@domandigital/craft 0.5.0 → 0.6.0

package/dist/index.cjs

@@ -20,23 +20,51 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AI_PHRASES: () => AI_PHRASES,
+  AI_VIOLET: () => AI_VIOLET,
+  AI_WORDS: () => AI_WORDS,
+  BUZZWORDS: () => BUZZWORDS,
+  CATALOGUE: () => CATALOGUE,
+  CATALOGUE_VERSION: () => CATALOGUE_VERSION,
+  CHOICE_KEYS: () => CHOICE_KEYS,
   DENSITIES: () => DENSITIES,
   DENSITY_NAMES: () => DENSITY_NAMES,
+  DIRECTION_VERSION: () => DIRECTION_VERSION,
+  DISTANCE_WEIGHTS: () => DISTANCE_WEIGHTS,
   DURATION_MS: () => DURATION_MS,
   DURATION_S: () => DURATION_S,
   EASE: () => EASE,
   EASE_TUPLE: () => EASE_TUPLE,
   EXIT_RATIO: () => EXIT_RATIO,
+  FINGERPRINT_VERSION: () => FINGERPRINT_VERSION,
   HOUSE_BUDGET: () => HOUSE_BUDGET,
   HOUSE_TYPE: () => HOUSE_TYPE,
   LIGHTNESS_CURVE: () => LIGHTNESS_CURVE,
+  NEGATIVE_REASSURANCE: () => NEGATIVE_REASSURANCE,
+  PILL_LIMIT: () => PILL_LIMIT,
+  PLAINER_WORDS: () => PLAINER_WORDS,
+  PROPOSED: () => PROPOSED,
   RAMP_STEPS: () => RAMP_STEPS,
+  REFLEX_FONTS_1: () => REFLEX_FONTS_1,
+  REFLEX_FONTS_2: () => REFLEX_FONTS_2,
+  RENDERED_PATHS: () => RENDERED_PATHS,
+  REVEAL_LIMIT: () => REVEAL_LIMIT,
+  REVIEW_PHRASES: () => REVIEW_PHRASES,
   SCALE: () => SCALE,
+  SHADCN_LIMIT: () => SHADCN_LIMIT,
+  SHADCN_PRIMITIVES: () => SHADCN_PRIMITIVES,
+  SNAPSHOT_VERSION: () => SNAPSHOT_VERSION,
+  SOURCE_KINDS: () => SOURCE_KINDS,
   SPACE_STEPS: () => SPACE_STEPS,
   SPRING: () => SPRING,
+  STOCK_PHRASES: () => STOCK_PHRASES,
   TYPE_STEPS: () => TYPE_STEPS,
+  VAGUE_WORDS: () => VAGUE_WORDS,
   accentFork: () => accentFork,
   apcaContrast: () => apcaContrast,
+  auditSnapshot: () => auditSnapshot,
+  catalogueTable: () => catalogueTable,
+  checkCopy: () => checkCopy,
   checkPair: () => checkPair,
   checkRestraint: () => checkRestraint,
   craftTokens: () => craftTokens,
@@ -46,26 +74,44 @@ __export(index_exports, {
   densityTokens: () => densityTokens,
   emitCss: () => emitCss,
   exitDuration: () => exitDuration,
+  findColours: () => findColours,
+  fingerprint: () => fingerprint,
+  fingerprintDistance: () => fingerprintDistance,
   fluidClamp: () => fluidClamp,
   fluidSpace: () => fluidSpace,
   fluidType: () => fluidType,
+  fontClass: () => fontClass,
   formatHex: () => formatHex,
+  formatReport: () => formatReport,
   hexToOklch: () => hexToOklch,
   inP3Gamut: () => inP3Gamut,
   inSrgbGamut: () => inSrgbGamut,
+  initDirection: () => initDirection,
+  isAiViolet: () => isAiViolet,
+  isCream: () => isCream,
+  makeSnapshot: () => makeSnapshot,
   motionTokens: () => motionTokens,
+  nearest: () => nearest,
+  normaliseFamily: () => normaliseFamily,
   oklchToHex: () => oklchToHex,
   oklchToRgb: () => oklchToRgb,
+  paletteFromPixels: () => paletteFromPixels,
+  parseColour: () => parseColour,
   parseHex: () => parseHex,
+  propose: () => propose,
   ramp: () => ramp,
   rampFromAnchors: () => rampFromAnchors,
+  runTell: () => runTell,
+  scanSource: () => scanSource,
   sectionRhythm: () => sectionRhythm,
   semantic: () => semantic,
   shouldAnimate: () => shouldAnimate,
   tailwindV3Preset: () => tailwindV3Preset,
   tailwindV4Theme: () => tailwindV4Theme,
+  tellById: () => tellById,
   toGamut: () => toGamut,
   typeFeatureTokens: () => typeFeatureTokens,
+  validateDirection: () => validateDirection,
   wcagContrast: () => wcagContrast
 });
 module.exports = __toCommonJS(index_exports);
@@ -78,11 +124,11 @@ function srgbToLinear(c) {
 function linearToSrgb(c) {
   return c <= 31308e-7 ? c * 12.92 : 1.055 * Math.pow(c, 1 / 2.4) - 0.055;
 }
-function parseHex(hex) {
-  const raw = hex.trim().replace(/^#/, "");
+function parseHex(hex2) {
+  const raw = hex2.trim().replace(/^#/, "");
   const expanded = raw.length === 3 || raw.length === 4 ? raw.slice(0, 3).split("").map((ch) => ch + ch).join("") : raw.slice(0, 6);
   if (!/^[0-9a-fA-F]{6}$/.test(expanded)) {
-    throw new Error(`craft: not a hex colour: ${JSON.stringify(hex)}`);
+    throw new Error(`craft: not a hex colour: ${JSON.stringify(hex2)}`);
   }
   return {
     r: parseInt(expanded.slice(0, 2), 16) / 255,
@@ -141,8 +187,8 @@ function xyzToLinearP3(x, y, z) {
   ];
 }
 var RAD = 180 / Math.PI;
-function hexToOklch(hex) {
-  const { r, g, b } = parseHex(hex);
+function hexToOklch(hex2) {
+  const { r, g, b } = parseHex(hex2);
   const [L, A, B] = linearRgbToOklab(srgbToLinear(r), srgbToLinear(g), srgbToLinear(b));
   const c = Math.sqrt(A * A + B * B);
   const h = c < 1e-7 ? 0 : (Math.atan2(B, A) * RAD % 360 + 360) % 360;
@@ -289,11 +335,11 @@ function rampFromAnchors(anchors, options = {}) {
         h: ((lo.h + hueDelta(lo.h, hi.h) * t) % 360 + 360) % 360
       };
     } else {
-      const nearest = below ?? above;
-      const base = parsed.get(nearest);
+      const nearest2 = below ?? above;
+      const base = parsed.get(nearest2);
       const lightness = warpLightness(
         LIGHTNESS_CURVE[step],
-        LIGHTNESS_CURVE[nearest],
+        LIGHTNESS_CURVE[nearest2],
         base.l
       );
       const baseEnvelope = chromaEnvelope(base.l);
@@ -306,8 +352,8 @@ function rampFromAnchors(anchors, options = {}) {
 }
 
 // src/color/contrast.ts
-function relativeLuminance(hex) {
-  const { r, g, b } = parseHex(hex);
+function relativeLuminance(hex2) {
+  const { r, g, b } = parseHex(hex2);
   const channel = (c) => c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
   return 0.2126 * channel(r) + 0.7152 * channel(g) + 0.0722 * channel(b);
 }
@@ -336,8 +382,8 @@ var APCA = {
   deltaYmin: 5e-4,
   loClip: 0.1
 };
-function apcaLuminance(hex) {
-  const { r, g, b } = parseHex(hex);
+function apcaLuminance(hex2) {
+  const { r, g, b } = parseHex(hex2);
   return APCA.Rco * Math.pow(r, APCA.mainTRC) + APCA.Gco * Math.pow(g, APCA.mainTRC) + APCA.Bco * Math.pow(b, APCA.mainTRC);
 }
 function softClamp(y) {
@@ -382,12 +428,12 @@ function accentFork(rampSteps, on, options = {}) {
   const order = darkBackgrounds ? [...RAMP_STEPS].reverse() : [...RAMP_STEPS];
   let best = null;
   for (const step of order) {
-    const hex = rampSteps[step];
-    const checks = on.map((bg) => checkPair(hex, bg));
+    const hex2 = rampSteps[step];
+    const checks = on.map((bg) => checkPair(hex2, bg));
     const clears = checks.every((c) => c.wcag >= minWcag && Math.abs(c.lc) >= minLc);
     if (clears) {
       return {
-        hex,
+        hex: hex2,
         step,
         checks,
         note: checks.map((c) => c.note).join("; "),
@@ -906,8 +952,8 @@ function resolveValue(value, props, depth = 0) {
   return fallback === void 0 || fallback === "" ? null : resolveValue(fallback, props, depth + 1);
 }
 function isVarOnlyList(value) {
-  const parts = value.split(",");
-  return parts.length > 1 && parts.every((part) => /^\s*var\(\s*--[\w-]+\s*\)\s*$/.test(part));
+  const parts2 = value.split(",");
+  return parts2.length > 1 && parts2.every((part) => /^\s*var\(\s*--[\w-]+\s*\)\s*$/.test(part));
 }
 function distinctValues(css, property, props, unresolved) {
   const pattern = new RegExp(`(?:^|[;{\\s])${property}\\s*:\\s*([^;}]+)`, "gi");
@@ -1002,7 +1048,7 @@ function checkRestraint(input) {
     );
   }
   const families = distinctValues(css, "font-family", props, unresolved).filter(
-    (f) => !/\bmonospace\b|\bmono\b/.test(f)
+    (f3) => !/\bmonospace\b|\bmono\b/.test(f3)
   );
   if (families.length > budget.maxFontFamilies) {
     push(
@@ -1049,9 +1095,9 @@ function checkRestraint(input) {
     ...css.matchAll(/--[a-z0-9-]*accent[a-z0-9-]*\s*:\s*(#[0-9a-fA-F]{3,8})/g)
   ].map((m) => m[1]);
   if (accentHexes.length > 1) {
-    const hues = accentHexes.map((hex) => {
+    const hues = accentHexes.map((hex2) => {
       try {
-        const { c, h } = hexToOklch(hex);
+        const { c, h } = hexToOklch(hex2);
         return c > 0.02 ? h : null;
       } catch {
         return null;
@@ -1319,25 +1365,2759 @@ function tailwindV4Theme() {
 `;
 }
 var DENSITY_NAMES = Object.keys(DENSITIES);
+
+// src/character/tells/copy.ts
+var f = (path, text) => ({ path, text });
+var isProsePath = (path) => /\.(md|markdown|mdx|txt)$/i.test(path);
+function allText(ctx) {
+  return [...ctx.blocks.filter((b) => isProsePath(b.path)), ...ctx.strings.filter((b) => !isProsePath(b.path))];
+}
+function phrases(patterns, label, source = (ctx) => ctx.blocks, skip = () => false) {
+  return (ctx) => {
+    const hits = [];
+    for (const block of source(ctx)) {
+      const spans = [];
+      for (const pattern of patterns) {
+        const global = new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`);
+        for (const m of block.text.matchAll(global)) {
+          if (skip(block, m[0], m.index ?? 0)) continue;
+          spans.push([m.index ?? 0, (m.index ?? 0) + m[0].length, m[0]]);
+        }
+      }
+      spans.sort((a, b) => a[0] - b[0]);
+      let end = -1;
+      for (const [start, stop, text] of spans) {
+        if (start < end) continue;
+        end = stop;
+        const lead = text.length - text.trimStart().length;
+        hits.push({ path: block.path, offset: block.offset + start + lead, message: label(text.trim()) });
+      }
+    }
+    return hits;
+  };
+}
+var escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/'/g, "['\u2019]?").replace(/ /g, "\\s+");
+var wordList = (words2) => new RegExp(`\\b(?:${[...words2].sort((a, b) => b.length - a.length).map(escape).join("|")})\\b`, "i");
+var quoted = (m) => `"${m}"`;
+var AI_WORDS = [
+  "tapestry",
+  "testament",
+  "realm",
+  "embark",
+  "embarking",
+  "unleash",
+  "unlocks",
+  "unlocking",
+  "elevate",
+  "elevates",
+  "elevated",
+  "elevating",
+  "bustling",
+  "nestled",
+  "meticulous",
+  "meticulously",
+  "paramount",
+  "furthermore",
+  "moreover",
+  "navigating",
+  "ever-evolving",
+  "unparalleled"
+];
+var STOCK_PHRASES = [
+  "in today's digital age",
+  "to the next level",
+  "one-stop shop",
+  "second to none",
+  "we pride ourselves",
+  "passionate about",
+  "your journey",
+  "our journey",
+  "curated",
+  "crafted with care",
+  "tailored to your",
+  "peace of mind"
+];
+var AI_PHRASES = [
+  "let's dive in",
+  "dive into",
+  "let's unpack",
+  "let's break this down",
+  "let's break it down",
+  "here's the thing",
+  "it's important to note",
+  "it's important to remember",
+  "it is worth noting that",
+  "at its core",
+  "the key takeaway",
+  "the reality is",
+  "the truth is",
+  "increasingly digital",
+  "seamless",
+  "seamlessly",
+  "unlock your",
+  "unlock the power",
+  "meaningful impact",
+  "drive meaningful",
+  "foster collaboration",
+  "fosters collaboration",
+  "fostering collaboration",
+  "comprehensive guide to",
+  "look no further",
+  "in the event that",
+  "at no additional cost to you",
+  "rest assured",
+  "when it comes to",
+  "we have got you covered",
+  "we've got you covered"
+];
+var PLAINER_WORDS = [
+  "empower",
+  "empowers",
+  "empowered",
+  "empowering",
+  "harness",
+  "harnesses",
+  "harnessed",
+  "harnessing",
+  "delve",
+  "delves",
+  "delved",
+  "delving",
+  "leverage",
+  "leverages",
+  "leveraged",
+  "leveraging"
+];
+var BUZZWORDS = [
+  "synergy",
+  "synergise",
+  "synergize",
+  "cutting-edge",
+  "cutting edge",
+  "best-in-class",
+  "best in class",
+  "best of breed",
+  "game-changer",
+  "game changer",
+  "paradigm shift",
+  "world-class",
+  "state of the art",
+  "state-of-the-art",
+  "mission-critical",
+  "low-hanging fruit",
+  "move the needle",
+  "circle back",
+  "touch base",
+  "reach out",
+  "value-add",
+  "robust",
+  "turnkey",
+  "holistic",
+  "disruptive"
+];
+var NEGATIVE_REASSURANCE = [
+  "no risk",
+  "never locked in",
+  "nothing goes wrong",
+  "no hidden fees",
+  "never pay",
+  "without the hassle",
+  "no surprises"
+];
+var VAGUE_WORDS = ["innovative", "scalable", "end-to-end", "streamline", "solutions"];
+var REVIEW_PHRASES = [
+  "great question",
+  "of course!",
+  "absolutely!",
+  "absolutely,",
+  "truly",
+  "genuinely",
+  "deeply",
+  "ultimately",
+  "one-size-fits-all",
+  "one size fits all",
+  "let me know if you'd",
+  "the single most",
+  "by far the most",
+  "hands down the",
+  "arguably the best",
+  "bar none"
+];
+var NEGATION = [
+  // "It's not just a haircut, it's an experience."
+  /\b(?:it['’]?s|it is|this is|this isn['’]t|we['’]re|we are|they['’]re)\s+(?:not|more than)\s+(?:just|only|merely|simply)?\s*[^.!?\n]{1,60}?[,;.—-]\s*(?:it['’]?s|it is|this is|we['’]re|we are|they['’]re)\b/i,
+  /\bmore\s+than\s+just\b/i,
+  // copular: "It's not a website, it's a growth engine"
+  /\b(?:it|that|this|you|we|they|she|he)(?:’s|'s|’re|'re)\s+not\s+[^.;:]{2,50}[,:]\s*(?:it|that|this|you|we|they|she|he)(?:’s|'s|’re|'re)/i,
+  // verbal: "I don't teach the treatment you'd choose: I teach the standard"
+  /\b(i|we|you|they|she|he)\s+(?:do|does|did|would|will|ca|wo)(?:n’t|n't)\s+(\w+)\b[^.;:]{2,60}[,:]\s*(?:i|we|you|they|she|he)\s+\2\b/i,
+  /\bnot\s+(?:just|merely|simply)\b/i,
+  // "X isn't a job, it's art"
+  /\b(?:is|are|was|were)(?:n’t|n't)\b[^.;]{2,60},\s*(?:it|they|that|this)(?:’s|'s|’re|'re)\b/i,
+  /\bless\s+about\b[^.;]{2,50}\bmore\s+about\b/i,
+  // parallel participle, no repeated subject: "dispatched from here, not shipped in from Seoul"
+  /\b\w{3,}ed\b[^,.;:]{0,40},\s*not\s+\w{3,}ed\b/i
+];
+var DATA_ABSENCE = /\b(?:yet|found|available|configured|selected|assigned|scheduled|recorded|on file|to show|to display|results|match|matches|matching|data|in this period)\b/i;
+var SIGNED_IN = /(?:^|\/)(?:admin|portal|dashboard|embedded)\//;
+function lineAround(text, index) {
+  const start = text.lastIndexOf("\n", index) + 1;
+  const end = text.indexOf("\n", index);
+  return text.slice(start, end === -1 ? text.length : end);
+}
+var emptyState = (block, match, index = 0) => SIGNED_IN.test(block.path) || DATA_ABSENCE.test(isProsePath(block.path) ? lineAround(block.text, index) : block.text) || DATA_ABSENCE.test(match);
+var NO_X_NO_Y = /\bno\s+[\w'’ ]{2,30},\s*no\s+\w/i;
+var NO_X_BADGE = /^no\s+[\w'’\- ]{2,28}[.!]?$/i;
+var EMOJI = /[\u{1F300}-\u{1FAFF}\u{1F1E6}-\u{1F1FF}]+/u;
+var placeholderDash = (block) => block.literal === true && /^[\s—]*$/.test(block.text);
+function badgeHits(ctx) {
+  const hits = [];
+  for (const block of ctx.strings) {
+    let text = block.text;
+    let lead = text.length - text.trimStart().length;
+    if (isProsePath(block.path)) {
+      if (/^\s*#{1,6}\s/.test(text) || /[<>{}=;]/.test(text)) continue;
+      const bullet = text.trimStart().match(/^[-*]\s+/);
+      if (bullet) lead += bullet[0].length;
+      text = text.slice(lead);
+    }
+    const candidate = text.trim();
+    if (NO_X_BADGE.test(candidate) && !emptyState(block, candidate)) {
+      hits.push({ path: block.path, offset: block.offset + lead, message: quoted(candidate) });
+    }
+  }
+  return hits;
+}
+var COPY_TELLS = [
+  {
+    id: "ai-vocabulary",
+    name: "AI vocabulary",
+    generation: 1,
+    severity: "warn",
+    surface: "copy",
+    why: "Tapestry, elevate, nestled, unparalleled: words that appear in generated copy far more than in anything a business owner writes.",
+    fix: "Say the plain thing. 'Elevate your look' becomes what actually happens: 'Gel that lasts three weeks'.",
+    detect: phrases([wordList(AI_WORDS), /\bunlock\b(?!\s+(?:your|the power))/i], quoted),
+    fixtures: {
+      flag: [f("content/home.md", "Elevate your nails in our bustling studio."), f("content/home.md", "We unlock it for you.")],
+      pass: [f("content/home.md", "Gel nails that last three weeks. Book online in a minute.")]
+    }
+  },
+  {
+    id: "stock-phrase",
+    name: "Stock phrase",
+    generation: 1,
+    severity: "warn",
+    surface: "copy",
+    why: "Phrases every generated services page uses. They fill space where a fact should be.",
+    fix: "Replace the phrase with the fact behind it: a number, a name, a place, a time.",
+    detect: phrases([wordList(STOCK_PHRASES)], quoted),
+    fixtures: {
+      flag: [f("content/home.md", "Take your plumbing to the next level with peace of mind.")],
+      pass: [f("content/home.md", "Gas Safe registered since 2009. Same-day callouts in Brackley.")]
+    }
+  },
+  {
+    id: "ai-phrase",
+    name: "AI phrase",
+    generation: 1,
+    severity: "warn",
+    surface: "copy",
+    why: "Let's dive in, here's the thing, at its core, seamless, rest assured: the phrase list of the house copy rules. A reader has seen each one in a thousand generated pages.",
+    fix: "Cut the phrase and start with the point it was introducing. 'Seamless booking' becomes 'Book in three taps'.",
+    detect: phrases(
+      [
+        wordList(AI_PHRASES),
+        /\bin today['’]?s (?:rapidly )?(?:evolving|changing|fast-paced)\b/i,
+        /\bwhether you['’]re an? [^.,;]{2,30} or\b/i
+      ],
+      quoted
+    ),
+    fixtures: {
+      flag: [
+        f("content/home.md", "Let's dive in to what we do."),
+        f("content/home.md", "In today's rapidly evolving market, we help."),
+        f("content/home.md", "Whether you're a landlord or a tenant, call us.")
+      ],
+      pass: [f("content/home.md", "Book in three taps. We confirm by text within the hour.")]
+    }
+  },
+  {
+    id: "plainer-word",
+    name: "A plainer word exists",
+    generation: 1,
+    severity: "warn",
+    surface: "copy",
+    why: "Empower, leverage, harness, delve: each stands in for a plainer verb, and the swap is a reliable sign nobody chose the word.",
+    fix: "Name the mechanism instead. 'Empower your team' becomes 'Your team can publish without us'.",
+    detect: phrases([wordList(PLAINER_WORDS)], quoted),
+    fixtures: {
+      flag: [f("content/home.md", "We empower small firms to grow.")],
+      pass: [f("content/home.md", "Small firms can publish without waiting for us.")]
+    }
+  },
+  {
+    id: "plain-english",
+    name: "'Plain English'",
+    generation: 2,
+    severity: "warn",
+    surface: "copy",
+    why: "Told to avoid jargon, a model announces that it is avoiding jargon. 'Explained plainly' swaps a synonym and keeps the tell.",
+    fix: "Use the house replacement, 'properly explained', or drop the claim and let the copy show it.",
+    detect: phrases([/\b(?:plain english|explained plainly|plainly explained)\b/i], quoted),
+    fixtures: {
+      flag: [f("content/home.md", "Your options, in plain English.")],
+      pass: [f("content/home.md", "Your options, properly explained.")]
+    }
+  },
+  {
+    id: "buzzword",
+    name: "Buzzword",
+    generation: 1,
+    severity: "warn",
+    surface: "copy",
+    why: "Cutting-edge, world-class, reach out, turnkey: corporate filler older than any model, and still the first thing a model writes about a business it knows nothing about.",
+    fix: "Say what is actually true. 'World-class service' becomes 'We answer the phone until 8pm'. 'Reach out' becomes 'get in touch'.",
+    detect: phrases([wordList(BUZZWORDS)], quoted),
+    fixtures: {
+      flag: [f("content/home.md", "Reach out for world-class plumbing.")],
+      pass: [f("content/home.md", "Get in touch. We answer until 8pm.")]
+    }
+  },
+  {
+    id: "negative-reassurance",
+    name: "Negative reassurance",
+    generation: 1,
+    severity: "warn",
+    surface: "copy",
+    why: "'No hidden fees', 'no surprises', 'never locked in' reassure by naming the fear, and plant it in a reader who did not have it.",
+    fix: "Say what they get: 'The price on the quote is the price you pay', 'Cancel any month'.",
+    detect: phrases([wordList(NEGATIVE_REASSURANCE)], quoted),
+    fixtures: {
+      flag: [f("content/home.md", "Clear pricing with no hidden fees.")],
+      pass: [f("content/home.md", "The price on the quote is the price you pay.")]
+    }
+  },
+  {
+    id: "vague-word",
+    name: "Vague word",
+    generation: 1,
+    severity: "warn",
+    surface: "copy",
+    why: "Innovative, scalable, end-to-end, solutions: each can be true, and each is used where the writer had nothing specific to say.",
+    fix: "Replace it with the specific thing. 'Innovative solutions' becomes the actual product and what it does.",
+    detect: phrases([wordList(VAGUE_WORDS)], quoted),
+    fixtures: {
+      flag: [f("content/home.md", "Innovative solutions for every business.")],
+      pass: [f("content/home.md", "Rewires, fuse boards and EV chargers across Northamptonshire.")]
+    }
+  },
+  {
+    id: "review-phrase",
+    name: "Review-tier phrase",
+    generation: 1,
+    severity: "warn",
+    surface: "copy",
+    why: "Truly, genuinely, ultimately, 'the single most', 'bar none': normal English once, and a tell when they stack. The house rules keep them for review, never blocking.",
+    fix: "Keep the one that lands hardest and cut the rest. 'What is genuinely excellent' reads better as 'what is excellent'.",
+    detect: phrases([new RegExp(`(?:^|\\b)(?:${[...REVIEW_PHRASES].sort((a, b) => b.length - a.length).map((p) => escape(p).replace(/^(\w)/, "\\b$1")).join("|")})`, "i")], quoted),
+    fixtures: {
+      flag: [f("content/home.md", "We are truly proud of it.")],
+      pass: [f("content/home.md", "We have fitted 400 boilers since 2009.")]
+    }
+  },
+  {
+    id: "hollow-imperative",
+    name: "Hollow imperative",
+    generation: 1,
+    severity: "warn",
+    surface: "copy",
+    why: "'Discover', 'Experience', 'Transform your' as the opening verb of a heading or button is a call to action with nothing in it.",
+    fix: "Name the action and the outcome: 'Book a 45-minute facial', not 'Experience the difference'.",
+    detect: phrases(
+      [/(?:^|[.!?]\s+|\n\s*|>\s*)(?:Discover|Experience|Explore|Transform|Indulge in|Embrace|Unlock|Elevate)\s+(?:the|your|our|a|true|real)\b[^.!?\n<]{0,40}/],
+      (m) => `"${m.replace(/^[.!?>\s]+/, "")}"`
+    ),
+    fixtures: {
+      flag: [f("content/home.md", "Experience the difference today.")],
+      pass: [f("content/home.md", "Book a 45-minute facial.")]
+    }
+  },
+  {
+    id: "rhetorical-opener",
+    name: "Rhetorical question opener",
+    generation: 1,
+    severity: "warn",
+    surface: "copy",
+    why: "'Looking for...?', 'Tired of...?', 'Ready to...?' opens with the model guessing at the reader instead of telling them something.",
+    fix: "Open with the answer.",
+    detect: phrases([/(?:^|\n\s*|>\s*)(?:Looking for|Tired of|Ready to|Want to|Struggling with|Need a)\b[^?\n<]{0,80}\?/], (m) => `"${m.replace(/^[>\s]+/, "")}"`),
+    fixtures: {
+      flag: [f("content/home.md", "Looking for a reliable plumber?")],
+      pass: [f("content/home.md", "A plumber in Brackley, on call until 10pm.")]
+    }
+  },
+  {
+    id: "em-dash",
+    name: "Em dash",
+    generation: 2,
+    severity: "warn",
+    surface: "copy",
+    why: "Generated copy leans on the em dash to join clauses. House copy does not use it.",
+    fix: "Use a full stop, a comma, or a colon. Two sentences are clearer than one sentence with a dash in it.",
+    detect: phrases([/\S{0,20}\s?—\s?\S{0,20}/], quoted, (ctx) => ctx.strings, (block) => placeholderDash(block)),
+    fixtures: {
+      flag: [
+        f("content/home.md", "Walk-ins welcome \u2014 just ring first."),
+        f("app/hours.tsx", `export const hours = { weekdays: "Mon \u2014 Fri" };`)
+      ],
+      pass: [
+        f("content/home.md", "Walk-ins welcome. Ring first. Open 9-5."),
+        f("app/row.tsx", `export const Cell = ({ v }) => <td>{v ?? "\u2014"}</td>;`),
+        f("app/row.tsx", `export const Empty = () => <td className="muted">\u2014</td>;`)
+      ]
+    }
+  },
+  {
+    id: "emoji",
+    name: "Emoji in copy",
+    generation: 1,
+    severity: "warn",
+    surface: "copy",
+    why: "A sparkle or a rocket beside a heading is decoration a model adds to seem friendly. It dates the page and reads as a social post.",
+    fix: "Remove it. Typographic marks are fine: a star for a rating, a middot as a separator, an arrow in a link.",
+    detect: phrases([new RegExp(EMOJI.source, "u")], (m) => `emoji ${m}`, (ctx) => ctx.strings),
+    fixtures: {
+      flag: [f("content/home.md", "New treatments this month \u2728\u{1F680}"), f("app/cta.tsx", `export const label = "Book \u{1F680}";`)],
+      pass: [f("content/home.md", "Rated \u2605\u2605\u2605\u2605\u2605 \xB7 Book now \u2192")]
+    }
+  },
+  {
+    id: "not-just-but",
+    name: "Contrastive negation",
+    generation: 2,
+    severity: "warn",
+    surface: "copy",
+    why: "'It's not just a haircut, it's an experience', 'dispatched from here, not shipped in': the contrast-and-reveal template is the most recognisable construction in generated copy.",
+    fix: "Say the positive claim and drop the contrast.",
+    detect: phrases(NEGATION, quoted, allText),
+    fixtures: {
+      flag: [
+        f("content/home.md", "It's not just a haircut, it's an experience."),
+        f("content/home.md", "It's not a website, it's a growth engine."),
+        f("content/home.md", "I don't teach the treatment you'd choose: I teach the standard."),
+        f("content/home.md", "Hairdressing isn't a job, it's art."),
+        f("content/home.md", "It is less about the tools and more about the eye."),
+        f("content/home.md", "Order today and it's dispatched from here, not shipped in from Seoul."),
+        f("app/offer.tsx", `export const outcome = "The whole path, not just the ads.";`)
+      ],
+      pass: [
+        f("content/home.md", "A haircut, a hot towel and a straight-razor finish."),
+        f("content/home.md", "They are cosmetics, not medicines."),
+        f("content/home.md", "The box arrived red, not led astray by a dented corner.")
+      ]
+    }
+  },
+  {
+    id: "no-x-no-y",
+    name: "'No X, no Y' list",
+    generation: 2,
+    severity: "warn",
+    surface: "copy",
+    why: "'No obligation, no spam.' Defining the business by what it is not, itemised, is the same template as contrastive negation.",
+    fix: "Say what they get: 'We reply within a day and only about your enquiry'.",
+    detect: phrases([NO_X_NO_Y], quoted, allText, emptyState),
+    fixtures: {
+      flag: [
+        f("content/home.md", "We reply within a day. No obligation, no spam."),
+        f("app/hero.tsx", `export const Hero = () => <p className="mt-4">We reply within a day. No
+  obligation, no spam.</p>;`)
+      ],
+      pass: [
+        f("content/home.md", "We reply within a day, and only about your enquiry."),
+        f("app/admin/list.tsx", `export const Empty = () => <p>No clients, no bookings.</p>;`),
+        f("app/list.tsx", `export const Empty = () => <p>No orders yet, no invoices found.</p>;`)
+      ]
+    }
+  },
+  {
+    id: "no-x-badge",
+    name: "'No X' badge",
+    generation: 2,
+    severity: "warn",
+    surface: "copy",
+    why: "'No catch.', 'NO JARGON GUIDE': a short standalone 'No X' reads as a slapped-on kicker, and worse when the same one is reused across pieces.",
+    fix: "Replace it with the positive fact it hints at, or cut it.",
+    detect: badgeHits,
+    fixtures: {
+      flag: [f("app/badge.tsx", `export const kicker = "No catch.";`), f("content/home.md", "Straight answers.\n\nNo jargon guide\n")],
+      pass: [
+        f("app/list.tsx", `export const empty = "No results found.";`),
+        f("app/portal/list.tsx", `export const empty = "No bookings";`),
+        f("content/home.md", "### No clarity on ideal client\n")
+      ]
+    }
+  },
+  {
+    id: "staccato-triplet",
+    name: "Staccato triplet",
+    generation: 2,
+    severity: "warn",
+    surface: "copy",
+    why: "Three fragments in a row ('Fast. Friendly. Local.' or 'No fuss. No jargon. Just results.') is the second wave's favourite rhythm.",
+    fix: "Write one sentence that says which of the three is true, and how you know.",
+    detect: phrases([/(?:\b[A-Z][\w'’-]*(?:\s+[\w'’-]+){0,2}[.!]\s+){2}[A-Z][\w'’-]*(?:\s+[\w'’-]+){0,2}[.!](?=\s|$)/], quoted),
+    fixtures: {
+      flag: [f("content/home.md", "No fuss. No jargon. Just results.")],
+      pass: [f("content/home.md", "We fix boilers the same day, and we tell you the price before we start.")]
+    }
+  },
+  {
+    id: "where-x-meets-y",
+    name: "'Where X meets Y'",
+    generation: 2,
+    severity: "warn",
+    surface: "copy",
+    why: "'Where luxury meets comfort' is a tagline shape that fits every business and so describes none.",
+    fix: "Say what the place is and where it is.",
+    detect: phrases([/\bwhere\s+[\w'’-]+(?:\s+[\w'’-]+)?\s+meets?\s+[\w'’-]+/i], quoted),
+    fixtures: {
+      flag: [f("content/home.md", "Where luxury meets comfort.")],
+      pass: [f("content/home.md", "A two-chair studio above the bakery on Market Place.")]
+    }
+  }
+];
+
+// src/character/color.ts
+var COLOUR = /#[0-9a-fA-F]{8}\b|#[0-9a-fA-F]{6}\b|#[0-9a-fA-F]{3,4}\b|\b(?:rgba?|hsla?|oklch|oklab)\([^)]*\)|\bcolor\(\s*srgb\b[^)]*\)/g;
+function num(token, percentOf) {
+  const t = token.trim();
+  if (t.endsWith("%")) return parseFloat(t) / 100 * percentOf;
+  return parseFloat(t);
+}
+function parts(fn) {
+  const inner = fn.slice(fn.indexOf("(") + 1, -1).trim();
+  const [main, slashAlpha] = inner.split("/");
+  const channels = main.split(/[\s,]+/).filter(Boolean);
+  let alpha = 1;
+  if (slashAlpha !== void 0) alpha = num(slashAlpha, 1);
+  else if (channels.length === 4) alpha = num(channels.pop(), 1);
+  return { channels, alpha: Number.isFinite(alpha) ? alpha : 1 };
+}
+function hslToRgb(h, s, l) {
+  const k = (n) => (n + h / 30) % 12;
+  const a = s * Math.min(l, 1 - l);
+  const f3 = (n) => l - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
+  return { r: f3(0), g: f3(8), b: f3(4) };
+}
+var clamp012 = (n) => Math.min(1, Math.max(0, n));
+function parseColour(raw) {
+  try {
+    if (raw.startsWith("#")) {
+      const hex2 = raw.slice(1);
+      const alpha2 = hex2.length === 8 ? parseInt(hex2.slice(6), 16) / 255 : hex2.length === 4 ? parseInt(hex2[3] + hex2[3], 16) / 255 : 1;
+      return { oklch: hexToOklch(raw), alpha: alpha2 };
+    }
+    const fn = raw.slice(0, raw.indexOf("(")).toLowerCase();
+    if (fn === "color") {
+      const { channels: channels2, alpha: alpha2 } = parts(raw.replace(/^color\(\s*srgb\s+/i, "srgb("));
+      const [r, g, b] = channels2.map((c) => clamp012(num(c, 1)));
+      if (![r, g, b].every(Number.isFinite)) return null;
+      return { oklch: hexToOklch(formatHex({ r, g, b })), alpha: alpha2 };
+    }
+    const { channels, alpha } = parts(raw);
+    if (channels.length < 3 || channels.some((c) => c.startsWith("var"))) return null;
+    if (fn === "oklch") {
+      const l = num(channels[0], 1);
+      const c = num(channels[1], 0.4);
+      const h = parseFloat(channels[2]);
+      if (![l, c].every(Number.isFinite)) return null;
+      return { oklch: { l, c, h: Number.isFinite(h) ? h : 0 }, alpha };
+    }
+    if (fn === "oklab") {
+      const l = num(channels[0], 1);
+      const a = num(channels[1], 0.4);
+      const b = num(channels[2], 0.4);
+      if (![l, a, b].every(Number.isFinite)) return null;
+      const c = Math.sqrt(a * a + b * b);
+      const h = c < 1e-7 ? 0 : (Math.atan2(b, a) * 180 / Math.PI % 360 + 360) % 360;
+      return { oklch: { l, c, h }, alpha };
+    }
+    if (fn === "rgb" || fn === "rgba") {
+      const [r, g, b] = channels.map((c) => clamp012(num(c, 255) / 255));
+      if (![r, g, b].every(Number.isFinite)) return null;
+      return { oklch: hexToOklch(formatHex({ r, g, b })), alpha };
+    }
+    if (fn === "hsl" || fn === "hsla") {
+      const h = parseFloat(channels[0]);
+      const s = num(channels[1], 1);
+      const l = num(channels[2], 1);
+      if (![h, s, l].every(Number.isFinite)) return null;
+      const rgb = hslToRgb((h % 360 + 360) % 360, clamp012(s), clamp012(l));
+      return { oklch: hexToOklch(formatHex(rgb)), alpha };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function findColours(value) {
+  const out = [];
+  for (const m of value.matchAll(COLOUR)) {
+    const parsed = parseColour(m[0]);
+    if (parsed) out.push({ raw: m[0], ...parsed, index: m.index ?? 0 });
+  }
+  return out;
+}
+var AI_VIOLET = { hueMin: 268, hueMax: 312, minChroma: 0.1, minL: 0.3, maxL: 0.85 };
+function isAiViolet({ l, c, h }) {
+  return c >= AI_VIOLET.minChroma && h >= AI_VIOLET.hueMin && h <= AI_VIOLET.hueMax && l >= AI_VIOLET.minL && l <= AI_VIOLET.maxL;
+}
+function isCream({ l, c, h }) {
+  return l >= 0.9 && l <= 0.985 && c >= 8e-3 && c <= 0.06 && h >= 55 && h <= 105;
+}
+function isBlueToPurple({ c, h }) {
+  return c >= 0.08 && h >= 240 && h <= 330;
+}
+
+// src/character/tells/source.ts
+function baseClass(cls) {
+  let depth = 0;
+  let cut = 0;
+  for (let i = 0; i < cls.length; i += 1) {
+    if (cls[i] === "[") depth += 1;
+    else if (cls[i] === "]") depth -= 1;
+    else if (cls[i] === ":" && depth === 0) cut = i + 1;
+  }
+  return cls.slice(cut).replace(/^!/, "");
+}
+function bases(unit) {
+  return unit.classes.map(baseClass);
+}
+function has(unit, pattern) {
+  return bases(unit).some((c) => pattern.test(c));
+}
+function find(unit, pattern) {
+  return bases(unit).find((c) => pattern.test(c));
+}
+function arbitrary(cls) {
+  const m = cls.match(/\[(.*)\]$/);
+  return m ? m[1].replace(/_/g, " ") : null;
+}
+function eachUnit(ctx, fn) {
+  const hits = [];
+  for (const file of ctx.files) {
+    for (const unit of file.classUnits) {
+      const message = fn(unit, file);
+      if (message) hits.push({ path: file.path, offset: unit.offset, message });
+    }
+  }
+  return hits;
+}
+function firstMatch(text, pattern) {
+  const m = pattern.exec(text);
+  pattern.lastIndex = 0;
+  return m ? m.index : -1;
+}
+var FRAMEWORK_PALETTE = /^--(?:color-)?(?:slate|gray|zinc|neutral|stone|red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose)-\d+$|^--tw-/;
+var f2 = (path, text) => ({ path, text });
+function familyNames(value) {
+  return value.split(",").map((v) => v.trim().replace(/^["']|["']$/g, "").trim()).filter(Boolean);
+}
+function fontMentions(file) {
+  const out = [];
+  for (const d of file.declarations) {
+    if (d.property === "font-family" || d.property === "font" || d.property.startsWith("--font")) {
+      for (const name of familyNames(d.value)) out.push({ name, offset: d.offset });
+    }
+  }
+  const text = file.text;
+  for (const m of text.matchAll(/import\s*\{([^}]*)\}\s*from\s*["']next\/font\/google["']/g)) {
+    for (const spec of m[1].split(",")) {
+      const name = spec.trim().split(/\s+as\s+/)[0].replace(/_/g, " ").trim();
+      if (name) out.push({ name, offset: m.index ?? 0 });
+    }
+  }
+  for (const m of text.matchAll(/fonts\.googleapis\.com\/css2?\?[^"'\s)>]*/g)) {
+    for (const fam of m[0].matchAll(/family=([^&:;]+)/g)) {
+      out.push({ name: decodeURIComponent(fam[1]).replace(/\+/g, " "), offset: m.index ?? 0 });
+    }
+  }
+  for (const m of text.matchAll(/@fontsource(?:-variable)?\/([a-z0-9-]+)/g)) {
+    out.push({ name: m[1].replace(/-/g, " "), offset: m.index ?? 0 });
+  }
+  for (const m of text.matchAll(/\bfont-\[([^\]]+)\]/g)) {
+    for (const name of familyNames(m[1].replace(/_/g, " "))) out.push({ name, offset: m.index ?? 0 });
+  }
+  if (file.kind === "script" || file.kind === "markup") {
+    for (const m of text.matchAll(/fontFamily\s*[:=]\s*(\{[\s\S]*?\}|\[[^\]]*\]|["'][^"']*["'])/g)) {
+      for (const lit of m[1].matchAll(/["']([^"']+)["']/g)) {
+        for (const name of familyNames(lit[1])) out.push({ name, offset: (m.index ?? 0) + (lit.index ?? 0) });
+      }
+    }
+  }
+  return out;
+}
+function fontTell(fonts) {
+  const wanted = new Map(fonts.map((n) => [n.toLowerCase(), n]));
+  return (ctx) => {
+    const hits = [];
+    for (const file of ctx.files) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const { name, offset } of fontMentions(file)) {
+        const canonical = wanted.get(name.toLowerCase());
+        if (!canonical || seen.has(canonical)) continue;
+        seen.add(canonical);
+        hits.push({ path: file.path, offset, message: `${canonical} is a reflex font` });
+      }
+    }
+    return hits;
+  };
+}
+var REFLEX_FONTS_1 = ["Inter", "Roboto", "Open Sans", "Poppins", "Montserrat", "Lato"];
+var REFLEX_FONTS_2 = [
+  "Inter Tight",
+  "DM Sans",
+  "Manrope",
+  "Space Grotesk",
+  "Plus Jakarta Sans",
+  "Outfit",
+  "Geist",
+  "Sora",
+  "Instrument Sans",
+  "Instrument Serif",
+  "Fraunces",
+  "Playfair Display",
+  "Cormorant Garamond",
+  "DM Serif Display"
+];
+var TW_VIOLET = /^(?:bg|text|from|via|to|border|ring|fill|stroke|shadow|outline|decoration|accent|caret|divide)-(indigo|violet|purple)-([3-8]00)(?:\/[\w.[\]]+)?$/;
+function violetHits(ctx) {
+  const hits = [];
+  for (const file of ctx.files) {
+    const seen = /* @__PURE__ */ new Set();
+    const push = (key, offset, message) => {
+      if (seen.has(key)) return;
+      seen.add(key);
+      hits.push({ path: file.path, offset, message });
+    };
+    for (const unit of file.classUnits) {
+      for (const cls of bases(unit)) {
+        const tw = cls.match(TW_VIOLET);
+        if (tw) push(`${tw[1]}-${tw[2]}`, unit.offset, `${tw[1]}-${tw[2]} is the default AI accent`);
+        const arb = arbitrary(cls);
+        if (arb) {
+          for (const c of findColours(arb)) {
+            if (isAiViolet(c.oklch)) push(c.raw.toLowerCase(), unit.offset, `${c.raw} sits in the indigo-violet band (h ${c.oklch.h.toFixed(0)}\xB0)`);
+          }
+        }
+      }
+    }
+    for (const d of file.declarations) {
+      if (FRAMEWORK_PALETTE.test(d.property)) continue;
+      for (const c of findColours(d.value)) {
+        if (c.alpha >= 0.5 && isAiViolet(c.oklch)) {
+          push(c.raw.toLowerCase(), d.offset, `${c.raw} sits in the indigo-violet band (h ${c.oklch.h.toFixed(0)}\xB0)`);
+        }
+      }
+    }
+  }
+  return hits;
+}
+var BLUEISH = /^(?:blue|indigo|sky|cyan)$/;
+var PURPLEISH = /^(?:violet|purple|fuchsia|pink)$/;
+function gradientHits(ctx) {
+  const hits = eachUnit(ctx, (unit) => {
+    if (!has(unit, /^bg-(?:gradient-to|linear|radial|conic)/)) return null;
+    const stops = bases(unit).map((c) => c.match(/^(?:from|via|to)-([a-z]+)-\d+/)?.[1]).filter((x) => Boolean(x));
+    if (stops.some((s) => BLUEISH.test(s)) && stops.some((s) => PURPLEISH.test(s))) {
+      return `gradient from ${stops.join(" to ")}`;
+    }
+    return null;
+  });
+  for (const file of ctx.files) {
+    for (const d of file.declarations) {
+      if (!/gradient\(/.test(d.value) || FRAMEWORK_PALETTE.test(d.property)) continue;
+      const colours = findColours(d.value).filter((c) => isBlueToPurple(c.oklch));
+      if (colours.length < 2) continue;
+      const hues = colours.map((c) => c.oklch.h);
+      if (Math.max(...hues) - Math.min(...hues) >= 25) {
+        hits.push({ path: file.path, offset: d.offset, message: `gradient from ${colours.map((c) => c.raw).join(" to ")}` });
+      }
+    }
+  }
+  return hits;
+}
+var CREAM_CLASS = /^bg-(?:cream|ivory|parchment|linen|sand|oat|bone|eggshell)(?:-\d+)?(?:\/\d+)?$/;
+var BG_PROPERTY = /background|^--(?:color-)?(?:bg|background|surface|canvas|paper|cream|base|page)/;
+function creamHits(ctx) {
+  const hits = [];
+  for (const file of ctx.files) {
+    const seen = /* @__PURE__ */ new Set();
+    const push = (key, offset, message) => {
+      if (seen.has(key)) return;
+      seen.add(key);
+      hits.push({ path: file.path, offset, message });
+    };
+    for (const unit of file.classUnits) {
+      for (const cls of bases(unit)) {
+        if (CREAM_CLASS.test(cls)) push(cls, unit.offset, `${cls} is a cream ground`);
+        const arb = cls.startsWith("bg-") ? arbitrary(cls) : null;
+        if (arb) {
+          for (const c of findColours(arb)) if (isCream(c.oklch)) push(c.raw.toLowerCase(), unit.offset, `${c.raw} is a cream ground`);
+        }
+      }
+    }
+    for (const d of file.declarations) {
+      if (!BG_PROPERTY.test(d.property) || FRAMEWORK_PALETTE.test(d.property)) continue;
+      for (const c of findColours(d.value)) {
+        if (c.alpha >= 0.9 && isCream(c.oklch)) push(c.raw.toLowerCase(), d.offset, `${c.raw} is a cream ground`);
+      }
+    }
+  }
+  return hits;
+}
+function glassHits(ctx) {
+  const hits = eachUnit(
+    ctx,
+    (unit) => has(unit, /^backdrop-blur/) && has(unit, /^bg-[a-z]+(?:-\d+)?\/(?:\d+|\[[\d.]+\])$/) ? "translucent blurred panel" : null
+  );
+  for (const file of ctx.files) {
+    for (const d of file.declarations) {
+      if (/^(?:-webkit-)?backdrop-filter$/.test(d.property) && /blur\(/.test(d.value)) {
+        hits.push({ path: file.path, offset: d.offset, message: "backdrop blur panel" });
+      }
+    }
+  }
+  return hits;
+}
+function gradientTextHits(ctx) {
+  const hits = eachUnit(
+    ctx,
+    (unit) => has(unit, /^bg-clip-text$/) && has(unit, /^text-transparent$/) ? "gradient-filled text" : null
+  );
+  for (const file of ctx.files) {
+    for (const d of file.declarations) {
+      if (/^(?:-webkit-)?background-clip$/.test(d.property) && /\btext\b/.test(d.value)) {
+        hits.push({ path: file.path, offset: d.offset, message: "gradient-filled text" });
+      }
+    }
+  }
+  return hits;
+}
+function thinBorderWideShadowHits(ctx) {
+  const hits = eachUnit(ctx, (unit) => {
+    const faint = has(unit, /^border-(?:black|white)\/(?:[1-9]|10|\[0?\.\d+\])$|^border-(?:gray|slate|zinc|neutral|stone)-(?:50|100|200)(?:\/\d+)?$/);
+    const wide = has(unit, /^shadow-(?:xl|2xl)$/) || bases(unit).some((c) => c.startsWith("shadow-[") && Number((arbitrary(c) ?? "").split(/\s+/)[2]?.replace("px", "")) >= 24);
+    return faint && wide && has(unit, /^border$/) ? "hairline border under a wide soft shadow" : null;
+  });
+  for (const file of ctx.files) {
+    const bySelector = /* @__PURE__ */ new Map();
+    for (const d of file.declarations) {
+      const entry = bySelector.get(d.selector) ?? { offset: d.offset };
+      if (/^border(?:-top|-bottom)?$/.test(d.property) && /\b1px\b/.test(d.value)) {
+        const c = findColours(d.value)[0];
+        if (c && c.alpha <= 0.12) entry.border = d.offset;
+      }
+      if (d.property === "box-shadow") {
+        const blur = Math.max(...[...d.value.matchAll(/(?:^|,)\s*(?:inset\s+)?-?[\d.]+(?:px)?\s+-?[\d.]+(?:px)?\s+([\d.]+)px/g)].map((m) => Number(m[1])), 0);
+        if (blur >= 24) entry.shadow = d.offset;
+      }
+      bySelector.set(d.selector, entry);
+    }
+    for (const entry of bySelector.values()) {
+      if (entry.border !== void 0 && entry.shadow !== void 0) {
+        hits.push({ path: file.path, offset: entry.border, message: "hairline border under a wide soft shadow" });
+      }
+    }
+  }
+  return hits;
+}
+function glowHits(ctx) {
+  const hits = eachUnit(ctx, (unit) => {
+    if (bases(unit).some((c) => c.startsWith("bg-[radial-gradient"))) return "radial spotlight behind content";
+    const blob = has(unit, /^(?:absolute|fixed)$/) && has(unit, /^blur-(?:2xl|3xl|\[(?:[4-9]\d|\d{3,})px\])$/) && has(unit, /^(?:rounded-full|bg-gradient|bg-[a-z]+-\d+\/\d+|opacity-)/);
+    return blob ? "blurred glow blob" : null;
+  });
+  for (const file of ctx.files) {
+    for (const d of file.declarations) {
+      if (!/^background(?:-image)?$/.test(d.property) || !/radial-gradient\(/.test(d.value)) continue;
+      const colours = findColours(d.value);
+      if (/transparent/.test(d.value) || colours.some((c) => c.alpha < 0.5)) {
+        hits.push({ path: file.path, offset: d.offset, message: "radial spotlight fading to transparent" });
+      }
+    }
+  }
+  return hits;
+}
+function gridBackgroundHits(ctx) {
+  const hits = eachUnit(ctx, (unit) => {
+    if (has(unit, /^bg-(?:grid|dot|dots|graph)(?:-|$)/)) return "decorative grid background";
+    const arb = bases(unit).filter((c) => c.startsWith("bg-[") || c.startsWith("[background")).map((c) => arbitrary(c) ?? "");
+    const lines = arb.join(" ").match(/(?:linear|radial)-gradient\([^)]*\b1px\b/g) ?? [];
+    return lines.length > 0 ? "decorative grid background" : null;
+  });
+  for (const file of ctx.files) {
+    for (const d of file.declarations) {
+      if (!/^background(?:-image)?$/.test(d.property)) continue;
+      const lines = d.value.match(/(?:linear|radial)-gradient\([^;]*?\b1px\b/g) ?? [];
+      if (lines.length >= 1 && /gradient\([\s\S]*gradient\(/.test(d.value)) {
+        hits.push({ path: file.path, offset: d.offset, message: "decorative grid background" });
+      }
+    }
+  }
+  return hits;
+}
+function italicSerifHits(ctx) {
+  const hits = eachUnit(
+    ctx,
+    (unit) => has(unit, /^italic$/) && has(unit, /^font-(?:serif|display|heading|title|\[)/) && !has(unit, /^font-(?:sans|mono)$/) ? "italic serif display" : null
+  );
+  for (const file of ctx.files) {
+    for (const m of file.text.matchAll(/<h[1-3]\b[^>]*>(?:(?!<\/h[1-3]>)[\s\S]){0,200}?<(?:em|i)\b/g)) {
+      hits.push({ path: file.path, offset: m.index ?? 0, message: "italic word set inside a display heading" });
+    }
+    for (const d of file.declarations) {
+      if (d.property === "font-style" && d.value === "italic" && /(?:^|[\s,>])(?:h[1-3]|\.?(?:display|hero|headline|title))\b/i.test(d.selector)) {
+        hits.push({ path: file.path, offset: d.offset, message: `italic display type on ${d.selector}` });
+      }
+    }
+  }
+  return hits;
+}
+function eyebrowChipHits(ctx) {
+  const hits = [];
+  for (const file of ctx.files) {
+    const h1 = file.text.search(/<h1\b/);
+    if (h1 === -1) continue;
+    for (const unit of file.classUnits) {
+      if (unit.offset > h1 || h1 - unit.offset > 900) continue;
+      const chip = has(unit, /^rounded-full$/) && has(unit, /^(?:border|ring-1|bg-[a-z]+-\d+\/\d+|bg-[a-z]+-(?:50|100))$/) && has(unit, /^text-(?:xs|sm|\[1[0-3]px\])$/) && has(unit, /^px-(?:2|2\.5|3|3\.5|4)$/);
+      if (chip) hits.push({ path: file.path, offset: unit.offset, message: "pill badge above the hero heading" });
+    }
+  }
+  return hits;
+}
+function iconTiles(file) {
+  return file.classUnits.filter((unit) => {
+    const sized = has(unit, /^size-(?:8|9|10|11|12|14)$/) || (find(unit, /^h-(?:8|9|10|11|12|14)$/) ?? "x").slice(2) === (find(unit, /^w-(?:8|9|10|11|12|14)$/) ?? "y").slice(2);
+    return sized && has(unit, /^rounded-(?:md|lg|xl|2xl|full)$/) && has(unit, /^(?:items-center|place-items-center|place-content-center)$/) && has(unit, /^bg-/);
+  });
+}
+var ICON_LIBRARY = /from\s+["'](?:lucide-react|@heroicons\/react[^"']*|react-icons[^"']*|@phosphor-icons\/react|@tabler\/icons-react|@radix-ui\/react-icons)["']/;
+function iconTileStackHits(ctx) {
+  const hits = [];
+  for (const file of ctx.files) {
+    if (!ICON_LIBRARY.test(file.text)) continue;
+    const tiles = iconTiles(file);
+    if (tiles.length > 0) {
+      hits.push({ path: file.path, offset: tiles[0].offset, message: `icon in a tinted tile (${tiles.length} in this file)` });
+    }
+  }
+  return hits;
+}
+function iconGridHits(ctx) {
+  const hits = [];
+  for (const file of ctx.files) {
+    if (!ICON_LIBRARY.test(file.text) || iconTiles(file).length === 0) continue;
+    const grid = file.classUnits.find((u) => has(u, /^grid-cols-3$/) && has(u, /^grid$/));
+    if (grid) hits.push({ path: file.path, offset: grid.offset, message: "three-column grid of icon cards" });
+  }
+  return hits;
+}
+function bentoHits(ctx) {
+  const hits = [];
+  for (const file of ctx.files) {
+    const all = file.classUnits.flatMap(bases);
+    const colSpan = all.some((c) => /^col-span-[2-3]$/.test(c));
+    const rowSpan = file.classUnits.find((u) => has(u, /^row-span-[2-3]$/));
+    if (colSpan && rowSpan) {
+      hits.push({ path: file.path, offset: rowSpan.offset, message: "mixed column and row spans: a bento grid" });
+    }
+  }
+  return hits;
+}
+var WRAPPER = /^(?:Section|Container|Reveal|FadeIn|FadeUp|Fade|Animate\w*|Motion\w*|Suspense|Fragment|Wrapper|Layout|Main|ErrorBoundary)$/;
+var PROOF = /Trust|Logo|Proof|Stat|Badge|Partner|Client|Marquee|Press|Rating|Review|Testimonial|Accredit|Brands/;
+function heroThenProofHits(ctx) {
+  const hits = [];
+  for (const file of ctx.files) {
+    if (file.kind !== "markup") continue;
+    const tags = [...file.text.matchAll(/<([A-Z][A-Za-z0-9]*)\b/g)].map((m) => ({ name: m[1], offset: m.index ?? 0 }));
+    const hero = tags.findIndex((t) => /Hero/.test(t.name));
+    if (hero === -1) continue;
+    const next = tags.slice(hero + 1).find((t) => !WRAPPER.test(t.name) && !/Hero/.test(t.name));
+    if (next && PROOF.test(next.name)) {
+      hits.push({ path: file.path, offset: next.offset, message: `${tags[hero].name} is followed straight by ${next.name}` });
+    }
+  }
+  return hits;
+}
+var REVEAL_LIMIT = 12;
+var PILL_LIMIT = 30;
+var SHADCN_LIMIT = 12;
+var REVEAL = /<(?:Reveal|ScrollReveal|FadeIn|FadeUp|FadeInUp|SlideIn|SlideUp|AnimateIn|AnimateOnScroll|InView|RevealOnScroll)\b|\bwhileInView\b|\bdata-aos=|\buseInView\s*\(|\bscrollTrigger\s*:/g;
+function countHits(ctx, perFile, limit, label) {
+  let total = 0;
+  let worst = null;
+  for (const file of ctx.files) {
+    const offsets = perFile(file);
+    total += offsets.length;
+    if (!worst || offsets.length > worst.offsets.length) worst = { file, offsets };
+  }
+  if (total <= limit || !worst || worst.offsets.length === 0) return [];
+  return [{ path: worst.file.path, offset: worst.offsets[0], message: label(total, `${worst.file.path} has ${worst.offsets.length}`) }];
+}
+function revealHits(ctx) {
+  return countHits(
+    ctx,
+    (file) => file.kind === "markup" || file.kind === "script" ? [...file.text.matchAll(REVEAL)].map((m) => m.index ?? 0) : [],
+    REVEAL_LIMIT,
+    (n, top) => `${n} scroll reveals (limit ${REVEAL_LIMIT}); ${top}`
+  );
+}
+var PILL_RADIUS = /\b(?:9{3,}|[1-9]\d{3,})px\b|\b(?:50|100)vh\b|\b100vmax\b|\b9{3,}rem\b/;
+function pillHits(ctx) {
+  return countHits(
+    ctx,
+    (file) => [
+      ...file.classUnits.filter((u) => has(u, /^rounded-full$/)).map((u) => u.offset),
+      ...file.declarations.filter((d) => /^border(?:-[a-z]+)*-radius$/.test(d.property) && PILL_RADIUS.test(d.value)).map((d) => d.offset)
+    ],
+    PILL_LIMIT,
+    (n, top) => `${n} fully rounded shapes (limit ${PILL_LIMIT}); ${top}`
+  );
+}
+var SHADCN_PRIMITIVES = [
+  "accordion",
+  "alert",
+  "alert-dialog",
+  "aspect-ratio",
+  "avatar",
+  "badge",
+  "breadcrumb",
+  "button",
+  "calendar",
+  "card",
+  "carousel",
+  "chart",
+  "checkbox",
+  "collapsible",
+  "command",
+  "context-menu",
+  "dialog",
+  "drawer",
+  "dropdown-menu",
+  "form",
+  "hover-card",
+  "input",
+  "input-otp",
+  "label",
+  "menubar",
+  "navigation-menu",
+  "pagination",
+  "popover",
+  "progress",
+  "radio-group",
+  "resizable",
+  "scroll-area",
+  "select",
+  "separator",
+  "sheet",
+  "sidebar",
+  "skeleton",
+  "slider",
+  "sonner",
+  "switch",
+  "table",
+  "tabs",
+  "textarea",
+  "toast",
+  "toaster",
+  "toggle",
+  "toggle-group",
+  "tooltip"
+];
+function shadcnHits(ctx) {
+  const stock = new Set(SHADCN_PRIMITIVES);
+  const ui = ctx.files.filter((file) => {
+    const m = file.path.match(/(?:^|\/)components\/ui\/([a-z-]+)\.(?:tsx|jsx|ts)$/);
+    return m !== null && stock.has(m[1]);
+  });
+  if (ui.length < SHADCN_LIMIT) return [];
+  const others = ctx.files.filter((file) => !ui.includes(file));
+  const imported = (name) => others.some((o) => new RegExp(`ui/${name}["']`).test(o.text)) || ui.some((o) => new RegExp(`["']\\./${name}["']|ui/${name}["']`).test(o.text));
+  const unused = others.length > 0 ? ui.filter((file) => !imported(file.path.match(/([a-z-]+)\.[a-z]+$/)[1])) : [];
+  const detail = unused.length > 0 ? `; ${unused.length} imported nowhere` : "";
+  return [{ path: ui[0].path, offset: 0, message: `${ui.length} stock shadcn primitives${detail}` }];
+}
+function marqueeHits(ctx) {
+  const hits = [];
+  const pattern = /@keyframes\s+[\w-]*marquee|animate-(?:marquee|scroll-x|infinite-scroll)\b|<Marquee\b|["']react-fast-marquee["']|ui\/marquee["']|animation(?:-name)?\s*:\s*[^;]*marquee/i;
+  for (const file of ctx.files) {
+    const at = firstMatch(file.text, pattern);
+    if (at !== -1) hits.push({ path: file.path, offset: at, message: "scrolling marquee" });
+  }
+  return hits;
+}
+function introHits(ctx) {
+  const hits = [];
+  const name = /(?:^|\/)(?:intro(?:-?(?:cinematic|sequence|animation|overlay))?|preloader|splash(?:-?screen)?|loading-?screen|curtain)\.(?:tsx|jsx|vue|svelte|astro)$/i;
+  for (const file of ctx.files) {
+    if (name.test(file.path) && /sessionStorage|localStorage|AnimatePresence|setTimeout|gsap|@keyframes|animate\(/.test(file.text)) {
+      hits.push({ path: file.path, offset: 0, message: "intro sequence before the page" });
+      continue;
+    }
+    const use = file.text.match(/<(?:IntroCinematic|Intro|Preloader|Splash|SplashScreen|LoadingScreen|Curtain)\b/);
+    if (use && file.kind === "markup") hits.push({ path: file.path, offset: use.index ?? 0, message: `${use[0].slice(1)} runs before the page` });
+  }
+  return hits;
+}
+var SOURCE_TELLS = [
+  {
+    id: "reflex-font",
+    name: "Reflex font",
+    generation: 1,
+    severity: "warn",
+    surface: "source",
+    why: "Inter, Roboto, Poppins and friends are what a model sets when nothing in the brief names a face. Every site in the estate ships one.",
+    fix: "Pick the display face from the client's world (signage, packaging, the trade's lettering), record why in art-direction.json, and keep it unique across the estate.",
+    detect: fontTell(REFLEX_FONTS_1),
+    fixtures: {
+      flag: [
+        f2("app/layout.tsx", `import { Inter } from "next/font/google";
+const inter = Inter({ subsets: ["latin"] });`),
+        f2("index.html", `<link href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;600" rel="stylesheet">`),
+        f2("tailwind.config.js", `fontFamily: { sans: ["Roboto", "sans-serif"] }`),
+        f2("main.ts", `import "@fontsource/montserrat";`),
+        f2("components/A.tsx", `<p className="font-['Open_Sans']">x</p>`)
+      ],
+      pass: [f2("app/layout.tsx", `import { Bricolage_Grotesque } from "next/font/google";`)]
+    }
+  },
+  {
+    id: "reflex-font-2",
+    name: "Second-wave reflex font",
+    generation: 2,
+    severity: "warn",
+    surface: "source",
+    why: "Ban Inter and a model reaches for Inter Tight, DM Sans, Manrope, Space Grotesk or an Instrument/Fraunces serif. A swap inside the reflex list is not a decision.",
+    fix: "Same as reflex-font. If this face really is the right one, declare an exception with the reason and the evidence.",
+    detect: fontTell(REFLEX_FONTS_2),
+    fixtures: {
+      flag: [f2("src/styles.css", `@theme {
+  --font-sans: "DM Sans", system-ui, sans-serif;
+}`)],
+      pass: [f2("src/styles.css", `@theme {
+  --font-sans: "Hanken Grotesk", system-ui, sans-serif;
+}`)]
+    }
+  },
+  {
+    id: "ai-violet",
+    name: "Indigo-violet accent",
+    generation: 1,
+    severity: "warn",
+    surface: "source",
+    why: "Tailwind's indigo and violet are the accent a model picks for any brand it knows nothing about. Hue is read in OKLCh, so a hex violet is caught as well as a class name.",
+    fix: 'Derive the accent from something the client owns (livery, shopfront, product). If violet is the brand, declare it: `{ "tell": "ai-violet", "because": "..." }`.',
+    detect: violetHits,
+    fixtures: {
+      flag: [
+        f2("components/Hero.tsx", `<a className="rounded-md bg-indigo-600 px-4 py-2 text-white">Book</a>`),
+        f2("app/globals.css", `:root { --accent: #5a35d1; }`)
+      ],
+      pass: [f2("components/Hero.tsx", `<a className="rounded-md bg-emerald-700 px-4 py-2 text-white">Book</a>`)]
+    }
+  },
+  {
+    id: "blue-purple-gradient",
+    name: "Blue-to-purple gradient",
+    generation: 1,
+    severity: "warn",
+    surface: "source",
+    why: "The first-wave hero background. It says 'software product' on a plumber's site.",
+    fix: "Use a flat ground from the palette. If the design needs depth, get it from photography or material texture from the client's world.",
+    detect: gradientHits,
+    fixtures: {
+      flag: [
+        f2("components/Hero.tsx", `<section className="bg-gradient-to-r from-blue-600 to-purple-600">`),
+        f2("app/globals.css", `.hero { background: linear-gradient(135deg, #2563eb, #9333ea); }`)
+      ],
+      pass: [f2("components/Hero.tsx", `<section className="bg-gradient-to-b from-stone-100 to-stone-200">`)]
+    }
+  },
+  {
+    id: "gradient-text",
+    name: "Gradient-filled heading",
+    generation: 1,
+    severity: "warn",
+    surface: "source",
+    why: "Gradient text is the model's way of making a heading look designed without deciding what it should look like.",
+    fix: "Set the heading in the display face at a real size and weight. Let type do the work.",
+    detect: gradientTextHits,
+    fixtures: {
+      flag: [
+        f2("components/Hero.tsx", `<h1 className="bg-gradient-to-r from-rose-500 to-amber-500 bg-clip-text text-transparent">`),
+        f2("app/globals.css", `.headline { -webkit-background-clip: text; color: transparent; }`)
+      ],
+      pass: [f2("components/Hero.tsx", `<h1 className="font-display text-5xl text-ink">`)]
+    }
+  },
+  {
+    id: "glass-panel",
+    name: "Glass panel",
+    generation: 1,
+    severity: "warn",
+    surface: "source",
+    why: "A translucent blurred card over a busy background is the stock way to put text on a hero image. It costs contrast and says nothing about the client.",
+    fix: "Give text a solid ground, or crop the image so the text sits on a quiet area.",
+    detect: glassHits,
+    fixtures: {
+      flag: [
+        f2("components/Hero.tsx", `<div className="rounded-2xl bg-white/10 p-8 backdrop-blur-md">`),
+        f2("app/globals.css", `.card { background: rgb(255 255 255 / .1); backdrop-filter: blur(12px); }`)
+      ],
+      pass: [f2("components/Hero.tsx", `<div className="rounded-sm bg-paper p-8">`)]
+    }
+  },
+  {
+    id: "hero-then-proof",
+    name: "Hero straight into a trust strip",
+    generation: 1,
+    severity: "warn",
+    surface: "source",
+    why: "Six of seven estate sites go hero, then logos or stats. It is the landing-page template's order, not the client's story.",
+    fix: "Follow the hero with the thing only this business has: the work, the place, the person. Put proof where a doubt arises.",
+    detect: heroThenProofHits,
+    fixtures: {
+      flag: [f2("app/page.tsx", `export default function Page() {
+  return (<main><Hero /><TrustStrip /><Services /></main>);
+}`)],
+      pass: [f2("app/page.tsx", `export default function Page() {
+  return (<main><Hero /><Workshop /><TrustStrip /></main>);
+}`)]
+    }
+  },
+  {
+    id: "icon-tile-grid",
+    name: "Three-column icon-card grid",
+    generation: 1,
+    severity: "warn",
+    surface: "source",
+    why: "Three cards, each an icon, a heading and two lines, is what a model builds for any list of services.",
+    fix: "Show the services as the client would: a price list, a menu board, photographs of the work, a sequence.",
+    detect: iconGridHits,
+    fixtures: {
+      flag: [
+        f2(
+          "components/Features.tsx",
+          `import { Heart } from "lucide-react";
+<div className="grid grid-cols-1 gap-6 md:grid-cols-3">
+  <div className="flex h-12 w-12 items-center justify-center rounded-xl bg-rose-100"><Heart /></div>
+</div>`
+        )
+      ],
+      pass: [f2("components/Features.tsx", `<ul className="divide-y">
+  <li className="flex justify-between py-3">Gel manicure <span>\xA332</span></li>
+</ul>`)]
+    }
+  },
+  {
+    id: "reveal-everywhere",
+    name: "Reveal on every section",
+    generation: 1,
+    severity: "warn",
+    surface: "source",
+    why: "When every block fades up on scroll, the motion stops meaning anything and the page feels slow. MMM had 70, DD 40, sen-sphere 27.",
+    fix: `Keep one gated signature moment per page (STANDARD section 7) and let the rest arrive still. The limit here is ${REVEAL_LIMIT} per scan.`,
+    detect: revealHits,
+    fixtures: {
+      flag: [f2("app/page.tsx", Array.from({ length: REVEAL_LIMIT + 1 }, (_, i) => `<Reveal><Block n={${i}} /></Reveal>`).join("\n"))],
+      pass: [f2("app/page.tsx", `<Reveal><Signature /></Reveal>
+<Block />
+<Block />`)]
+    }
+  },
+  {
+    id: "pill-everything",
+    name: "Pills everywhere",
+    generation: 1,
+    severity: "warn",
+    surface: "source",
+    why: "rounded-full on every button, badge and tag is the framework's friendliest default. MMM had 162, DD 125. A shape used everywhere is not a shape language.",
+    fix: `Choose the shape language on purpose (and record it), then use the pill only where it means something. The limit here is ${PILL_LIMIT} per scan.`,
+    detect: pillHits,
+    fixtures: {
+      flag: [f2("components/Tags.tsx", Array.from({ length: PILL_LIMIT + 1 }, () => `<span className="rounded-full px-3">tag</span>`).join("\n"))],
+      pass: [f2("components/Tags.tsx", `<span className="rounded-full px-3">tag</span>
+<a className="rounded-sm px-4">Book</a>`)]
+    }
+  },
+  {
+    id: "shadcn-dump",
+    name: "Stock component dump",
+    generation: 1,
+    severity: "warn",
+    surface: "source",
+    why: "A generator exports the whole shadcn/ui kit whether the site uses it or not. Rise & Bloom ships a full set under its own book, vine and petal assets.",
+    fix: "Delete the primitives nothing imports. Restyle the ones that stay so they belong to this site.",
+    detect: shadcnHits,
+    fixtures: {
+      flag: [SHADCN_PRIMITIVES.slice(0, SHADCN_LIMIT).map((name) => f2(`src/components/ui/${name}.tsx`, `export function X() { return null; }`))],
+      pass: [f2("src/components/ui/button.tsx", `export function Button() { return null; }`)]
+    }
+  },
+  {
+    id: "cream-palette",
+    name: "Cream ground",
+    generation: 2,
+    severity: "warn",
+    surface: "source",
+    why: "Once white-and-violet was named, models moved to a warm off-white: parchment, linen, oat. It reads as 'tasteful' in the same way everywhere.",
+    fix: "Take the ground from the client's material world (paper stock, wall colour, tile). If it really is cream, say why.",
+    detect: creamHits,
+    fixtures: {
+      flag: [
+        f2("app/globals.css", `body { background-color: #f5efe6; }`),
+        f2("app/page.tsx", `<main className="bg-cream text-ink">`),
+        f2("app/page.tsx", `<main className="bg-[#f7f1e8]">`)
+      ],
+      pass: [f2("app/globals.css", `body { background-color: #ffffff; }`)]
+    }
+  },
+  {
+    id: "italic-serif-display",
+    name: "Italic serif display",
+    generation: 2,
+    severity: "warn",
+    surface: "source",
+    why: "A serif heading with one italic word ('Beauty, reimagined') is the second wave's signature move.",
+    fix: "Use emphasis only where the sentence needs it, and set it the way the display face wants, not by reflex.",
+    detect: italicSerifHits,
+    fixtures: {
+      flag: [
+        f2("components/Hero.tsx", `<h1 className="font-display text-6xl">Nails, <em>reimagined</em></h1>`),
+        f2("components/Hero.tsx", `<span className="font-serif italic">reimagined</span>`),
+        f2("app/globals.css", `.hero h1 { font-style: italic; }`)
+      ],
+      pass: [f2("components/Hero.tsx", `<h1 className="font-display text-6xl">Nails in Brackley</h1>
+<p><em>Walk-ins</em> welcome.</p>`)]
+    }
+  },
+  {
+    id: "hero-eyebrow-chip",
+    name: "Eyebrow chip above the hero",
+    generation: 2,
+    severity: "warn",
+    surface: "source",
+    why: "A small bordered pill ('New \xB7 Now booking') above the headline is in almost every generated hero.",
+    fix: "Drop it. If the fact matters, put it in the headline or the first line of copy.",
+    detect: eyebrowChipHits,
+    fixtures: {
+      flag: [
+        f2("components/Hero.tsx", `<span className="inline-flex rounded-full border px-3 py-1 text-xs">Now booking</span>
+<h1>Nails in Brackley</h1>`),
+        f2("components/Hero.tsx", `<span className={cn("rounded-full px-3 text-xs", "bg-rose-500/10")}>New</span>
+<h1>Nails</h1>`)
+      ],
+      pass: [f2("components/Hero.tsx", `<h1>Nails in Brackley</h1>
+<span className="inline-flex rounded-full border px-3 py-1 text-xs">Tag</span>`)]
+    }
+  },
+  {
+    id: "icon-tile-stack",
+    name: "Icon in a tinted tile",
+    generation: 2,
+    severity: "warn",
+    surface: "source",
+    why: "A library icon in a soft rounded square, stacked above a heading, is the stock card header.",
+    fix: "Use the client's own marks, photography or numerals. If an icon earns its place, set it inline with the text.",
+    detect: iconTileStackHits,
+    fixtures: {
+      flag: [f2("components/Card.tsx", `import { Sparkles } from "lucide-react";
+<div className="flex size-10 items-center justify-center rounded-lg bg-violet-100"><Sparkles /></div>`)],
+      pass: [f2("components/Card.tsx", `import { Sparkles } from "lucide-react";
+<p className="flex items-center gap-2"><Sparkles className="size-4" />Aftercare</p>`)]
+    }
+  },
+  {
+    id: "bento-grid",
+    name: "Bento grid",
+    generation: 2,
+    severity: "warn",
+    surface: "source",
+    why: "Mixed-size tiles in a grid became the default 'features' layout of the second wave.",
+    fix: "Lay content out by what it is. If one item matters most, give it the page, not a double-width tile.",
+    detect: bentoHits,
+    fixtures: {
+      flag: [f2("components/Features.tsx", `<div className="grid grid-cols-3"><div className="md:col-span-2 md:row-span-2" /><div /></div>`)],
+      pass: [f2("components/Features.tsx", `<div className="grid grid-cols-3"><div className="col-span-2" /><div /></div>`)]
+    }
+  },
+  {
+    id: "radial-spotlight-glow",
+    name: "Radial glow",
+    generation: 2,
+    severity: "warn",
+    surface: "source",
+    why: "A soft blurred blob or radial spotlight behind the hero is atmosphere without a subject.",
+    fix: "Light the page with real imagery, or leave the ground flat.",
+    detect: glowHits,
+    fixtures: {
+      flag: [
+        f2("components/Hero.tsx", `<div className="absolute -top-20 left-1/2 h-96 w-96 rounded-full bg-rose-400/30 blur-3xl" />`),
+        f2("app/globals.css", `.hero { background: radial-gradient(circle at top, rgb(244 63 94 / .25), transparent 60%); }`)
+      ],
+      pass: [f2("components/Hero.tsx", `<div className="absolute inset-0 bg-black/40" />`)]
+    }
+  },
+  {
+    id: "grid-background",
+    name: "Graph-paper background",
+    generation: 2,
+    severity: "warn",
+    surface: "source",
+    why: "A faint 1px line or dot grid behind the hero is the developer-tool look, borrowed by everyone.",
+    fix: "Remove it. If the brand has a pattern, draw it from the brand.",
+    detect: gridBackgroundHits,
+    fixtures: {
+      flag: [
+        f2(
+          "app/globals.css",
+          `.hero { background-image: linear-gradient(to right, #e5e5e5 1px, transparent 1px), linear-gradient(to bottom, #e5e5e5 1px, transparent 1px); background-size: 24px 24px; }`
+        ),
+        f2("components/Hero.tsx", `<div className="absolute inset-0 bg-[linear-gradient(to_right,#8882_1px,transparent_1px)] bg-[size:24px_24px]" />`)
+      ],
+      pass: [f2("app/globals.css", `.hero { background-image: url(/shopfront.avif); }`)]
+    }
+  },
+  {
+    id: "marquee",
+    name: "Scrolling marquee",
+    generation: 2,
+    severity: "warn",
+    surface: "source",
+    why: "An endless strip of logos or words is the second wave's trust strip. It moves so it looks alive.",
+    fix: "Show proof still and in context: one named review, one accreditation, where the doubt arises.",
+    detect: marqueeHits,
+    fixtures: {
+      flag: [
+        f2("app/globals.css", `@keyframes marquee { from { transform: translateX(0) } to { transform: translateX(-50%) } }`),
+        f2("components/Logos.tsx", `import Marquee from "react-fast-marquee";`)
+      ],
+      pass: [f2("app/globals.css", `@keyframes fade { from { opacity: 0 } to { opacity: 1 } }`)]
+    }
+  },
+  {
+    id: "thin-border-wide-shadow",
+    name: "Hairline border, wide shadow",
+    generation: 2,
+    severity: "warn",
+    surface: "source",
+    why: "A near-invisible border under a large soft shadow is the stock 'elevated card'.",
+    fix: "Pick one: a border that is visible, or a shadow the light source explains. Keep within the four-shadow budget.",
+    detect: thinBorderWideShadowHits,
+    fixtures: {
+      flag: [
+        f2("components/Card.tsx", `<div className="rounded-2xl border border-black/5 bg-white shadow-2xl">`),
+        f2("app/globals.css", `.card { border: 1px solid rgb(0 0 0 / .06); box-shadow: 0 20px 48px rgb(0 0 0 / .08); }`)
+      ],
+      pass: [f2("components/Card.tsx", `<div className="rounded-sm border border-ink bg-white">`)]
+    }
+  },
+  {
+    id: "intro-cinematic",
+    name: "Intro cinematic",
+    generation: 2,
+    severity: "warn",
+    surface: "source",
+    why: "A logo animation that runs before the page is something a model adds to make a site feel premium. Three estate sites open with one. It delays the page for every visitor.",
+    fix: "Remove it. Spend the signature moment on something the visitor came for.",
+    detect: introHits,
+    fixtures: {
+      flag: [
+        f2("components/IntroCinematic.tsx", `const seen = sessionStorage.getItem("intro");
+export function IntroCinematic() { return <AnimatePresence /> }`),
+        f2("app/page.tsx", `<><Preloader /><Hero /></>`)
+      ],
+      pass: [f2("components/Introduction.md", `An introduction to the studio.`)]
+    }
+  }
+];
+
+// src/character/parse.ts
+var MARKUP = /\.(tsx|jsx|html?|astro|vue|svelte|mdx)$/i;
+var SCRIPT = /\.(ts|js|mjs|cjs)$/i;
+var CSS = /\.(css|scss|sass|less|pcss)$/i;
+var PROSE = /\.(md|markdown|txt)$/i;
+function fileKind(path) {
+  if (MARKUP.test(path)) return "markup";
+  if (CSS.test(path)) return "css";
+  if (SCRIPT.test(path)) return "script";
+  if (PROSE.test(path)) return "prose";
+  return "other";
+}
+function lineAt(text, offset) {
+  let line = 1;
+  for (let i = 0; i < offset && i < text.length; i += 1) {
+    if (text.charCodeAt(i) === 10) line += 1;
+  }
+  return line;
+}
+function excerptAt(text, offset, max = 140) {
+  const start = text.lastIndexOf("\n", Math.max(0, offset - 1)) + 1;
+  const endRaw = text.indexOf("\n", offset);
+  const line = text.slice(start, endRaw === -1 ? text.length : endRaw).trim();
+  return line.length > max ? `${line.slice(0, max - 1)}\u2026` : line;
+}
+var LITERAL = /"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'|`(?:[^`\\]|\\.)*`/g;
+function stringLiterals(text, base = 0) {
+  const out = [];
+  for (const m of text.matchAll(LITERAL)) {
+    out.push({ value: m[0].slice(1, -1), offset: base + (m.index ?? 0) });
+  }
+  return out;
+}
+function matchBracket(text, open) {
+  const pairs = { "{": "}", "(": ")", "[": "]" };
+  const close = pairs[text[open]];
+  const opener = text[open];
+  let depth = 0;
+  for (let i = open; i < text.length; i += 1) {
+    const ch = text[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const end = skipString(text, i);
+      i = end - 1;
+      continue;
+    }
+    if (ch === opener) depth += 1;
+    else if (ch === close) {
+      depth -= 1;
+      if (depth === 0) return i + 1;
+    }
+  }
+  return text.length;
+}
+function skipString(text, start) {
+  const quote = text[start];
+  for (let i = start + 1; i < text.length; i += 1) {
+    if (text[i] === "\\") {
+      i += 1;
+      continue;
+    }
+    if (text[i] === quote) return i + 1;
+    if (text[i] === "\n" && quote !== "`") return i + 1;
+  }
+  return text.length;
+}
+function split(classes) {
+  return classes.split(/\s+/).filter((c) => c.length > 0 && !c.includes("${"));
+}
+function classUnits(text) {
+  const units = [];
+  const covered = [];
+  const attr = /\b(?:className|class|:class)\s*=\s*/g;
+  for (const m of text.matchAll(attr)) {
+    const at = (m.index ?? 0) + m[0].length;
+    const ch = text[at];
+    if (ch === '"' || ch === "'") {
+      const end = skipString(text, at);
+      units.push({ classes: split(text.slice(at + 1, end - 1)), offset: m.index ?? 0 });
+    } else if (ch === "{") {
+      const end = matchBracket(text, at);
+      const joined = stringLiterals(text.slice(at, end)).map((l) => l.value).join(" ");
+      units.push({ classes: split(joined), offset: m.index ?? 0 });
+      covered.push([at, end]);
+    }
+  }
+  const call = /\b(cn|clsx|twMerge|cx|cva|tv)\s*\(/g;
+  for (const m of text.matchAll(call)) {
+    const start = m.index ?? 0;
+    if (covered.some(([a, b]) => start >= a && start < b)) continue;
+    const open = start + m[0].length - 1;
+    const end = matchBracket(text, open);
+    const literals = stringLiterals(text.slice(open, end), open);
+    if (m[1] === "cva" || m[1] === "tv") {
+      for (const l of literals) units.push({ classes: split(l.value), offset: l.offset });
+    } else {
+      units.push({ classes: split(literals.map((l) => l.value).join(" ")), offset: start });
+    }
+    covered.push([open, end]);
+  }
+  return units.filter((u) => u.classes.length > 0);
+}
+function blankComments(css) {
+  return css.replace(/\/\*[\s\S]*?\*\//g, (c) => c.replace(/[^\n]/g, " "));
+}
+function cssDeclarations(css, base = 0) {
+  const src = blankComments(css);
+  const out = [];
+  const stack = [];
+  let segStart = 0;
+  let parens = 0;
+  const flush = (end) => {
+    const seg = src.slice(segStart, end);
+    const colon = seg.indexOf(":");
+    if (stack.length === 0 || colon === -1) return;
+    const property = seg.slice(0, colon).trim();
+    if (!/^(--)?[a-zA-Z-]+$/.test(property)) return;
+    const lead = seg.length - seg.trimStart().length;
+    out.push({
+      property: property.toLowerCase(),
+      value: seg.slice(colon + 1).trim(),
+      selector: stack[stack.length - 1],
+      offset: base + segStart + lead
+    });
+  };
+  for (let i = 0; i < src.length; i += 1) {
+    const ch = src[i];
+    if (ch === '"' || ch === "'") {
+      i = skipString(src, i) - 1;
+      continue;
+    }
+    if (ch === "(") parens += 1;
+    else if (ch === ")") parens = Math.max(0, parens - 1);
+    if (parens > 0) continue;
+    if (ch === "{") {
+      stack.push(src.slice(segStart, i).trim());
+      segStart = i + 1;
+    } else if (ch === ";") {
+      flush(i);
+      segStart = i + 1;
+    } else if (ch === "}") {
+      flush(i);
+      stack.pop();
+      segStart = i + 1;
+    }
+  }
+  return out;
+}
+function styleBlocks(text) {
+  const out = [];
+  for (const m of text.matchAll(/<style\b[^>]*>([\s\S]*?)<\/style>/gi)) {
+    const bodyStart = (m.index ?? 0) + m[0].indexOf(">") + 1;
+    out.push(...cssDeclarations(m[1], bodyStart));
+  }
+  return out;
+}
+function parseFile(file) {
+  const kind = fileKind(file.path);
+  return {
+    ...file,
+    kind,
+    classUnits: kind === "markup" || kind === "script" ? classUnits(file.text) : [],
+    declarations: kind === "css" ? cssDeclarations(file.text) : kind === "markup" ? styleBlocks(file.text) : []
+  };
+}
+
+// src/character/prose.ts
+var blank = (s) => s.replace(/[^\n]/g, " ");
+function readsAsProse(value) {
+  if (value.length < 12 || !/\s/.test(value)) return false;
+  if (looksLikeClasses(value) || looksLikeAddress(value)) return false;
+  const words2 = withoutMarkup(value);
+  if (looksLikeCode(words2) || /[<>]/.test(words2)) return false;
+  return /[a-zA-Z]{3,}\s+[a-zA-Z]{2,}/.test(words2);
+}
+function withoutMarkup(value) {
+  return value.replace(/<\/?[a-zA-Z][^<>]*>/g, " ").replace(/\$\{[^}]*\}/g, " ").replace(/\{\{[^}]*\}\}/g, " ").replace(/&(?:#\d+|#x[0-9a-f]+|[a-z]+);/gi, "'");
+}
+function looksLikeCode(words2) {
+  return /[{}]|;\s*(?:\n|$)|\s=\s|===?|=>|\b(?:const|let|var|function|import|export)\s/.test(words2);
+}
+var UTILITY = /^(?:flex|grid|block|inline|hidden|contents|relative|absolute|fixed|sticky|static|rounded|border|shadow|underline|italic|uppercase|lowercase|capitalize|truncate|container|group|peer|transition|antialiased|prose|sr-only|outline|ring|grow|shrink|isolate|invisible|visible|collapse)$/;
+function looksLikeClasses(value) {
+  const tokens = value.trim().split(/\s+/);
+  if (tokens.length === 0 || !tokens.every((t) => /^[!\w@:/[\]().#%,>&*+=~-]+$/.test(t))) return false;
+  const classy = tokens.filter((t) => /[-:[\]/]/.test(t) || UTILITY.test(t)).length;
+  return classy / tokens.length >= 0.6 && /[a-z]-|:|\[/.test(value);
+}
+function looksLikeAddress(value) {
+  return /^(?:\.{0,2}\/|@\/|https?:|mailto:|tel:)/.test(value);
+}
+function readsAsText(value) {
+  if (value.trim().length === 0) return false;
+  if (looksLikeAddress(value) || looksLikeClasses(value)) return false;
+  return /[^\s\w]|[a-zA-Z]/.test(value);
+}
+function literalIsText(value) {
+  return readsAsText(value) && !looksLikeCode(withoutMarkup(value));
+}
+function maskScriptComments(text) {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const start = i;
+      i += 1;
+      while (i < text.length) {
+        if (text[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (text[i] === ch) {
+          i += 1;
+          break;
+        }
+        if (text[i] === "\n" && ch !== "`") break;
+        i += 1;
+      }
+      out += text.slice(start, i);
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "/") {
+      const end = text.indexOf("\n", i);
+      const stop = end === -1 ? text.length : end;
+      out += " ".repeat(stop - i);
+      i = stop;
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "*") {
+      const end = text.indexOf("*/", i + 2);
+      const stop = end === -1 ? text.length : end + 2;
+      out += blank(text.slice(i, stop));
+      i = stop;
+      continue;
+    }
+    out += ch;
+    i += 1;
+  }
+  return out;
+}
+function maskMarkupComments(text) {
+  return text.replace(/<(script|style)\b[\s\S]*?<\/\1>/gi, blank).replace(/\{\/\*[\s\S]*?\*\/\}|<!--[\s\S]*?-->/g, blank).replace(/^[ \t]*\/\*[\s\S]*?\*\//gm, blank).replace(/^[ \t]*\/\/[^\n]*/gm, blank).replace(/([;,{}()[\]])([ \t]+)\/\/[^\n]*/g, (m, p, s) => p + s + " ".repeat(m.length - p.length - s.length)).replace(/^\s*import\b[^\n]*$/gm, blank);
+}
+function markupParts(file) {
+  const masked = maskMarkupComments(file.text);
+  const textNodes = [];
+  let rest = masked;
+  for (const m of masked.matchAll(/([>}])([^<>{}]+)(?=[<{])/g)) {
+    const body = m[2];
+    const before = masked[(m.index ?? 0) - 1] ?? "";
+    const after = masked[(m.index ?? 0) + m[0].length];
+    if (m[1] === ">" && /[=-]/.test(before)) continue;
+    if (m[1] === "}" && (/^\s*(?:[)\],;:]|(?:else|catch|finally|return|from|as|if|const|let|export|function)\b)/.test(body) || /;\s*$/.test(body))) continue;
+    if (m[1] === "}" && after === "{" && (/[=()`'"]/.test(body) || !/[a-zA-Z]{2,}|[^\s\w,|&?:]/.test(body))) continue;
+    if (body.trim().length === 0) continue;
+    if (m[1] === ">" && after === "<" && /^[\s—–-]*$/.test(body)) continue;
+    const at = (m.index ?? 0) + 1;
+    textNodes.push({ path: file.path, text: body, offset: at });
+    rest = rest.slice(0, at) + blank(body) + rest.slice(at + body.length);
+  }
+  return { textNodes, literals: splitHtml(stringLiterals(rest)) };
+}
+function textNodeIsProse(body) {
+  return /[a-zA-Z]{2,}/.test(body) && /\s/.test(body.trim()) || /[a-zA-Z]{4,}[.!?]/.test(body);
+}
+function proseBlocks(file) {
+  const masked = file.text.replace(/^(```|~~~)[\s\S]*?^\1/gm, blank).replace(/`[^`\n]*`/g, (m) => " ".repeat(m.length)).replace(/^---\n[\s\S]*?\n---\n/, blank).replace(/<!--[\s\S]*?-->/g, blank);
+  return [{ path: file.path, text: masked, offset: 0 }];
+}
+function isData(path) {
+  return /\.jsonl?$/i.test(path);
+}
+function scriptLiterals(file) {
+  return splitHtml(stringLiterals(isData(file.path) ? file.text : maskScriptComments(file.text)));
+}
+function splitHtml(literals) {
+  const out = [];
+  for (const l of literals) {
+    if (!/<[a-zA-Z][^<>]*>/.test(l.value)) {
+      out.push(l);
+      continue;
+    }
+    for (const m of l.value.matchAll(/(?:^|>)([^<>]+)(?=<|$)/g)) {
+      const body = m[1];
+      if (!body.trim()) continue;
+      const lead = m[0].length - body.length;
+      out.push({ value: body, offset: l.offset + (m.index ?? 0) + lead });
+    }
+  }
+  return out;
+}
+function extractCopy(file) {
+  const kind = fileKind(file.path);
+  if (kind === "prose" || file.path.endsWith(".mdx")) return proseBlocks(file);
+  if (kind === "markup") {
+    const { textNodes, literals } = markupParts(file);
+    return [
+      ...textNodes.filter((b) => textNodeIsProse(b.text)),
+      ...literals.filter((l) => readsAsProse(l.value)).map((l) => ({ path: file.path, text: l.value, offset: l.offset + 1, literal: true }))
+    ];
+  }
+  if (kind === "script" || isData(file.path)) {
+    return scriptLiterals(file).filter((l) => readsAsProse(l.value)).map((l) => ({ path: file.path, text: l.value, offset: l.offset + 1, literal: true }));
+  }
+  return [];
+}
+function extractStrings(file) {
+  const kind = fileKind(file.path);
+  if (kind === "prose" || file.path.endsWith(".mdx")) {
+    const [block] = proseBlocks(file);
+    const out = [];
+    let offset = 0;
+    for (const line of block.text.split("\n")) {
+      if (line.trim()) out.push({ path: file.path, text: line, offset });
+      offset += line.length + 1;
+    }
+    return out;
+  }
+  if (kind === "markup") {
+    const { textNodes, literals } = markupParts(file);
+    return [
+      ...textNodes.filter((b) => readsAsText(b.text)),
+      ...literals.filter((l) => literalIsText(l.value)).map((l) => ({ path: file.path, text: l.value, offset: l.offset + 1, literal: true }))
+    ];
+  }
+  if (kind === "script" || isData(file.path)) {
+    return scriptLiterals(file).filter((l) => literalIsText(l.value)).map((l) => ({ path: file.path, text: l.value, offset: l.offset + 1, literal: true }));
+  }
+  return [];
+}
+
+// src/snapshot/types.ts
+var SNAPSHOT_VERSION = 1;
+
+// src/snapshot/fixture.ts
+function makeSnapshot(patch = {}) {
+  const base = {
+    version: SNAPSHOT_VERSION,
+    url: "https://example.test/",
+    capturedAt: "2026-09-23T00:00:00.000Z",
+    viewport: { width: 1440, height: 900 },
+    pageHeight: 4200,
+    ground: "rgb(255, 255, 255)",
+    colours: {
+      backgrounds: [
+        { value: "rgb(255, 255, 255)", area: 6e6, chars: 0 },
+        { value: "rgb(31, 58, 46)", area: 9e4, chars: 0 }
+      ],
+      text: [
+        { value: "rgb(28, 28, 26)", area: 0, chars: 5200 },
+        { value: "rgb(31, 58, 46)", area: 0, chars: 300 }
+      ]
+    },
+    fonts: [
+      { family: "S\xF6hne", chars: 4200, displayChars: 0, italicChars: 0, weights: [400, 500] },
+      { family: "Tiempos Headline", chars: 900, displayChars: 900, italicChars: 0, weights: [500] }
+    ],
+    headings: [
+      { level: 1, family: "Tiempos Headline", sizePx: 64, weight: 500, italic: false, italicPart: false, text: "Boilers fixed the same day in Brackley", top: 180 },
+      { level: 2, family: "Tiempos Headline", sizePx: 36, weight: 500, italic: false, italicPart: false, text: "What we fix", top: 1100 }
+    ],
+    controls: [
+      { kind: "button", radiusPx: 4, heightPx: 44, background: "rgb(31, 58, 46)", text: "Book a visit" },
+      { kind: "link", radiusPx: 4, heightPx: 44, background: "rgb(255, 255, 255)", text: "Call 01280 000000" },
+      { kind: "button", radiusPx: 4, heightPx: 40, background: "rgb(31, 58, 46)", text: "Send" },
+      { kind: "link", radiusPx: 4, heightPx: 40, background: "rgb(31, 58, 46)", text: "See prices" }
+    ],
+    sections: [
+      { top: 0, height: 800, kind: "hero", label: "Boilers fixed the same day in Brackley", cards: 0, iconCards: 0, hiddenAtLoad: false },
+      { top: 800, height: 900, kind: "text", label: "What we fix", cards: 0, iconCards: 0, hiddenAtLoad: false },
+      { top: 1700, height: 900, kind: "cards", label: "Recent jobs", cards: 3, iconCards: 0, hiddenAtLoad: false },
+      { top: 2600, height: 700, kind: "text", label: "Prices", cards: 0, iconCards: 0, hiddenAtLoad: false },
+      { top: 3300, height: 900, kind: "text", label: "Contact", cards: 0, iconCards: 0, hiddenAtLoad: false }
+    ],
+    effects: {
+      glass: 0,
+      gradientText: 0,
+      gradients: [],
+      glows: 0,
+      gridBackgrounds: 0,
+      marquees: 0,
+      hairlineShadowCards: 0,
+      eyebrowChip: false
+    },
+    motion: { hiddenSections: 0, sections: 5, animations: 0, introOverlay: false },
+    metrics: {
+      fontSizes: [14, 16, 20, 36, 64],
+      fontWeights: [400, 500],
+      radii: ["4px"],
+      shadows: [],
+      spacingOnScalePct: 96,
+      bodyLineLengthCh: 68,
+      bodyFontSizePx: 17
+    }
+  };
+  const out = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    const current = base[key];
+    out[key] = value && typeof value === "object" && !Array.isArray(value) && current && typeof current === "object" && !Array.isArray(current) ? { ...current, ...value } : value;
+  }
+  return out;
+}
+
+// src/snapshot/fonts.ts
+function normaliseFamily(raw) {
+  let name = raw.replace(/["']/g, "").trim();
+  const next = name.match(/^__(.+?)(?:_Fallback)?_[0-9a-f]{5,8}$/i);
+  if (next) name = next[1].replace(/_/g, " ");
+  name = name.replace(/\s+Fallback$/i, "").replace(/\s+Variable$/i, "");
+  if (!/\s/.test(name) && (/[a-z][A-Z]/.test(name) || /^[a-z]+(?:-[a-z]+)+$/.test(name))) {
+    name = name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/-/g, " ").replace(/\b([a-z])/g, (c) => c.toUpperCase()).replace(/\bDm\b/, "DM");
+  }
+  if (/^(?:system-ui|-apple-system|BlinkMacSystemFont|ui-sans-serif|ui-serif|ui-monospace|sans-serif|serif|monospace)$/i.test(name)) return "system-ui";
+  return name;
+}
+var KNOWN = {
+  fraunces: "serif",
+  "playfair display": "serif",
+  "cormorant garamond": "serif",
+  cormorant: "serif",
+  "eb garamond": "serif",
+  lora: "serif",
+  merriweather: "serif",
+  "libre baskerville": "serif",
+  "instrument serif": "serif",
+  newsreader: "serif",
+  "source serif 4": "serif",
+  "crimson pro": "serif",
+  canela: "serif",
+  "tiempos headline": "serif",
+  "tiempos text": "serif",
+  "gt super": "serif",
+  "freight display pro": "serif",
+  "gt sectra": "serif",
+  georgia: "serif",
+  "times new roman": "serif",
+  "dm serif display": "serif",
+  "bodoni moda": "serif",
+  "libre caslon text": "serif",
+  "young serif": "serif",
+  "caveat": "script",
+  "dancing script": "script",
+  "great vibes": "script",
+  "pinyon script": "script"
+};
+function fontClass(family) {
+  const name = normaliseFamily(family);
+  if (name === "system-ui") return "system";
+  const known = KNOWN[name.toLowerCase()];
+  if (known) return known;
+  if (/\bmono\b|code|courier/i.test(name)) return "mono";
+  if (/script|hand/i.test(name)) return "script";
+  if (/serif/i.test(name) && !/sans/i.test(name)) return "serif";
+  return "sans";
+}
+
+// src/snapshot/rendered.ts
+var hit = (s, message, excerpt) => ({ path: s.url, offset: 0, message, excerpt: excerpt ?? message });
+var pct = (n) => `${Math.round(n * 100)}%`;
+var oklchOf = (value) => parseColour(value)?.oklch ?? null;
+function reflexFonts(list) {
+  const wanted = new Map(list.map((n) => [n.toLowerCase(), n]));
+  return (s) => {
+    const total = s.fonts.reduce((n, f3) => n + f3.chars, 0) || 1;
+    const display = s.fonts.reduce((n, f3) => n + f3.displayChars, 0) || 1;
+    const hits = [];
+    const seen = /* @__PURE__ */ new Set();
+    const h1 = s.headings.find((h) => h.level === 1);
+    const h1Name = h1 ? wanted.get(normaliseFamily(h1.family).toLowerCase()) : void 0;
+    if (h1 && h1Name) {
+      seen.add(h1Name);
+      hits.push(hit(s, `${h1Name} sets the headline`, h1.text));
+    }
+    for (const font of s.fonts) {
+      const name = wanted.get(normaliseFamily(font.family).toLowerCase());
+      if (!name || seen.has(name)) continue;
+      const share = font.chars / total;
+      const displayShare = font.displayChars / display;
+      if (share >= 0.15 || displayShare >= 0.3) {
+        seen.add(name);
+        hits.push(hit(s, `${name} sets ${pct(share)} of the text on the page${displayShare >= 0.3 ? ` and ${pct(displayShare)} of the headings` : ""}`));
+      }
+    }
+    return hits;
+  };
+}
+function violetHits2(s) {
+  const hits = [];
+  const controls = s.controls.filter((c) => {
+    const o = oklchOf(c.background);
+    return o !== null && (parseColour(c.background)?.alpha ?? 1) > 0.5 && isAiViolet(o);
+  });
+  if (controls.length > 0) hits.push(hit(s, `${controls.length} button${controls.length === 1 ? "" : "s"} filled with an indigo-violet accent`, `${controls[0].text}: ${controls[0].background}`));
+  const totalChars = s.colours.text.reduce((n, t) => n + t.chars, 0) || 1;
+  const violetText = s.colours.text.filter((t) => {
+    const o = oklchOf(t.value);
+    return o !== null && isAiViolet(o);
+  });
+  const textChars = violetText.reduce((n, t) => n + t.chars, 0);
+  if (textChars >= 40 && textChars / totalChars >= 0.01) hits.push(hit(s, `${pct(textChars / totalChars)} of the text is set in indigo-violet`, violetText[0].value));
+  const pageArea = s.pageHeight * s.viewport.width || 1;
+  const violetBg = s.colours.backgrounds.filter((b) => {
+    const o = oklchOf(b.value);
+    return o !== null && (parseColour(b.value)?.alpha ?? 1) > 0.5 && isAiViolet(o);
+  });
+  const bgArea = violetBg.reduce((n, b) => n + b.area, 0);
+  if (bgArea / pageArea >= 0.01 && controls.length === 0) hits.push(hit(s, `indigo-violet covers ${pct(bgArea / pageArea)} of the page`, violetBg[0].value));
+  return hits;
+}
+function blueToPurple(s) {
+  const hits = [];
+  for (const g of s.effects.gradients) {
+    const hues = g.stops.map(oklchOf).filter((o) => o !== null && o.c >= 0.08).map((o) => o.h);
+    if (hues.some((h) => h >= 235 && h <= 272) && hues.some((h) => h >= 285 && h <= 330)) {
+      hits.push(hit(s, "a blue-to-purple gradient covers a large area", g.stops.join(" \u2192 ")));
+    }
+  }
+  return hits;
+}
+var count = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+var RENDERED_PATHS = {
+  "reflex-font": {
+    detect: reflexFonts(REFLEX_FONTS_1),
+    fixtures: {
+      flag: [makeSnapshot({ fonts: [{ family: "__Inter_d65c78", chars: 5e3, displayChars: 900, italicChars: 0, weights: [400, 700] }] })],
+      pass: [makeSnapshot(), makeSnapshot({ fonts: [{ family: "S\xF6hne", chars: 5e3, displayChars: 900, italicChars: 0, weights: [400] }, { family: "Inter", chars: 60, displayChars: 0, italicChars: 0, weights: [400] }] })]
+    }
+  },
+  "reflex-font-2": {
+    detect: reflexFonts(REFLEX_FONTS_2),
+    fixtures: {
+      flag: [
+        makeSnapshot({ fonts: [{ family: "S\xF6hne", chars: 4200, displayChars: 0, italicChars: 0, weights: [400] }, { family: "Fraunces", chars: 900, displayChars: 900, italicChars: 0, weights: [500] }] }),
+        makeSnapshot({ headings: [{ level: 1, family: "Instrument Serif", sizePx: 72, weight: 400, italic: false, italicPart: false, text: "Beauty", top: 200 }] })
+      ],
+      pass: [makeSnapshot()]
+    }
+  },
+  "ai-violet": {
+    detect: violetHits2,
+    fixtures: {
+      flag: [
+        makeSnapshot({ controls: [{ kind: "button", radiusPx: 4, heightPx: 44, background: "oklch(0.541 0.281 293.009)", text: "Get started" }] }),
+        makeSnapshot({ colours: { backgrounds: makeSnapshot().colours.backgrounds, text: [{ value: "rgb(28, 28, 26)", area: 0, chars: 5e3 }, { value: "rgb(79, 70, 229)", area: 0, chars: 400 }] } }),
+        makeSnapshot({ colours: { text: makeSnapshot().colours.text, backgrounds: [{ value: "rgb(255, 255, 255)", area: 5e6, chars: 0 }, { value: "rgb(90, 53, 209)", area: 4e5, chars: 0 }] } })
+      ],
+      pass: [makeSnapshot(), makeSnapshot({ controls: [{ kind: "button", radiusPx: 4, heightPx: 44, background: "rgb(30, 58, 138)", text: "Book" }] })]
+    }
+  },
+  "blue-purple-gradient": {
+    detect: blueToPurple,
+    fixtures: {
+      flag: [makeSnapshot({ effects: { gradients: [{ stops: ["rgb(37, 99, 235)", "rgb(147, 51, 234)"], area: 12e5, radial: false }] } })],
+      pass: [makeSnapshot({ effects: { gradients: [{ stops: ["rgb(250, 247, 240)", "rgb(255, 255, 255)"], area: 12e5, radial: false }] } })]
+    }
+  },
+  "gradient-text": {
+    detect: (s) => s.effects.gradientText > 0 ? [hit(s, `${count(s.effects.gradientText, "heading")} painted with a gradient`)] : [],
+    fixtures: { flag: [makeSnapshot({ effects: { gradientText: 1 } })], pass: [makeSnapshot()] }
+  },
+  "glass-panel": {
+    detect: (s) => s.effects.glass > 0 ? [hit(s, `${count(s.effects.glass, "translucent blurred panel")}`)] : [],
+    fixtures: { flag: [makeSnapshot({ effects: { glass: 2 } })], pass: [makeSnapshot()] }
+  },
+  "cream-palette": {
+    detect: (s) => {
+      const ground = oklchOf(s.ground);
+      if (ground && isCream(ground)) return [hit(s, "the page ground is a warm off-white", s.ground)];
+      const pageArea = s.pageHeight * s.viewport.width || 1;
+      const cream = s.colours.backgrounds.find((b) => {
+        const o = oklchOf(b.value);
+        return o !== null && isCream(o) && b.area / pageArea >= 0.3;
+      });
+      return cream ? [hit(s, `a warm off-white covers ${pct(cream.area / pageArea)} of the page`, cream.value)] : [];
+    },
+    fixtures: {
+      flag: [makeSnapshot({ ground: "rgb(250, 246, 238)" }), makeSnapshot({ colours: { text: makeSnapshot().colours.text, backgrounds: [{ value: "rgb(245, 240, 230)", area: 3e6, chars: 0 }] } })],
+      pass: [makeSnapshot(), makeSnapshot({ ground: "rgb(254, 252, 232)" })]
+    }
+  },
+  "italic-serif-display": {
+    detect: (s) => {
+      const h = s.headings.find((x) => x.level <= 2 && fontClass(x.family) === "serif" && (x.italic || x.italicPart));
+      return h ? [hit(s, `a serif ${h.level === 1 ? "headline" : "heading"} with an italic turn`, h.text)] : [];
+    },
+    fixtures: {
+      flag: [makeSnapshot({ headings: [{ level: 1, family: "__Instrument_Serif_1a2b3c", sizePx: 72, weight: 400, italic: false, italicPart: true, text: "Beauty, reimagined", top: 200 }] })],
+      pass: [makeSnapshot(), makeSnapshot({ headings: [{ level: 1, family: "S\xF6hne", sizePx: 64, weight: 600, italic: false, italicPart: true, text: "Boilers, fixed", top: 200 }] })]
+    }
+  },
+  "hero-eyebrow-chip": {
+    detect: (s) => s.effects.eyebrowChip ? [hit(s, "a small bordered pill sits above the headline")] : [],
+    fixtures: { flag: [makeSnapshot({ effects: { eyebrowChip: true } })], pass: [makeSnapshot()] }
+  },
+  "icon-tile-grid": {
+    detect: (s) => s.sections.filter((x) => x.cards >= 3 && x.iconCards >= 3).map((x) => hit(s, `${x.iconCards} icon cards in a row`, x.label)),
+    fixtures: {
+      flag: [makeSnapshot({ sections: [...makeSnapshot().sections.slice(0, 2), { top: 1700, height: 700, kind: "cards", label: "Our services", cards: 3, iconCards: 3, hiddenAtLoad: false }] })],
+      pass: [makeSnapshot()]
+    }
+  },
+  "hero-then-proof": {
+    detect: (s) => {
+      const [first, second] = s.sections;
+      return first?.kind === "hero" && second && ["logos", "stats", "marquee"].includes(second.kind) ? [hit(s, `the hero is followed straight away by ${second.kind === "stats" ? "a row of numbers" : "a strip of logos"}`, second.label)] : [];
+    },
+    fixtures: {
+      flag: [
+        makeSnapshot({ sections: [makeSnapshot().sections[0], { top: 800, height: 160, kind: "logos", label: "Trusted by", cards: 0, iconCards: 0, hiddenAtLoad: false }, ...makeSnapshot().sections.slice(1)] }),
+        makeSnapshot({ sections: [makeSnapshot().sections[0], { top: 800, height: 220, kind: "stats", label: "500+", cards: 0, iconCards: 0, hiddenAtLoad: false }] })
+      ],
+      pass: [makeSnapshot()]
+    }
+  },
+  "reveal-everywhere": {
+    detect: (s) => {
+      const below = s.sections.filter((x) => x.top > s.viewport.height).length;
+      const hidden = s.motion.hiddenSections;
+      return hidden >= 4 && below > 0 && hidden / below >= 0.6 ? [hit(s, `${hidden} of ${below} sections below the fold wait for a scroll to appear`)] : [];
+    },
+    fixtures: {
+      flag: [makeSnapshot({ motion: { hiddenSections: 4 }, sections: makeSnapshot().sections.map((x, i) => ({ ...x, hiddenAtLoad: i > 0 })) })],
+      pass: [makeSnapshot(), makeSnapshot({ motion: { hiddenSections: 1 } })]
+    }
+  },
+  "pill-everything": {
+    detect: (s) => {
+      const pills = s.controls.filter((c) => c.radiusPx >= c.heightPx / 2 - 1);
+      return s.controls.length >= 4 && pills.length / s.controls.length >= 0.8 ? [hit(s, `${pills.length} of ${s.controls.length} buttons are pills`)] : [];
+    },
+    fixtures: {
+      flag: [makeSnapshot({ controls: makeSnapshot().controls.map((c) => ({ ...c, radiusPx: 9999 })) })],
+      pass: [makeSnapshot(), makeSnapshot({ controls: makeSnapshot().controls.slice(0, 2).map((c) => ({ ...c, radiusPx: 9999 })) })]
+    }
+  },
+  "radial-spotlight-glow": {
+    detect: (s) => {
+      const radial = s.effects.gradients.filter((g) => g.radial).length;
+      const n = s.effects.glows + radial;
+      return n > 0 ? [hit(s, `${count(n, "soft glow")} behind the content`)] : [];
+    },
+    fixtures: {
+      flag: [makeSnapshot({ effects: { glows: 1 } }), makeSnapshot({ effects: { gradients: [{ stops: ["rgba(99, 102, 241, 0.3)", "rgba(0, 0, 0, 0)"], area: 9e5, radial: true }] } })],
+      pass: [makeSnapshot()]
+    }
+  },
+  "grid-background": {
+    detect: (s) => s.effects.gridBackgrounds > 0 ? [hit(s, `${count(s.effects.gridBackgrounds, "graph-paper background")}`)] : [],
+    fixtures: { flag: [makeSnapshot({ effects: { gridBackgrounds: 1 } })], pass: [makeSnapshot()] }
+  },
+  marquee: {
+    detect: (s) => s.effects.marquees > 0 ? [hit(s, `${count(s.effects.marquees, "endless scrolling strip")}`)] : [],
+    fixtures: { flag: [makeSnapshot({ effects: { marquees: 1 } })], pass: [makeSnapshot()] }
+  },
+  "thin-border-wide-shadow": {
+    detect: (s) => s.effects.hairlineShadowCards >= 3 ? [hit(s, `${s.effects.hairlineShadowCards} cards with a hairline border under a wide shadow`)] : [],
+    fixtures: { flag: [makeSnapshot({ effects: { hairlineShadowCards: 3 } })], pass: [makeSnapshot(), makeSnapshot({ effects: { hairlineShadowCards: 1 } })] }
+  },
+  "intro-cinematic": {
+    detect: (s) => s.motion.introOverlay ? [hit(s, "a full-screen layer covers the page at load and then leaves")] : [],
+    fixtures: { flag: [makeSnapshot({ motion: { introOverlay: true } })], pass: [makeSnapshot()] }
+  }
+};
+
+// src/character/check.ts
+var CATALOGUE_VERSION = "2026.09.3";
+var CATALOGUE = [...SOURCE_TELLS, ...COPY_TELLS].map(
+  (t) => RENDERED_PATHS[t.id] ? { ...t, rendered: RENDERED_PATHS[t.id] } : t
+);
+function tellById(id) {
+  return CATALOGUE.find((t) => t.id === id);
+}
+function validateExceptions(exceptions) {
+  const applied = [];
+  const rejected = [];
+  for (const exception of exceptions) {
+    if (!tellById(exception.tell)) {
+      rejected.push({ exception, reason: `no tell called "${exception.tell}"` });
+    } else if (typeof exception.because !== "string" || exception.because.trim().length < 12) {
+      rejected.push({ exception, reason: "an exception needs a because of at least a sentence" });
+    } else {
+      applied.push(exception);
+    }
+  }
+  return { applied, rejected };
+}
+var MARKER = /\b(?:copy|craft)-ok\b/;
+function marked(lines, line) {
+  return MARKER.test(lines[line - 1] ?? "") || MARKER.test(lines[line - 2] ?? "");
+}
+function toFinding(tell, hit2, texts) {
+  const text = texts.get(hit2.path) ?? "";
+  return {
+    tell: tell.id,
+    name: tell.name,
+    generation: tell.generation,
+    severity: tell.severity,
+    path: hit2.path,
+    line: texts.has(hit2.path) ? lineAt(text, hit2.offset) : 0,
+    excerpt: hit2.excerpt ?? excerptAt(text, hit2.offset),
+    message: hit2.message,
+    fix: tell.fix
+  };
+}
+function report(tells, files, run, options) {
+  const { applied, rejected } = validateExceptions(options.exceptions ?? []);
+  const texts = new Map(files.map((file) => [file.path, file.text]));
+  const selected = options.only ? tells.filter((t) => options.only.includes(t.id)) : tells;
+  const findings = [];
+  const suppressed = [];
+  const lineCache = /* @__PURE__ */ new Map();
+  const linesOf = (path) => {
+    let lines = lineCache.get(path);
+    if (!lines) lineCache.set(path, lines = (texts.get(path) ?? "").split("\n"));
+    return lines;
+  };
+  const excepted = /* @__PURE__ */ new Map();
+  for (const tell of selected) {
+    for (const hit2 of run(tell)) {
+      const exception = applied.find((e) => e.tell === tell.id && (!e.path || hit2.path.includes(e.path)));
+      if (exception) {
+        excepted.set(exception, (excepted.get(exception) ?? 0) + 1);
+        continue;
+      }
+      const finding = toFinding(tell, hit2, texts);
+      if (marked(linesOf(hit2.path), finding.line)) {
+        suppressed.push({ tell: tell.id, path: finding.path, line: finding.line });
+        continue;
+      }
+      findings.push(finding);
+    }
+  }
+  findings.sort((a, b) => a.path.localeCompare(b.path) || a.line - b.line || a.tell.localeCompare(b.tell));
+  const byGeneration = { 1: 0, 2: 0, 3: 0 };
+  const byTell = {};
+  for (const finding of findings) {
+    byGeneration[finding.generation] += 1;
+    byTell[finding.tell] = (byTell[finding.tell] ?? 0) + 1;
+  }
+  return {
+    catalogueVersion: CATALOGUE_VERSION,
+    findings,
+    rejectedExceptions: rejected,
+    excepted: [...excepted].map(([e, count2]) => ({ tell: e.tell, because: e.because, count: count2 })),
+    suppressed,
+    summary: {
+      files: files.length,
+      findings: findings.length,
+      byGeneration,
+      byTell,
+      blocking: findings.filter((x) => x.severity === "block").length
+    }
+  };
+}
+function scanSource(files, options = {}) {
+  const ctx = { files: files.map(parseFile) };
+  const tells = CATALOGUE.filter((t) => t.surface === "source");
+  return report(tells, files, (tell) => tell.surface === "source" ? tell.detect(ctx) : [], options);
+}
+function copyContext(files) {
+  return { files, blocks: files.flatMap(extractCopy), strings: files.flatMap(extractStrings) };
+}
+function checkCopy(files, options = {}) {
+  const ctx = copyContext(files);
+  const tells = CATALOGUE.filter((t) => t.surface === "copy");
+  return report(tells, files, (tell) => tell.surface === "copy" ? tell.detect(ctx) : [], options);
+}
+function auditSnapshot(snapshot, options = {}) {
+  const tells = CATALOGUE.filter((t) => t.rendered);
+  const result = report(tells, [], (tell) => tell.rendered.detect(snapshot), options);
+  result.summary.files = 1;
+  return result;
+}
+function runTell(tell, files) {
+  if (tell.surface === "source") return tell.detect({ files: files.map(parseFile) });
+  return tell.detect(copyContext(files));
+}
+function catalogueTable() {
+  const rows = CATALOGUE.map(
+    (t) => `| \`${t.id}\` | ${t.generation} | ${t.surface}${t.rendered ? " + rendered" : ""} | ${t.severity} | ${t.name} | ${t.why.replace(/\|/g, "\\|")} |`
+  );
+  return [
+    `Catalogue version \`${CATALOGUE_VERSION}\`, ${CATALOGUE.length} tells.`,
+    "",
+    "| Id | Gen | Surface | Severity | Tell | Why it is a default |",
+    "| --- | --- | --- | --- | --- | --- |",
+    ...rows
+  ].join("\n");
+}
+
+// src/character/format.ts
+function formatReport(report2, title) {
+  const lines = [];
+  let current = "";
+  for (const f3 of report2.findings) {
+    if (f3.path !== current) {
+      current = f3.path;
+      lines.push("", f3.path);
+    }
+    lines.push(`  ${String(f3.line).padStart(4)}  ${f3.tell} (gen ${f3.generation}, ${f3.severity})  ${f3.message}`);
+    lines.push(`        ${f3.excerpt}`);
+  }
+  const fixes = new Map(report2.findings.map((f3) => [f3.tell, f3.fix]));
+  if (fixes.size > 0) {
+    lines.push("", "What to do instead:");
+    for (const [tell, fix] of fixes) lines.push(`  ${tell}: ${fix}`);
+  }
+  for (const r of report2.rejectedExceptions) {
+    lines.push("", `Exception not applied (${r.exception.tell}): ${r.reason}`);
+  }
+  for (const e of report2.excepted) {
+    lines.push("", `Excepted: ${e.count} \xD7 ${e.tell}, because ${e.because}`);
+  }
+  if (report2.suppressed.length > 0) {
+    lines.push("", `Suppressed: ${report2.suppressed.length} marked copy-ok or craft-ok (${report2.suppressed.map((s) => `${s.path}:${s.line}`).join(", ")})`);
+  }
+  const { summary } = report2;
+  const gens = `gen 1: ${summary.byGeneration[1]}, gen 2: ${summary.byGeneration[2]}, gen 3: ${summary.byGeneration[3]}`;
+  lines.push(
+    "",
+    `${title}: ${summary.findings} finding${summary.findings === 1 ? "" : "s"} in ${summary.files} file${summary.files === 1 ? "" : "s"} (${gens}). Catalogue ${report2.catalogueVersion}.`
+  );
+  return lines.join("\n").replace(/^\n/, "");
+}
+
+// src/fingerprint/index.ts
+var FINGERPRINT_VERSION = 1;
+var CHROMATIC = 0.03;
+var oklch = (value) => {
+  const parsed = parseColour(value);
+  return parsed && parsed.alpha > 0.5 ? parsed.oklch : null;
+};
+function accentOf(s) {
+  const buttons = /* @__PURE__ */ new Map();
+  for (const c of s.controls) {
+    const o = oklch(c.background);
+    if (o && o.c >= CHROMATIC) buttons.set(c.background, (buttons.get(c.background) ?? 0) + 1);
+  }
+  const topButton = [...buttons].sort((a, b) => b[1] - a[1])[0];
+  if (topButton) return oklch(topButton[0]);
+  const bg = s.colours.backgrounds.map((b) => ({ o: oklch(b.value), w: b.area })).filter((x) => x.o && x.o.c >= CHROMATIC).sort((a, b) => b.w - a.w)[0];
+  if (bg) return bg.o;
+  const text = s.colours.text.map((t) => ({ o: oklch(t.value), w: t.chars })).filter((x) => x.o && x.o.c >= CHROMATIC).sort((a, b) => b.w - a.w)[0];
+  return text ? text.o : null;
+}
+function faces(s) {
+  const byChars = [...s.fonts].sort((a, b) => b.chars - a.chars);
+  const byDisplay = [...s.fonts].sort((a, b) => b.displayChars - a.displayChars);
+  const bodyName = normaliseFamily(byChars[0]?.family ?? "system-ui");
+  const displayName = normaliseFamily((byDisplay[0]?.displayChars ? byDisplay[0].family : byChars[0]?.family) ?? "system-ui");
+  return {
+    display: { family: displayName, class: fontClass(displayName) },
+    body: { family: bodyName, class: fontClass(bodyName) }
+  };
+}
+function median(values) {
+  if (values.length === 0) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+function fingerprint(s) {
+  const effects = [];
+  if (s.effects.glass > 0) effects.push("glass-panel");
+  if (s.effects.gradientText > 0) effects.push("gradient-text");
+  if (s.effects.glows > 0 || s.effects.gradients.some((g) => g.radial)) effects.push("radial-spotlight-glow");
+  if (s.effects.gridBackgrounds > 0) effects.push("grid-background");
+  if (s.effects.marquees > 0) effects.push("marquee");
+  if (s.effects.hairlineShadowCards >= 3) effects.push("thin-border-wide-shadow");
+  if (s.effects.eyebrowChip) effects.push("hero-eyebrow-chip");
+  if (s.motion.introOverlay) effects.push("intro-cinematic");
+  const below = s.sections.filter((x) => x.top > s.viewport.height).length;
+  return {
+    version: FINGERPRINT_VERSION,
+    accent: accentOf(s),
+    ground: oklch(s.ground) ?? { l: 1, c: 0, h: 0 },
+    ...faces(s),
+    roundness: median(s.controls.map((c) => Math.min(0.5, c.radiusPx / Math.max(1, c.heightPx)))),
+    motion: below ? Math.min(1, s.motion.hiddenSections / below) : 0,
+    effects: effects.sort(),
+    layout: s.sections.map((x) => x.kind)
+  };
+}
+var DISTANCE_WEIGHTS = { accent: 0.25, type: 0.25, ground: 0.1, shape: 0.1, motion: 0.1, effects: 0.1, layout: 0.1 };
+function levenshtein(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i += 1) {
+    let prev = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j += 1) {
+      const cur = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+      prev = cur;
+    }
+  }
+  return row[b.length];
+}
+var clamp = (n) => Math.max(0, Math.min(1, n));
+function faceDistance(a, b) {
+  if (a.family.toLowerCase() === b.family.toLowerCase()) return 0;
+  return a.class === b.class ? 0.5 : 1;
+}
+function fingerprintDistance(a, b) {
+  const accent = a.accent && b.accent ? clamp(deltaEOk(a.accent, b.accent) / 0.3) : a.accent || b.accent ? 1 : 0;
+  const ground = clamp(deltaEOk(a.ground, b.ground) / 0.15);
+  const type = 0.6 * faceDistance(a.display, b.display) + 0.4 * faceDistance(a.body, b.body);
+  const shape = a.roundness === null || b.roundness === null ? a.roundness === b.roundness ? 0 : 0.5 : clamp(Math.abs(a.roundness - b.roundness) / 0.5);
+  const motion = clamp(Math.abs(a.motion - b.motion));
+  const union = /* @__PURE__ */ new Set([...a.effects, ...b.effects]);
+  const shared = a.effects.filter((e) => b.effects.includes(e)).length;
+  const effects = union.size === 0 ? 0 : 1 - shared / union.size;
+  const longest = Math.max(a.layout.length, b.layout.length);
+  const layout = longest === 0 ? 0 : levenshtein(a.layout, b.layout) / longest;
+  const parts2 = { accent, ground, type, shape, motion, effects, layout };
+  const total = Object.keys(DISTANCE_WEIGHTS).reduce((sum, k) => sum + DISTANCE_WEIGHTS[k] * parts2[k], 0);
+  return { total: Math.round(total * 1e3) / 1e3, parts: parts2 };
+}
+function nearest(target, set, k = set.length) {
+  return set.map((item) => ({ id: item.id, distance: fingerprintDistance(target, item.fingerprint) })).sort((x, y) => x.distance.total - y.distance.total).slice(0, k);
+}
+
+// src/direction/types.ts
+var DIRECTION_VERSION = 1;
+var SOURCE_KINDS = [
+  "livery",
+  "shopfront",
+  "signage",
+  "packaging",
+  "product",
+  "uniform",
+  "interior",
+  "place",
+  "material",
+  "trade",
+  "print",
+  "photo",
+  "founder"
+];
+var CHOICE_KEYS = ["accent", "ground", "display", "body", "shape", "motif", "signature"];
+
+// src/direction/validate.ts
+var PREFERENCE = /\b(?:client (?:likes|liked|wants|wanted|asked|chose|prefers?)|(?:we|they|i) (?:like|liked|love|loved|prefer)|on[- ]trend|trendy|popular|what (?:everyone|competitors) (?:uses?|does)|brand (?:colou?r|font|guidelines?) (?:is|are|says?))\b/i;
+var MOOD = /\b(?:modern|clean|fresh|professional|trustworthy|premium|elegant|sleek|timeless|minimal(?:ist)?|bold|vibrant|friendly|approachable|luxur(?:y|ious)|sophisticated|contemporary|stylish|warm|inviting|high[- ]end)\b/gi;
+var VALUE_WORDS = /* @__PURE__ */ new Set(["green", "blue", "navy", "black", "white", "cream", "grey", "gray", "gold", "yellow", "orange", "purple", "violet", "pink", "brown", "teal", "bottle", "dark", "light", "deep", "pale", "bright", "colour", "color", "font", "face", "serif", "sans", "type", "lettering"]);
+var STOP = /* @__PURE__ */ new Set(["with", "that", "this", "from", "their", "they", "have", "been", "were", "which", "what", "when", "where", "there", "about", "into", "onto", "over", "same", "each", "every"]);
+function words(text) {
+  return new Set((text.toLowerCase().match(/[a-z][a-z'-]{3,}/g) ?? []).map((w) => w.replace(/'s$/, "")).filter((w) => !STOP.has(w) && !VALUE_WORDS.has(w)));
+}
+function tellFor(key, value) {
+  if (key === "accent") {
+    const c = parseColour(value);
+    return c && isAiViolet(c.oklch) ? "ai-violet" : null;
+  }
+  if (key === "ground") {
+    const c = parseColour(value);
+    return c && isCream(c.oklch) ? "cream-palette" : null;
+  }
+  if (key === "display" || key === "body") {
+    const name = normaliseFamily(value).toLowerCase();
+    if (REFLEX_FONTS_1.some((f3) => f3.toLowerCase() === name)) return "reflex-font";
+    if (REFLEX_FONTS_2.some((f3) => f3.toLowerCase() === name)) return "reflex-font-2";
+  }
+  return null;
+}
+function validateDirection(input, ctx = {}) {
+  const problems = [];
+  const err = (at, message) => problems.push({ severity: "error", at, message });
+  const warn = (at, message) => problems.push({ severity: "warn", at, message });
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    err("", "art-direction.json must be a JSON object");
+    return { valid: false, problems, decided: 0 };
+  }
+  const d = input;
+  const legacy = d.version === void 0 && d.choices === void 0 && Array.isArray(d.exceptions);
+  if (legacy) {
+    warn("", "exceptions only: run craft direction init to record the choices and their reasons");
+    return { valid: true, problems, decided: 0 };
+  }
+  if (d.version !== DIRECTION_VERSION) err("version", `version must be ${DIRECTION_VERSION}`);
+  if (typeof d.client !== "string" || !d.client.trim()) err("client", "name the client");
+  if (typeof d.brief !== "string" || d.brief.trim().split(/\s+/).length < 8) err("brief", "the brief needs a sentence: who, where, and what they do");
+  const sources = Array.isArray(d.sources) ? d.sources : [];
+  if (!Array.isArray(d.sources)) err("sources", "sources must be a list");
+  if (sources.length === 0) err("sources", "no sources: a reason needs something in the client's world to point at");
+  const ids = /* @__PURE__ */ new Set();
+  sources.forEach((s, i) => {
+    const at = `sources[${i}]`;
+    if (!s || typeof s !== "object") return err(at, "a source must be an object");
+    if (typeof s.id !== "string" || !/^[a-z0-9][a-z0-9-]*$/.test(s.id)) err(`${at}.id`, "id must be short kebab-case");
+    else if (ids.has(s.id)) err(`${at}.id`, `"${s.id}" is used twice`);
+    else ids.add(s.id);
+    if (!SOURCE_KINDS.includes(s.kind)) err(`${at}.kind`, `kind must be one of: ${SOURCE_KINDS.join(", ")}`);
+    if (typeof s.note !== "string" || s.note.trim().split(/\s+/).length < 3) err(`${at}.note`, "say what it is and where");
+    if (s.path && ctx.pathExists && !/^https?:/.test(s.path) && !ctx.pathExists(s.path)) err(`${at}.path`, `${s.path} does not exist`);
+    for (const [j, c] of (s.colours ?? []).entries()) if (!parseColour(c)) err(`${at}.colours[${j}]`, `"${c}" is not a colour`);
+  });
+  const choices = d.choices && typeof d.choices === "object" ? d.choices : {};
+  if (!d.choices || typeof d.choices !== "object") err("choices", "choices must be an object");
+  const exceptions = Array.isArray(d.exceptions) ? d.exceptions : [];
+  let decided = 0;
+  for (const key of Object.keys(choices)) {
+    if (!CHOICE_KEYS.includes(key)) err(`choices.${key}`, `not a choice craft knows. Choices are: ${CHOICE_KEYS.join(", ")}. Layout and navigation stay conventional.`);
+  }
+  for (const key of CHOICE_KEYS) {
+    const c = choices[key];
+    const at = `choices.${key}`;
+    if (!c) {
+      warn(at, "not decided yet");
+      continue;
+    }
+    let ok = true;
+    if (typeof c.value !== "string" || !c.value.trim()) {
+      err(`${at}.value`, "no value");
+      ok = false;
+    } else if ((key === "accent" || key === "ground") && !parseColour(c.value)) {
+      err(`${at}.value`, `"${c.value}" is not a colour`);
+      ok = false;
+    }
+    const because = typeof c.because === "string" ? c.because.trim() : "";
+    const evidence = Array.isArray(c.evidence) ? c.evidence : [];
+    if (because.split(/\s+/).filter(Boolean).length < 8) {
+      err(`${at}.because`, "a reason is at least a sentence. Without one this is a default, however good it looks.");
+      ok = false;
+    } else if (because.startsWith("PROPOSED:")) {
+      err(`${at}.because`, "a proposal, not yet a decision. Check it against the source, then rewrite the reason in your own words.");
+      ok = false;
+    } else {
+      if (PREFERENCE.test(because)) {
+        err(`${at}.because`, "that is a preference, not a reason. Say what in the client's world this comes from.");
+        ok = false;
+      }
+      const moods = because.match(MOOD) ?? [];
+      if (moods.length >= 2) {
+        err(`${at}.because`, `"${moods.join(", ")}" describes a mood, not a source. Name the thing it comes from.`);
+        ok = false;
+      }
+    }
+    if (evidence.length === 0) {
+      err(`${at}.evidence`, "cite at least one source");
+      ok = false;
+    }
+    for (const id of evidence) {
+      if (!ids.has(id)) {
+        err(`${at}.evidence`, `no source called "${id}"`);
+        ok = false;
+      }
+    }
+    if (ok) {
+      const cited = sources.filter((s) => evidence.includes(s.id));
+      const reasonWords = words(because);
+      const tied = cited.some((s) => reasonWords.has(s.id) || [...words(`${s.note} ${s.lettering ?? ""}`)].some((w) => reasonWords.has(w)));
+      if (!tied) {
+        err(`${at}.because`, `the reason does not mention what its evidence shows (${evidence.join(", ")}). Say what on it this comes from.`);
+        ok = false;
+      }
+    }
+    if (typeof c.value === "string") {
+      const tell = tellFor(key, c.value);
+      if (tell && !exceptions.some((e) => e.tell === tell)) {
+        err(`${at}.value`, `${c.value} is on the tell catalogue (${tell}). Keep it only with an exception for ${tell}, carrying the same reason.`);
+        ok = false;
+      }
+    }
+    const fp = ctx.fingerprint;
+    if (fp && typeof c.value === "string") {
+      if ((key === "accent" || key === "ground") && parseColour(c.value)) {
+        const declared = parseColour(c.value).oklch;
+        const measured = key === "accent" ? fp.accent : fp.ground;
+        if (measured && deltaEOk(declared, measured) > 0.08) {
+          warn(`${at}.value`, `the page does not show it: its ${key} measures oklch(${measured.l.toFixed(2)} ${measured.c.toFixed(3)} ${measured.h.toFixed(0)})`);
+        }
+      }
+      if (key === "display" || key === "body") {
+        const measured = key === "display" ? fp.display.family : fp.body.family;
+        if (normaliseFamily(c.value).toLowerCase() !== measured.toLowerCase()) warn(`${at}.value`, `the page sets ${measured}, not ${c.value}`);
+      }
+    }
+    if (ok) decided += 1;
+  }
+  return { valid: problems.every((p) => p.severity !== "error"), problems, decided };
+}
+
+// src/direction/init.ts
+var hex = (o) => {
+  const { r, g, b } = oklchToRgb(o);
+  const clamp2 = (n) => Math.min(1, Math.max(0, n));
+  return formatHex({ r: clamp2(r), g: clamp2(g), b: clamp2(b) });
+};
+function initDirection(input) {
+  const fp = input.current;
+  const empty = (value) => ({ value, because: "", evidence: [] });
+  const choices = fp ? {
+    ...fp.accent ? { accent: empty(hex(fp.accent)) } : {},
+    ground: empty(hex(fp.ground)),
+    display: empty(fp.display.family),
+    body: empty(fp.body.family),
+    ...fp.roundness !== null ? { shape: empty(fp.roundness >= 0.45 ? "pill buttons" : fp.roundness <= 0.05 ? "square corners" : `corners at ${Math.round(fp.roundness * 100)}% of button height`) } : {}
+  } : {};
+  return {
+    $schema: "https://unpkg.com/@domandigital/craft/art-direction.schema.json",
+    version: DIRECTION_VERSION,
+    client: input.client ?? "",
+    brief: input.brief ?? "",
+    sources: [],
+    choices,
+    ...input.exceptions?.length ? { exceptions: input.exceptions } : {}
+  };
+}
+
+// src/direction/propose.ts
+var PROPOSED = "PROPOSED:";
+function srgbToLinear2(c) {
+  return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+function toLab(r, g, b) {
+  const lr = srgbToLinear2(r / 255);
+  const lg = srgbToLinear2(g / 255);
+  const lb = srgbToLinear2(b / 255);
+  const l = Math.cbrt(0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb);
+  const m = Math.cbrt(0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb);
+  const s = Math.cbrt(0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb);
+  return [0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s, 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s, 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s];
+}
+function paletteFromPixels(rgba, k = 6, maxSamples = 2e4) {
+  const total = Math.floor(rgba.length / 4);
+  const step = Math.max(1, Math.floor(total / maxSamples));
+  const px = [];
+  for (let i = 0; i < total; i += step) {
+    const o = i * 4;
+    if (rgba[o + 3] < 128) continue;
+    px.push({ lab: toLab(rgba[o], rgba[o + 1], rgba[o + 2]), rgb: [rgba[o], rgba[o + 1], rgba[o + 2]] });
+  }
+  if (px.length === 0) return [];
+  const sorted = [...px].sort((a, b) => a.lab[0] - b.lab[0]);
+  const n = Math.min(k, px.length);
+  let centres = Array.from({ length: n }, (_, i) => sorted[Math.floor((i + 0.5) / n * sorted.length)].lab.slice());
+  let assign = new Array(px.length).fill(0);
+  for (let iter = 0; iter < 12; iter += 1) {
+    assign = px.map((p) => {
+      let best = 0;
+      let bestD = Infinity;
+      centres.forEach((c, j) => {
+        const d = (p.lab[0] - c[0]) ** 2 + (p.lab[1] - c[1]) ** 2 + (p.lab[2] - c[2]) ** 2;
+        if (d < bestD) {
+          bestD = d;
+          best = j;
+        }
+      });
+      return best;
+    });
+    centres = centres.map((c, j) => {
+      const members = px.filter((_, i) => assign[i] === j);
+      if (members.length === 0) return c;
+      return [0, 1, 2].map((d) => members.reduce((s, m) => s + m.lab[d], 0) / members.length);
+    });
+  }
+  return centres.map((_, j) => {
+    const members = px.filter((__, i) => assign[i] === j);
+    if (members.length === 0) return null;
+    const avg = [0, 1, 2].map((d) => members.reduce((s, m) => s + m.rgb[d], 0) / members.length / 255);
+    const hex2 = formatHex({ r: avg[0], g: avg[1], b: avg[2] });
+    return { hex: hex2, share: members.length / px.length, oklch: hexToOklch(hex2) };
+  }).filter((c) => c !== null).sort((a, b) => b.share - a.share);
+}
+var chromatic = (o) => o.c >= 0.04 && o.l >= 0.2 && o.l <= 0.85;
+function accentCandidates(input) {
+  const out = [];
+  for (const s of input.sources) {
+    for (const c of s.colours ?? []) {
+      const parsed = parseColour(c);
+      if (!parsed || !chromatic(parsed.oklch)) continue;
+      const o = parsed.oklch;
+      const siblings = (input.estate ?? []).map((e) => ({ id: e.id, d: e.fingerprint.accent ? deltaEOk(o, e.fingerprint.accent) : 1 }));
+      const nearest2 = siblings.sort((a, b) => a.d - b.d)[0];
+      const penalty = isAiViolet(o) ? 1 : 0;
+      out.push({
+        value: c.startsWith("#") ? c.toLowerCase() : c,
+        evidence: [s.id],
+        note: `from ${s.id} (${s.kind})${nearest2 ? `; nearest estate accent ${nearest2.id} at \u0394E ${nearest2.d.toFixed(2)}` : ""}${penalty ? "; in the reflex violet band" : ""}`,
+        score: (nearest2 ? Math.min(nearest2.d, 0.3) : 0.3) - penalty + o.c
+      });
+    }
+  }
+  return out.sort((a, b) => b.score - a.score).map(({ score: _s, ...rest }) => rest);
+}
+function groundCandidates(input) {
+  const out = [];
+  for (const s of input.sources) {
+    for (const c of s.colours ?? []) {
+      const parsed = parseColour(c);
+      if (!parsed || parsed.oklch.l < 0.9) continue;
+      out.push({ value: c, evidence: [s.id], note: `a light colour from ${s.id}${isCream(parsed.oklch) ? "; reads as the cream tell, needs its reason" : ""}` });
+    }
+  }
+  return out;
+}
+function typeCandidates(input) {
+  return input.sources.filter((s) => s.lettering).map((s) => ({ value: "", evidence: [s.id], note: `find a face with the character of "${s.lettering}" on ${s.id}` }));
+}
+function propose(input) {
+  const proposals = [
+    { key: "accent", candidates: accentCandidates(input) },
+    { key: "ground", candidates: groundCandidates(input) },
+    { key: "display", candidates: typeCandidates(input) }
+  ];
+  const choices = {};
+  const draft = (p) => {
+    const top = p.candidates[0];
+    if (!top || !top.value) return void 0;
+    const source = input.sources.find((s) => s.id === top.evidence[0]);
+    return {
+      value: top.value,
+      because: `${PROPOSED} taken from the ${source.id}: ${source.note} Confirm it matches, then rewrite this in your own words.`,
+      evidence: top.evidence
+    };
+  };
+  for (const p of proposals) {
+    const c = draft(p);
+    if (c) choices[p.key] = c;
+  }
+  return {
+    proposals,
+    direction: { version: DIRECTION_VERSION, client: input.client, brief: input.brief, sources: input.sources, choices }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AI_PHRASES,
+  AI_VIOLET,
+  AI_WORDS,
+  BUZZWORDS,
+  CATALOGUE,
+  CATALOGUE_VERSION,
+  CHOICE_KEYS,
   DENSITIES,
   DENSITY_NAMES,
+  DIRECTION_VERSION,
+  DISTANCE_WEIGHTS,
   DURATION_MS,
   DURATION_S,
   EASE,
   EASE_TUPLE,
   EXIT_RATIO,
+  FINGERPRINT_VERSION,
   HOUSE_BUDGET,
   HOUSE_TYPE,
   LIGHTNESS_CURVE,
+  NEGATIVE_REASSURANCE,
+  PILL_LIMIT,
+  PLAINER_WORDS,
+  PROPOSED,
   RAMP_STEPS,
+  REFLEX_FONTS_1,
+  REFLEX_FONTS_2,
+  RENDERED_PATHS,
+  REVEAL_LIMIT,
+  REVIEW_PHRASES,
   SCALE,
+  SHADCN_LIMIT,
+  SHADCN_PRIMITIVES,
+  SNAPSHOT_VERSION,
+  SOURCE_KINDS,
   SPACE_STEPS,
   SPRING,
+  STOCK_PHRASES,
   TYPE_STEPS,
+  VAGUE_WORDS,
   accentFork,
   apcaContrast,
+  auditSnapshot,
+  catalogueTable,
+  checkCopy,
   checkPair,
   checkRestraint,
   craftTokens,
@@ -1347,25 +4127,43 @@ var DENSITY_NAMES = Object.keys(DENSITIES);
   densityTokens,
   emitCss,
   exitDuration,
+  findColours,
+  fingerprint,
+  fingerprintDistance,
   fluidClamp,
   fluidSpace,
   fluidType,
+  fontClass,
   formatHex,
+  formatReport,
   hexToOklch,
   inP3Gamut,
   inSrgbGamut,
+  initDirection,
+  isAiViolet,
+  isCream,
+  makeSnapshot,
   motionTokens,
+  nearest,
+  normaliseFamily,
   oklchToHex,
   oklchToRgb,
+  paletteFromPixels,
+  parseColour,
   parseHex,
+  propose,
   ramp,
   rampFromAnchors,
+  runTell,
+  scanSource,
   sectionRhythm,
   semantic,
   shouldAnimate,
   tailwindV3Preset,
   tailwindV4Theme,
+  tellById,
   toGamut,
   typeFeatureTokens,
+  validateDirection,
   wcagContrast
 });