@domandigital/craft 0.5.0 → 0.6.0

package/dist/audit.cjs

@@ -0,0 +1,2444 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/audit/index.ts
+var audit_exports = {};
+__export(audit_exports, {
+  audit: () => audit,
+  collectInPage: () => collectInPage,
+  loadPlaywright: () => loadPlaywright,
+  overlayInPage: () => overlayInPage,
+  snapshotPage: () => snapshotPage,
+  snapshotUrl: () => snapshotUrl
+});
+module.exports = __toCommonJS(audit_exports);
+
+// 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 = (words) => new RegExp(`\\b(?:${[...words].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/color/oklch.ts
+var clamp01 = (n) => n < 0 ? 0 : n > 1 ? 1 : n;
+function srgbToLinear(c) {
+  return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+function parseHex(hex) {
+  const raw = hex.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)}`);
+  }
+  return {
+    r: parseInt(expanded.slice(0, 2), 16) / 255,
+    g: parseInt(expanded.slice(2, 4), 16) / 255,
+    b: parseInt(expanded.slice(4, 6), 16) / 255
+  };
+}
+function formatHex({ r, g, b }) {
+  const byte = (n) => Math.round(clamp01(n) * 255).toString(16).padStart(2, "0");
+  return `#${byte(r)}${byte(g)}${byte(b)}`;
+}
+function linearRgbToOklab(r, g, b) {
+  const l = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b;
+  const m = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b;
+  const s = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b;
+  const l_ = Math.cbrt(l);
+  const m_ = Math.cbrt(m);
+  const s_ = Math.cbrt(s);
+  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_
+  ];
+}
+var RAD = 180 / Math.PI;
+function hexToOklch(hex) {
+  const { r, g, b } = parseHex(hex);
+  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;
+  return { l: L, c, h };
+}
+
+// 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 hex = raw.slice(1);
+      const alpha2 = hex.length === 8 ? parseInt(hex.slice(6), 16) / 255 : hex.length === 4 ? parseInt(hex[3] + hex[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
+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;
+}
+
+// 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 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;
+}
+
+// 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)
+  };
+}
+
+// src/audit/collect.ts
+function collectInPage() {
+  const vw = window.innerWidth;
+  const vh = window.innerHeight;
+  const scrollY = window.scrollY;
+  const LIMIT = 8e3;
+  const all = Array.from(document.body.querySelectorAll("*")).slice(0, LIMIT);
+  const styles = /* @__PURE__ */ new Map();
+  const style = (el) => {
+    let cs = styles.get(el);
+    if (!cs) styles.set(el, cs = getComputedStyle(el));
+    return cs;
+  };
+  const box = (el) => {
+    const r = el.getBoundingClientRect();
+    return { top: r.top + scrollY, left: r.left, width: r.width, height: r.height };
+  };
+  const shown = (el) => {
+    const cs = style(el);
+    if (cs.display === "none" || cs.visibility === "hidden") return false;
+    const r = el.getBoundingClientRect();
+    return r.width > 0 && r.height > 0;
+  };
+  const alphaOf = (c) => {
+    const m = c.match(/rgba?\(([^)]+)\)/);
+    if (!m) return c === "transparent" ? 0 : 1;
+    const parts2 = m[1].split(/[\s,/]+/).filter(Boolean);
+    return parts2.length >= 4 ? parseFloat(parts2[3]) : 1;
+  };
+  const painted = (c) => Boolean(c) && alphaOf(c) > 0.02;
+  const ownText = (el) => Array.from(el.childNodes).filter((n) => n.nodeType === 3).map((n) => n.nodeValue ?? "").join("").replace(/\s+/g, " ").trim();
+  const firstFamily = (stack) => (stack.split(",")[0] ?? "").replace(/["']/g, "").trim();
+  const px = (v) => parseFloat(v) || 0;
+  const bg = /* @__PURE__ */ new Map();
+  const text = /* @__PURE__ */ new Map();
+  const fonts = /* @__PURE__ */ new Map();
+  const sizes = /* @__PURE__ */ new Set();
+  const weights = /* @__PURE__ */ new Set();
+  const radii = /* @__PURE__ */ new Set();
+  const shadows = /* @__PURE__ */ new Set();
+  const spacing = [];
+  const pageArea = Math.max(1, document.documentElement.scrollHeight * vw);
+  for (const el of all) {
+    if (!shown(el)) continue;
+    const cs = style(el);
+    const b = box(el);
+    const area = Math.min(b.width * b.height, pageArea);
+    if (painted(cs.backgroundColor)) {
+      const e = bg.get(cs.backgroundColor) ?? { area: 0, chars: 0 };
+      e.area += area;
+      bg.set(cs.backgroundColor, e);
+    }
+    const own = ownText(el);
+    if (own.length > 1) {
+      const chars = own.length;
+      const t = text.get(cs.color) ?? { area: 0, chars: 0 };
+      t.chars += chars;
+      text.set(cs.color, t);
+      const family = firstFamily(cs.fontFamily);
+      const f3 = fonts.get(family) ?? { chars: 0, displayChars: 0, italicChars: 0, weights: /* @__PURE__ */ new Set() };
+      const size = px(cs.fontSize);
+      const weight = parseInt(cs.fontWeight, 10) || 400;
+      f3.chars += chars;
+      if (/^H[1-3]$/.test(el.tagName) || size >= 28) f3.displayChars += chars;
+      if (cs.fontStyle === "italic" || cs.fontStyle.startsWith("oblique")) f3.italicChars += chars;
+      f3.weights.add(weight);
+      fonts.set(family, f3);
+      sizes.add(Math.round(size));
+      weights.add(weight);
+    }
+    if (/^(A|BUTTON|SECTION|ARTICLE|ASIDE)$/.test(el.tagName) || /card|panel|box|tile/i.test(typeof el.className === "string" ? el.className : "")) {
+      if (cs.borderRadius && cs.borderRadius !== "0px") radii.add(cs.borderRadius);
+      if (cs.boxShadow && cs.boxShadow !== "none") shadows.add(cs.boxShadow);
+    }
+    for (const prop of ["marginTop", "marginBottom", "paddingTop", "paddingBottom"]) {
+      const v = Math.round(px(cs[prop]));
+      if (v > 0 && v <= 200) spacing.push(v);
+    }
+  }
+  const htmlBg = getComputedStyle(document.documentElement).backgroundColor;
+  const bodyBg = getComputedStyle(document.body).backgroundColor;
+  const ground = painted(bodyBg) ? bodyBg : painted(htmlBg) ? htmlBg : "rgb(255, 255, 255)";
+  const headings = Array.from(document.querySelectorAll("h1, h2, h3")).filter(shown).slice(0, 60).map((h) => {
+    const cs = style(h);
+    const italic = cs.fontStyle !== "normal";
+    const italicPart = !italic && Array.from(h.querySelectorAll("*")).some((c) => style(c).fontStyle !== "normal" && (c.textContent ?? "").trim().length > 0);
+    return {
+      level: Number(h.tagName[1]),
+      family: firstFamily(cs.fontFamily),
+      sizePx: Math.round(px(cs.fontSize)),
+      weight: parseInt(cs.fontWeight, 10) || 400,
+      italic,
+      italicPart,
+      text: (h.textContent ?? "").replace(/\s+/g, " ").trim().slice(0, 120),
+      top: Math.round(box(h).top)
+    };
+  });
+  const controls = [];
+  for (const el of all) {
+    const tag = el.tagName;
+    const isButton = tag === "BUTTON" || tag === "INPUT" && /^(submit|button)$/i.test(el.type);
+    if (!isButton && tag !== "A") continue;
+    if (!shown(el)) continue;
+    const cs = style(el);
+    const b = box(el);
+    const label = (el.textContent ?? el.value ?? "").replace(/\s+/g, " ").trim();
+    if (!label || b.height < 24 || b.height > 90) continue;
+    if (!isButton && !(painted(cs.backgroundColor) || px(cs.borderTopWidth) >= 1)) continue;
+    if (!isButton && px(cs.paddingLeft) < 8) continue;
+    const r = cs.borderTopLeftRadius;
+    const radius = r.endsWith("%") ? parseFloat(r) / 100 * b.height : px(r);
+    controls.push({
+      kind: isButton ? "button" : "link",
+      radiusPx: Math.round(radius),
+      heightPx: Math.round(b.height),
+      background: cs.backgroundColor,
+      text: label.slice(0, 60)
+    });
+    if (controls.length >= 200) break;
+  }
+  const anims = [];
+  const docAny = document;
+  for (const a of docAny.getAnimations ? docAny.getAnimations() : []) {
+    const effect = a.effect;
+    if (!effect) continue;
+    let translateX = false;
+    try {
+      translateX = effect.getKeyframes().some((k) => /translate(?:X|3d)?\(\s*-?[\d.]+(?:%|px)/.test(String(k.transform ?? "")) && !/translateY/.test(String(k.transform ?? "")));
+    } catch {
+      translateX = false;
+    }
+    anims.push({ target: effect.target, infinite: effect.getTiming().iterations === Infinity, translateX });
+  }
+  const marqueeTargets = anims.filter((a) => a.infinite && a.translateX && a.target).map((a) => a.target);
+  const root = document.querySelector("main") ?? document.body;
+  const blocks = [];
+  const pushBlocks = (parent, depth) => {
+    for (const child of Array.from(parent.children)) {
+      if (!shown(child) && !(style(child).opacity === "0")) continue;
+      const b = box(child);
+      if (b.height < 80 || b.width < vw * 0.5) continue;
+      const kids = Array.from(child.children).filter((k) => box(k).height >= 80 && box(k).width >= vw * 0.5);
+      const covered = kids.reduce((n, k) => n + box(k).height, 0);
+      const wrapper = depth < 6 && !/^(SECTION|ARTICLE|HEADER|FOOTER|ASIDE|NAV)$/.test(child.tagName) && (kids.length === 1 && box(kids[0]).height >= b.height * 0.8 || kids.length >= 2 && covered >= b.height * 0.6);
+      if (wrapper) pushBlocks(child, depth + 1);
+      else blocks.push(child);
+    }
+  };
+  pushBlocks(root, 0);
+  const header = document.querySelector("body > header, header");
+  const h1 = document.querySelector("h1");
+  const hiddenAtLoad = (el) => {
+    const check = [el, ...Array.from(el.children).slice(0, 6)];
+    return check.some((c) => {
+      const cs = style(c);
+      const op = parseFloat(cs.opacity);
+      return op < 0.1 || op < 1 && cs.transform !== "none" || c.hasAttribute("data-aos") || /\breveal\b|\bfade-?(?:in|up)\b|\banimate-on-scroll\b/i.test(typeof c.className === "string" ? c.className : "");
+    });
+  };
+  const cardsIn = (section) => {
+    let best = { cards: 0, iconCards: 0 };
+    const containers = [section, ...Array.from(section.querySelectorAll("div, ul, ol"))].slice(0, 300);
+    for (const c of containers) {
+      const kids = Array.from(c.children).filter(shown);
+      if (kids.length < 3) continue;
+      const boxes = kids.map(box);
+      const row = boxes.filter((b) => Math.abs(b.top - boxes[0].top) < 12);
+      if (row.length < 3) continue;
+      const w = row.map((b) => b.width);
+      if (Math.max(...w) > Math.min(...w) * 1.35 || Math.max(...w) > vw * 0.45) continue;
+      const withText = kids.filter((k) => (k.textContent ?? "").trim().length > 12);
+      if (withText.length < 3) continue;
+      const iconCards = withText.filter((k) => {
+        const first = k.querySelector("svg, img");
+        if (!first) return false;
+        const fb = box(first);
+        const kb = box(k);
+        return fb.width <= 72 && fb.height <= 72 && fb.top - kb.top < 120;
+      }).length;
+      if (withText.length > best.cards) best = { cards: withText.length, iconCards };
+    }
+    return best;
+  };
+  const sections = blocks.slice(0, 40).map((el, index) => {
+    const b = box(el);
+    const heading = el.querySelector("h1, h2, h3");
+    const label = (heading?.textContent ?? el.textContent ?? "").replace(/\s+/g, " ").trim().slice(0, 60);
+    const images = Array.from(el.querySelectorAll("img, svg")).filter((i) => shown(i) && box(i).height <= 90);
+    const textChars = (el.textContent ?? "").replace(/\s+/g, "").length;
+    const numbers = Array.from(el.querySelectorAll("*")).filter((n) => /^[£$€]?\d[\d,.]*\s?(?:[%+kKmM★]|\/5|\+)?$/.test(ownText(n)) && px(style(n).fontSize) >= 24).length;
+    const { cards, iconCards } = cardsIn(el);
+    let kind = "text";
+    if (marqueeTargets.some((t) => el.contains(t))) kind = "marquee";
+    else if (h1 && el.contains(h1) || index === 0 && b.top < vh) kind = "hero";
+    else if (images.length >= 4 && textChars < 300) kind = "logos";
+    else if (numbers >= 3 && textChars < 600) kind = "stats";
+    else if (cards >= 3) kind = "cards";
+    return {
+      top: Math.round(b.top),
+      height: Math.round(b.height),
+      kind,
+      label,
+      cards,
+      iconCards,
+      hiddenAtLoad: b.top > vh && hiddenAtLoad(el)
+    };
+  });
+  if (header && sections.length === 0) {
+    const b = box(header);
+    sections.push({ top: Math.round(b.top), height: Math.round(b.height), kind: "hero", label: "", cards: 0, iconCards: 0, hiddenAtLoad: false });
+  }
+  const colourStops = (image) => image.match(/rgba?\([^)]*\)|#[0-9a-f]{3,8}\b/gi) ?? [];
+  const effects = {
+    glass: 0,
+    gradientText: 0,
+    gradients: [],
+    glows: 0,
+    gridBackgrounds: 0,
+    marquees: new Set(marqueeTargets).size,
+    hairlineShadowCards: 0,
+    eyebrowChip: false
+  };
+  for (const el of all) {
+    if (!shown(el)) continue;
+    const cs = style(el);
+    const b = box(el);
+    const area = b.width * b.height;
+    const backdrop = cs.backdropFilter || cs.webkitBackdropFilter || "";
+    if (/blur\(\s*[1-9]/.test(backdrop) && alphaOf(cs.backgroundColor) < 0.95 && b.width >= 200 && b.height >= 120 && cs.position !== "fixed" && cs.position !== "sticky" && !el.closest("header, nav, [role=dialog], dialog")) {
+      effects.glass += 1;
+    }
+    const image = cs.backgroundImage || "";
+    const clip = cs.backgroundClip || cs.webkitBackgroundClip || "";
+    if (clip === "text" && /gradient/.test(image)) effects.gradientText += 1;
+    if (/gradient/.test(image)) {
+      const size = cs.backgroundSize || "";
+      const small = /(?:^|\s)(?:[1-9]|[1-5]\d|6[0-4])px/.test(size);
+      const lines = (image.match(/linear-gradient/g) ?? []).length;
+      if (small && (lines >= 2 || /radial-gradient/.test(image)) || /repeating-linear-gradient/.test(image)) {
+        effects.gridBackgrounds += 1;
+      } else if (area >= vw * vh * 0.05) {
+        effects.gradients.push({ stops: colourStops(image), area: Math.round(area), radial: /radial-gradient/.test(image) });
+      }
+    }
+    const blur = (cs.filter || "").match(/blur\(\s*([\d.]+)px/);
+    if ((blur && parseFloat(blur[1]) >= 40 || /radial-gradient/.test(image) && !/(?:^|\s)\d{1,2}px/.test(cs.backgroundSize || "")) && area >= 4e4 && (el.textContent ?? "").trim().length === 0) {
+      effects.glows += 1;
+    }
+    const shadow = cs.boxShadow || "";
+    const shadowBlur = shadow.match(/(?:-?[\d.]+px\s+){2}([\d.]+)px/);
+    if (shadowBlur && parseFloat(shadowBlur[1]) >= 24 && px(cs.borderTopWidth) >= 1 && alphaOf(cs.borderTopColor) <= 0.2 && area >= 2e4) {
+      effects.hairlineShadowCards += 1;
+    }
+  }
+  if (h1) {
+    let prev = h1.previousElementSibling;
+    if (!prev && h1.parentElement) prev = h1.parentElement.previousElementSibling;
+    if (prev && shown(prev)) {
+      const cs = style(prev);
+      const b = box(prev);
+      const pill = b.height <= 44 && px(cs.borderTopLeftRadius) >= b.height / 2 - 1;
+      const drawn = painted(cs.backgroundColor) || px(cs.borderTopWidth) >= 1;
+      const chip = pill && drawn ? prev : Array.from(prev.querySelectorAll("*")).find((c) => {
+        const ccs = style(c);
+        const cb = box(c);
+        return cb.height <= 44 && px(ccs.borderTopLeftRadius) >= cb.height / 2 - 1 && (painted(ccs.backgroundColor) || px(ccs.borderTopWidth) >= 1);
+      });
+      effects.eyebrowChip = Boolean(chip && (chip.textContent ?? "").trim().length > 0 && (chip.textContent ?? "").trim().length <= 48);
+    }
+  }
+  const onScale = spacing.filter((v) => v % 4 === 0).length;
+  let bodyLineLengthCh = null;
+  let bodyFontSizePx = null;
+  const para = Array.from(document.querySelectorAll("p")).find((p) => shown(p) && (p.innerText || "").trim().split(/\s+/).length > 20);
+  if (para) {
+    const cs = style(para);
+    bodyFontSizePx = Math.round(px(cs.fontSize));
+    const probe = document.createElement("span");
+    probe.style.cssText = `font:${cs.font};visibility:hidden;position:absolute;white-space:pre`;
+    probe.textContent = "abcdefghijklmnopqrstuvwxyz";
+    document.body.appendChild(probe);
+    const avg = probe.getBoundingClientRect().width / 26;
+    probe.remove();
+    const width = para.getBoundingClientRect().width - px(cs.paddingLeft) - px(cs.paddingRight);
+    if (avg > 0 && width > 0) bodyLineLengthCh = Math.round(width / avg);
+  }
+  const toList = (m) => Array.from(m, ([value, v]) => ({ value, area: Math.round(v.area), chars: v.chars })).sort((a, b) => b.area - a.area || b.chars - a.chars);
+  const nums = (s) => Array.from(s).sort((a, b) => a - b);
+  return {
+    viewport: { width: vw, height: vh },
+    pageHeight: document.documentElement.scrollHeight,
+    ground,
+    colours: { backgrounds: toList(bg).slice(0, 60), text: toList(text).sort((a, b) => b.chars - a.chars).slice(0, 40) },
+    fonts: Array.from(fonts, ([family, f3]) => ({ family, chars: f3.chars, displayChars: f3.displayChars, italicChars: f3.italicChars, weights: nums(f3.weights) })).sort((a, b) => b.chars - a.chars),
+    headings,
+    controls,
+    sections,
+    effects,
+    motion: {
+      hiddenSections: sections.filter((s) => s.hiddenAtLoad).length,
+      sections: sections.length,
+      animations: anims.length
+    },
+    metrics: {
+      fontSizes: nums(sizes),
+      fontWeights: nums(weights),
+      radii: Array.from(radii).sort(),
+      shadows: Array.from(shadows).sort().slice(0, 20),
+      spacingOnScalePct: spacing.length ? Math.round(onScale / spacing.length * 1e3) / 10 : null,
+      bodyLineLengthCh,
+      bodyFontSizePx
+    }
+  };
+}
+function overlayInPage() {
+  const vw = window.innerWidth;
+  const vh = window.innerHeight;
+  for (const el of Array.from(document.body.querySelectorAll("*")).slice(0, 4e3)) {
+    const cs = getComputedStyle(el);
+    if (cs.position !== "fixed" && cs.position !== "absolute") continue;
+    if (cs.display === "none" || cs.visibility === "hidden" || parseFloat(cs.opacity) < 0.5) continue;
+    const r = el.getBoundingClientRect();
+    if (r.width < vw * 0.9 || r.height < vh * 0.9 || r.top > 10) continue;
+    const bg = cs.backgroundColor;
+    const alpha = /rgba?\(([^)]+)\)/.test(bg) ? parseFloat((bg.match(/[\d.]+/g) ?? [])[3] ?? "1") : 0;
+    if (alpha > 0.8 || /gradient|url\(/.test(cs.backgroundImage)) return true;
+  }
+  return false;
+}
+
+// src/audit/index.ts
+async function loadPlaywright() {
+  for (const name of ["playwright", "playwright-core"]) {
+    try {
+      return await import(
+        /* @vite-ignore */
+        name
+      );
+    } catch {
+    }
+  }
+  throw new Error("craft audit needs a browser. Install one: npm i -D playwright && npx playwright install chromium");
+}
+async function snapshotPage(page, url, options = {}) {
+  const early = await page.evaluate(overlayInPage).catch(() => false);
+  await page.waitForTimeout(options.introWindowMs ?? 5e3);
+  const late = await page.evaluate(overlayInPage).catch(() => false);
+  const data = await page.evaluate(collectInPage);
+  return {
+    version: SNAPSHOT_VERSION,
+    url,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...data,
+    motion: { ...data.motion, introOverlay: early && !late }
+  };
+}
+async function snapshotUrl(url, options = {}) {
+  const pw = await loadPlaywright();
+  const env = globalThis.process?.env ?? {};
+  const executablePath = options.executablePath ?? env.CRAFT_CHROMIUM ?? void 0;
+  const host = new URL(url).hostname;
+  const noProxy = [`localhost`, `127.0.0.1`, `::1`, ...(env.NO_PROXY ?? env.no_proxy ?? "").split(",")].map((h) => h.trim().replace(/^\*?\./, "")).filter(Boolean);
+  const direct = /^(?:localhost|127\.|\[?::1\]?$)/.test(host) || noProxy.some((h) => host === h || host.endsWith(`.${h}`));
+  const proxy = direct ? void 0 : env.HTTPS_PROXY ?? env.https_proxy;
+  const browser = await pw.chromium.launch({ headless: true, ...executablePath ? { executablePath } : {}, ...proxy ? { proxy: { server: proxy } } : {} });
+  try {
+    const page = await browser.newPage({ viewport: options.viewport ?? { width: 1440, height: 900 } });
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: options.timeoutMs ?? 45e3 });
+    return await snapshotPage(page, url, options);
+  } finally {
+    await browser.close();
+  }
+}
+async function audit(url, options = {}) {
+  const snapshot = await snapshotUrl(url, options);
+  return { snapshot, report: auditSnapshot(snapshot, options), fingerprint: fingerprint(snapshot) };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  audit,
+  collectInPage,
+  loadPlaywright,
+  overlayInPage,
+  snapshotPage,
+  snapshotUrl
+});