@designesy/score 0.5.1 → 0.7.0

package/dist/engine.js

@@ -1,10 +1,10 @@
 /**
- * @designesy/score — 42-check design-contract scoring engine.
+ * @designesy/score — 44-check design-contract scoring engine.
  *
  * Scores a URL against the Designesy design-system contract: fetches the page,
- * extracts CSS + :root tokens, runs 40 deterministic checks, computes a weighted
- * score (0-100), assigns a letter grade (A-F), and applies anti-slop deductions
- * + originality lifts.
+ * extracts CSS + :root tokens, runs 44 checks (41 scored, 3 that need a
+ * browser), computes a weighted score (0-100), assigns a letter grade (A-F),
+ * and applies anti-slop deductions + originality lifts.
  *
  * Zero dependencies. Uses node:https (not fetch/undici) to avoid the Windows
  * libuv crash during process exit.
@@ -24,7 +24,11 @@ const TIER2_ABSENCE_PATTERNS = [
     { id: 'v08', absenceMatch: /^missing:/ },
     { id: 'v10', absenceMatch: /^missing:/ },
     { id: 'v13', absenceMatch: /^no press-scale|only scale\(0\)|no press-scale \(scale/ },
+    // v14 and v18 are Designesy Cadence taste; Tier 1 until engine 1.1.0. See the
+    // notes on the same entries in apps/site/app/api/score/route.ts.
+    { id: 'v14', absenceMatch: /^missing:/ },
     { id: 'v15', absenceMatch: /missing complete font-smoothing/ },
+    { id: 'v18', absenceMatch: /^balance=(?:true|false) pretty=(?:true|false)$/ },
     { id: 'v19', absenceMatch: /^only \d+ instances/ },
     { id: 'v20', absenceMatch: /^no ::selection rule found/ },
     { id: 'v23', absenceMatch: /^only \d+\/5 duration tokens|no.*duration tokens/i },
@@ -464,10 +468,12 @@ const REMEDIATION = {
     v29: 'Structure design tokens in layers: primitive (raw values like --color-blue-500: #3b82f6), semantic (aliases like --color-accent: var(--color-blue-500)), and component (references like --button-bg: var(--color-accent)). At minimum, alias some tokens via var() so a color change propagates through the system. Full 3-tier architecture is DSAF A1.1 maturity level.',
     v42: 'Name your color tokens by ROLE, not by hue. The contract names colors by what they mean: --ink (text), --paper (background), --surface (panels), --muted (secondary text), --signal (brand accent), --ok/--warn/--error (status). Hue names like --blue-500 or --slate-900 describe wavelength, not usage: when the brand palette shifts or dark mode lands, every hue-named reference must be hunted down and rewritten. Keep hue primitives in a separate tier and alias them to role tokens via var().',
     v43: 'Express UI states as semantic color roles: --ok/--success (verification pass), --warn/--warning (caution), --error/--danger (failure), --info (notice). The contract ships --ok, --warn, and --error for exactly this. Status colors named by state let components consume meaning (a score badge, a form error, and a toast all read the same token) and stay legible when the palette evolves.',
+    v44: 'Give each status hue a text token for words and keep the hue itself for marks. A color that marks a state (a dot, a bar, a tint) needs 3:1, while the word for that state needs 4.5:1 (3:1 at 24px, or 18.66px bold) in every theme the site declares. Mix the hue toward your ink for text, for example --warn-ink: color-mix(in oklab, var(--warn) 70%, var(--ink)), measure it on the page and on each surface it sits on in every theme, and paint status words with it.',
+    v45: 'Let every entrance that starts invisible run to its end when motion is paused. Under the pause rule, give one-shot entrances whose first keyframe is opacity 0 a negative delay longer than the animation, for example html[data-motion="paused"] :is(.fade-up, .reveal) { animation-delay: -3600s !important; }, or remove them with animation: none. Loops can stay held. Test by pausing motion and reloading: every page should still show its content.',
     v34: 'EU AI Act Article 50(1) requires AI chatbots/agents to disclose their AI nature at the first interaction, accessible to people with disabilities (effective 2026-08-02). Fix options (any one): (1) add visible "AI Assistant" or "Chatbot" text in the chatbot UI header, (2) add aria-label="AI assistant" to the chatbot container, (3) add <meta name="generator" content="AI-powered"> to the page head, (4) add C2PA Content Credentials to AI-generated images, (5) add a persistent AI-disclosure badge in footer/header. US parallels: California AB 2659, Colorado AI Act (Feb 2026).',
     v35: 'Add a forced-colors readiness block: @media (forced-colors: active) { ... } with forced-color-adjust: none on elements that must preserve brand identity (logos, charts, semantic-color indicators). Windows High Contrast Mode and Chrome forced-colors recolor the page: without this media query, critical UI becomes illegible. Also ensure borders/outlines use currentColor or system colors so they adapt. Test with Windows HCM (Settings > Accessibility > Contrast themes).',
     v36: 'Remove UTS #39 confusable characters from CSS identifiers and token names. Confusables are Unicode characters from different scripts (Cyrillic, Greek, fullwidth) that look identical to ASCII letters; Cyrillic а (U+0430), for example, looks like Latin a (U+0061). In token names they enable shadowing attacks (--соlor-bg with Cyrillic с vs --color-bg). Audit all custom property names, class names, and url() paths for non-ASCII characters using a Unicode confusable detector. Provenance: Unicode Technical Standard #39, Unicode 16.0.0. Designesy is the only design verification engine that checks this surface.',
-    v37: 'Publish a DESIGN.md file at /DESIGN.md in your repo root and serve it publicly. Google\'s @google/design.md CLI (v0.4.0, Apache-2.0) validates the file format: 11 lint rules covering broken token refs, missing primary colors, WCAG contrast, orphaned tokens, section order, and more. Designesy integrates Google\'s linter as the spec layer and runs its own 42-check contract verification as the layer above. Install the CLI: npm install -g @google/design.md. Lint locally: npx @google/design.md lint DESIGN.md. Export to W3C DTCG: npx @google/design.md export --format dtcg DESIGN.md. Note: DESIGN.md uses sRGB hex only; for OKLCH/Display P3 color spaces, use the W3C DTCG JSON format directly.',
+    v37: 'Publish a DESIGN.md file at /DESIGN.md in your repo root and serve it publicly. Google\'s @google/design.md CLI (v0.4.0, Apache-2.0) validates the file format: 11 lint rules covering broken token refs, missing primary colors, WCAG contrast, orphaned tokens, section order, and more. Designesy integrates Google\'s linter as the spec layer and runs its own 44-check contract verification as the layer above. Install the CLI: npm install -g @google/design.md. Lint locally: npx @google/design.md lint DESIGN.md. Export to W3C DTCG: npx @google/design.md export --format dtcg DESIGN.md. Note: DESIGN.md uses sRGB hex only; for OKLCH/Display P3 color spaces, use the W3C DTCG JSON format directly.',
     v38: 'Rewrite button labels to start with a verb or recognized command. NN/g: "Lead with verbs or verb phrases that clearly outline what will happen after the command is selected." Use "Save changes" not "Changes", "Delete file" not "File". Recognized commands: Save, Cancel, Delete, Edit, Share, Close, Back, Next, etc. This is a WARN (heuristic): review flagged buttons manually.',
     v39: 'Remove trailing periods from button text, labels, and tab text. Microsoft Fluent: "Don\'t end text for buttons, radio buttons, labels, or checkboxes with a period." Periods are for full sentences in tooltips, error messages, and dialog bodies only.',
     v40: 'Replace non-descriptive link text with destination-revealing text. WCAG 2.4.4 Link Purpose: link text should describe the destination. Use "Read the typography guide" not "Click here". Use "View the leaderboard" not "Learn more". NN/g: non-descriptive links force users to read surrounding context to understand the destination.',
@@ -637,6 +643,43 @@ function checkTabularNums(css) {
         return { id: 'v19', item: 'tabular-nums: 8 instances across the live CSS', category: 'cadence', status: 'PASS', detail: `${count} instances found` };
     return { id: 'v19', item: 'tabular-nums: 8 instances across the live CSS', category: 'cadence', status: 'WARN', detail: `only ${count} instances (threshold: 8)` };
 }
+/**
+ * v05 helper: does a `prefers-reduced-motion: no-preference` block opt INTO
+ * motion?
+ *
+ * Gating motion behind `no-preference` is a recommended way to honour reduced
+ * motion: the motion exists only for users who have not asked for less, so a
+ * `reduce` preference receives none of it. The block counts when it declares an
+ * animation, a transition, smooth scrolling or a view transition.
+ *
+ * A block that only switches motion off (`animation: none`, durations of 10ms or
+ * less) is the `reduce` kill switch filed under the wrong query. It stills motion
+ * for users with no preference and leaves it running for users who asked for
+ * less, which inverts the preference, so it does not count. The calibration
+ * fixture broken-reduced-motion-inverted pins that case.
+ */
+function optsIntoMotion(body) {
+    if (/@view-transition\s*\{[^}]*navigation\s*:\s*auto/i.test(body))
+        return true;
+    const declRe = /(?:^|[{;\s])(animation|animation-name|animation-duration|transition|transition-property|transition-duration|scroll-behavior|view-transition-name)\s*:\s*([^;{}]+)/gi;
+    let m;
+    while ((m = declRe.exec(body)) !== null) {
+        const prop = m[1].toLowerCase();
+        const value = m[2].replace(/!important/i, '').trim().toLowerCase();
+        if (prop === 'scroll-behavior') {
+            if (value === 'smooth')
+                return true;
+            continue;
+        }
+        if (/^(?:none|initial|unset|revert|revert-layer|0|0s|0ms)$/.test(value))
+            continue;
+        const times = [...value.matchAll(/(?:^|[\s,(])(\d*\.?\d+)(ms|s)\b/g)].map((t) => parseFloat(t[1]) * (t[2] === 's' ? 1000 : 1));
+        if (times.length > 0 && times.every((t) => t <= 10))
+            continue;
+        return true;
+    }
+    return false;
+}
 function checkReducedMotion(css) {
     const ITEM = 'prefers-reduced-motion disables entrance and wordmark breath';
     const CATEGORY = 'motion';
@@ -645,15 +688,19 @@ function checkReducedMotion(css) {
     // calibration corpus caught exactly that: the previous regex matched the
     // string anywhere, including inside /* */.
     const code = css.replace(/\/\*[\s\S]*?\*\//g, '');
-    // Match the media query and require the `reduce` VALUE specifically.
-    // The prior regex accepted any @media containing the feature name, so
-    // `@media (prefers-reduced-motion: NO-PREFERENCE)` — which expresses the
-    // OPPOSITE intent, opting INTO motion — passed as readily as `reduce`. That
-    // is a false PASS on the exact accessibility primitive the check exists to
-    // verify. `no-preference` is not a reduced-motion block.
+    // Match the media query and read its VALUE. Two shapes honour reduced motion:
+    //   * `reduce` with a non-empty body: motion is switched off for those users.
+    //   * `no-preference` with a body that opts INTO motion (optsIntoMotion): the
+    //     motion is opt-in, so a reduce preference never receives it.
+    // Until engine 1.1.0 only the first shape passed, and a site that gated all
+    // of its motion behind `no-preference` was WARNed for following a recommended
+    // pattern. A bare substring match on the feature name stays wrong in both
+    // directions: an empty block, or a `no-preference` block that only switches
+    // motion off, honours nothing and still WARNs.
     const mqRe = /@media[^{]*prefers-reduced-motion\s*:\s*(reduce|no-preference)\b[^{]*\{/gi;
     let match;
     let sawReduce = false;
+    let sawMotionOptIn = false;
     let sawNoPreference = false;
     while ((match = mqRe.exec(code)) !== null) {
         const value = match[1].toLowerCase();
@@ -675,6 +722,8 @@ function checkReducedMotion(css) {
         const body = close > open ? code.slice(open + 1, close).trim() : '';
         if (value === 'no-preference') {
             sawNoPreference = true;
+            if (optsIntoMotion(body))
+                sawMotionOptIn = true;
             continue;
         }
         // A `reduce` query that declares no rules reduces nothing.
@@ -684,10 +733,13 @@ function checkReducedMotion(css) {
     if (sawReduce) {
         return { id: 'v05', item: ITEM, category: CATEGORY, status: 'PASS', detail: 'prefers-reduced-motion: reduce block declares rules' };
     }
+    if (sawMotionOptIn) {
+        return { id: 'v05', item: ITEM, category: CATEGORY, status: 'PASS', detail: 'motion is opt-in: declared inside a prefers-reduced-motion: no-preference block, so a reduce preference receives none of it' };
+    }
     if (sawNoPreference) {
         return {
             id: 'v05', item: ITEM, category: CATEGORY, status: 'WARN',
-            detail: 'a prefers-reduced-motion media query exists but uses `no-preference`: that opts INTO motion rather than reducing it. Reduced-motion support requires the `reduce` value.',
+            detail: 'a prefers-reduced-motion: no-preference block exists but gates no motion: it is empty, or it only switches motion off, which stills motion for users with no preference and leaves it running for users who asked for less. Declare motion inside no-preference, or switch it off inside reduce.',
         };
     }
     return { id: 'v05', item: ITEM, category: CATEGORY, status: 'WARN', detail: 'missing prefers-reduced-motion: reduce media query' };
@@ -1022,9 +1074,33 @@ function checkFontFamilyCount(css, tokens) {
         return { id: 'v26', item: 'Font family count ≤3 (body + heading + mono)', category: 'cadence', status: 'WARN', detail: `${count} families (recommended ≤3): ${list}` };
     return { id: 'v26', item: 'Font family count ≤3 (body + heading + mono)', category: 'cadence', status: 'FAIL', detail: `${count} families, palette drift (recommended ≤3): ${list}` };
 }
+/**
+ * v27 helper: does the delivered markup carry a field iOS Safari zooms into on
+ * focus? That is a <textarea>, a <select>, or an <input> of any type except the
+ * ones that take no typed text: hidden, checkbox, radio, submit, button, reset,
+ * image, file, range and color. An <input> with no type is a text field.
+ */
+function hasZoomableField(html) {
+    const visible = html.replace(/<script[\s\S]*?<\/script>/gi, '').replace(/<style[\s\S]*?<\/style>/gi, '');
+    if (/<(?:textarea|select)\b/i.test(visible))
+        return true;
+    const inputs = visible.match(/<input\b[^>]*>/gi) || [];
+    return inputs.some((tag) => {
+        const type = /\stype\s*=\s*["']?([a-z-]+)/i.exec(tag);
+        return !type || !/^(?:hidden|checkbox|radio|submit|button|reset|image|file|range|color)$/i.test(type[1]);
+    });
+}
 // v27 — Input font-size 16px floor (iOS Safari auto-zoom prevention).
 // Scans CSS for input/textarea/select font-size below 16px (1rem).
-function checkInputFontFloor(css) {
+//
+// Since engine 1.1.0 the page's own markup decides applicability. When the CSS
+// shows neither a sub-16px input rule nor a 16px floor, a page with no field iOS
+// can zoom into (hasZoomableField) has nothing to check and reads SKIP, as v38
+// does for a page with no buttons. It used to read WARN. The CSS verdicts are
+// unchanged: a sub-16px input rule still FAILs and a declared floor still PASSes,
+// because both describe the stylesheet that fields rendered later by script
+// would also inherit.
+function checkInputFontFloor(css, html) {
     // Find input/textarea/select rules with font-size < 16px or < 1rem.
     const inputRe = /(?:input|textarea|select|\.input|\.field)[^{]*\{[^}]*font-size\s*:\s*(\d+(?:\.\d+)?)(px|rem)/gi;
     const below = [];
@@ -1044,6 +1120,8 @@ function checkInputFontFloor(css) {
             || /input\s*[,][^{]*\{[^}]*font-size\s*:\s*(?:1rem|16px|1\.0(?:\d+)?rem|[2-9]\dpx)/i.test(css);
         if (hasGlobalFloor)
             return { id: 'v27', item: 'Input font-size ≥16px (prevents iOS Safari auto-zoom)', category: 'accessibility', status: 'PASS', detail: 'input font-size floor detected' };
+        if (!hasZoomableField(html))
+            return { id: 'v27', item: 'Input font-size ≥16px (prevents iOS Safari auto-zoom)', category: 'accessibility', status: 'SKIP', detail: 'no text input, textarea or select found in HTML: nothing for the 16px floor to protect' };
         return { id: 'v27', item: 'Input font-size ≥16px (prevents iOS Safari auto-zoom)', category: 'accessibility', status: 'WARN', detail: 'no explicit input font-size ≥16px detected: iOS Safari may auto-zoom on focus' };
     }
     return { id: 'v27', item: 'Input font-size ≥16px (prevents iOS Safari auto-zoom)', category: 'accessibility', status: 'FAIL', detail: `${below.length} input(s) below 16px floor: ${below.join(', ')}` };
@@ -1232,24 +1310,1640 @@ function checkSemanticStatusRoles(tokens) {
     if (colorTokens.length === 0) {
         return { id: 'v43', item, category: 'semantic', status: 'SKIP', detail: 'no color tokens in :root' };
     }
-    const families = { ok: false, warn: false, error: false, info: false };
-    for (const [name] of colorTokens) {
-        const segments = name.toLowerCase().split(/[-_]/);
-        if (segments.some((s) => ['ok', 'success', 'pass', 'positive'].includes(s)))
-            families.ok = true;
-        if (segments.some((s) => ['warn', 'warning', 'caution'].includes(s)))
-            families.warn = true;
-        if (segments.some((s) => ['error', 'danger', 'fail', 'critical', 'negative'].includes(s)))
-            families.error = true;
-        if (segments.some((s) => ['info', 'notice', 'informational'].includes(s)))
-            families.info = true;
+    const families = { ok: false, warn: false, error: false, info: false };
+    for (const [name] of colorTokens) {
+        const segments = name.toLowerCase().split(/[-_]/);
+        if (segments.some((s) => ['ok', 'success', 'pass', 'positive'].includes(s)))
+            families.ok = true;
+        if (segments.some((s) => ['warn', 'warning', 'caution'].includes(s)))
+            families.warn = true;
+        if (segments.some((s) => ['error', 'danger', 'fail', 'critical', 'negative'].includes(s)))
+            families.error = true;
+        if (segments.some((s) => ['info', 'notice', 'informational'].includes(s)))
+            families.info = true;
+    }
+    const found = Object.entries(families).filter(([, v]) => v).map(([k]) => k);
+    const missing = Object.entries(families).filter(([, v]) => !v).map(([k]) => k);
+    if (found.length >= 3) {
+        return { id: 'v43', item, category: 'semantic', status: 'PASS', detail: `${found.length}/4 status families present (${found.join(', ')}): states expressed as semantic roles` };
+    }
+    return { id: 'v43', item, category: 'semantic', status: 'WARN', detail: `${found.length}/4 status families present${found.length ? ` (${found.join(', ')})` : ''}; missing: ${missing.join(', ')}` };
+}
+function stripCssComments(css) {
+    const out = [];
+    const n = css.length;
+    let last = 0;
+    let i = 0;
+    while (i < n) {
+        const c = css.charCodeAt(i);
+        if (c === 47 && css.charCodeAt(i + 1) === 42) {
+            out.push(css.slice(last, i), ' ');
+            const end = css.indexOf('*/', i + 2);
+            i = end < 0 ? n : end + 2;
+            last = i;
+            continue;
+        }
+        if (c === 34 || c === 39) {
+            i++;
+            while (i < n) {
+                const d = css.charCodeAt(i);
+                if (d === 92) {
+                    i += 2;
+                    continue;
+                }
+                i++;
+                if (d === c || d === 10)
+                    break;
+            }
+            continue;
+        }
+        i++;
+    }
+    out.push(css.slice(last));
+    return out.join('');
+}
+/** Split at top-level separators, outside parentheses, brackets and quotes. */
+function splitCssTopLevel(s, sep) {
+    const out = [];
+    let depth = 0;
+    let quote = '';
+    let from = 0;
+    const push = (to) => {
+        const piece = s.slice(from, to).trim();
+        if (piece)
+            out.push(piece);
+    };
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        if (quote) {
+            if (ch === '\\')
+                i++;
+            else if (ch === quote)
+                quote = '';
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        if (ch === '(' || ch === '[')
+            depth++;
+        else if ((ch === ')' || ch === ']') && depth > 0)
+            depth--;
+        else if (depth === 0 && (sep === ' ' ? ch === ' ' || ch === '\n' || ch === '\t' || ch === '\r' || ch === '\f' : ch === sep)) {
+            push(i);
+            from = i + 1;
+        }
+    }
+    push(s.length);
+    return out;
+}
+/** A selector on one line, cut to 120 characters, for a finding. */
+function shortSelector(selector) {
+    const one = selector.replace(/\s+/g, ' ').trim();
+    return one.length > 120 ? `${one.slice(0, 117)}...` : one;
+}
+// v44 and v45 read the same sheet; the second parse of the same string is
+// served from here.
+let lastCssParse = null;
+function parseCssRules(css) {
+    if (lastCssParse && lastCssParse.css === css)
+        return lastCssParse.result;
+    const result = parseCssRulesUncached(css);
+    lastCssParse = { css, result };
+    return result;
+}
+function parseCssRulesUncached(css) {
+    const src = stripCssComments(css);
+    const n = src.length;
+    const rules = [];
+    const keyframes = [];
+    const stack = [];
+    let order = 0;
+    let start = 0;
+    let paren = 0;
+    const close = (f, end) => {
+        f.parts.push(src.slice(f.segStart, end));
+        const decls = f.parts.join(' ').trim();
+        if (f.kind === 'frame' && f.kf)
+            f.kf.frames.push({ selector: f.prelude.toLowerCase(), decls });
+        else if ((f.kind === 'rule' || (f.kind === 'group' && f.selector)) && decls) {
+            rules.push({ selector: f.selector, decls, at: f.at, order: order++ });
+        }
+    };
+    let i = 0;
+    while (i < n) {
+        const c = src.charCodeAt(i);
+        if (c === 34 || c === 39) {
+            i++;
+            while (i < n) {
+                const d = src.charCodeAt(i);
+                if (d === 92) {
+                    i += 2;
+                    continue;
+                }
+                i++;
+                if (d === c || d === 10)
+                    break;
+            }
+            continue;
+        }
+        // An unquoted url(...) may hold braces and semicolons: skip it whole. A
+        // quoted one is read as a string, because its text can hold `)`
+        // (`url("data:...filter='url(%23n)'...")`).
+        if ((c === 117 || c === 85) && src.slice(i, i + 4).toLowerCase() === 'url(') {
+            let j = i + 4;
+            while (j < n && (src[j] === ' ' || src[j] === '\t' || src[j] === '\n' || src[j] === '\r'))
+                j++;
+            if (src[j] !== '"' && src[j] !== "'") {
+                const end = src.indexOf(')', j);
+                i = end < 0 ? n : end + 1;
+                continue;
+            }
+        }
+        if (c === 40) {
+            paren++;
+            i++;
+            continue;
+        }
+        if (c === 41) {
+            if (paren > 0)
+                paren--;
+            i++;
+            continue;
+        }
+        if (c === 59) {
+            if (paren === 0)
+                start = i + 1;
+            i++;
+            continue;
+        }
+        if (c === 123) {
+            paren = 0;
+            const prelude = src.slice(start, i).trim();
+            const parent = stack.length ? stack[stack.length - 1] : null;
+            if (parent)
+                parent.parts.push(src.slice(parent.segStart, start));
+            const at = parent ? parent.at : [];
+            const ctx = parent && (parent.kind === 'rule' || parent.kind === 'group') ? parent.selector : '';
+            let f;
+            if (prelude.startsWith('@')) {
+                const name = (/^@([\w-]+)/.exec(prelude)?.[1] ?? '').toLowerCase();
+                if (/keyframes$/.test(name)) {
+                    const kf = { name: prelude.slice(name.length + 1).trim().replace(/^["']|["']$/g, ''), frames: [] };
+                    keyframes.push(kf);
+                    f = { kind: 'keyframes', prelude, selector: '', at, parts: [], segStart: i + 1, kf };
+                }
+                else if (/^(media|supports|layer|container|document|-moz-document|scope|starting-style)$/.test(name)) {
+                    f = { kind: 'group', prelude, selector: ctx, at: [...at, prelude.toLowerCase()], parts: [], segStart: i + 1, kf: null };
+                }
+                else {
+                    f = { kind: 'other', prelude, selector: '', at, parts: [], segStart: i + 1, kf: null };
+                }
+            }
+            else if (parent && parent.kind === 'keyframes') {
+                f = { kind: 'frame', prelude, selector: '', at, parts: [], segStart: i + 1, kf: parent.kf };
+            }
+            else if (parent && (parent.kind === 'other' || parent.kind === 'frame')) {
+                f = { kind: 'other', prelude, selector: '', at, parts: [], segStart: i + 1, kf: null };
+            }
+            else {
+                const selector = ctx
+                    ? splitCssTopLevel(prelude, ',').map((p) => (p.includes('&') ? p.replace(/&/g, `:is(${ctx})`) : `:is(${ctx}) ${p}`)).join(', ')
+                    : prelude;
+                f = { kind: 'rule', prelude, selector, at, parts: [], segStart: i + 1, kf: null };
+            }
+            stack.push(f);
+            start = i + 1;
+            i++;
+            continue;
+        }
+        if (c === 125) {
+            paren = 0;
+            const f = stack.pop();
+            if (f) {
+                close(f, i);
+                const parent = stack.length ? stack[stack.length - 1] : null;
+                if (parent)
+                    parent.segStart = i + 1;
+            }
+            start = i + 1;
+            i++;
+            continue;
+        }
+        i++;
+    }
+    while (stack.length) {
+        const f = stack.pop();
+        if (f)
+            close(f, n);
+    }
+    return { rules, keyframes };
+}
+function parseCssDecls(decls) {
+    const out = [];
+    for (const raw of splitCssTopLevel(decls, ';')) {
+        const colon = raw.indexOf(':');
+        if (colon <= 0)
+            continue;
+        const name = raw.slice(0, colon).trim();
+        if (!/^-{0,2}[a-zA-Z_][\w-]*$/.test(name))
+            continue;
+        let value = raw.slice(colon + 1).trim();
+        const important = /!\s*important\s*$/i.test(value);
+        if (important)
+            value = value.replace(/\s*!\s*important\s*$/i, '').trim();
+        out.push({ prop: name.startsWith('--') ? name : name.toLowerCase(), value, important });
+    }
+    return out;
+}
+/** Each var(--x[, fallback]) replaced by its value in the first scope that declares it. */
+function substituteCssVars(value, scope, depth = 0) {
+    if (depth > 16)
+        return null;
+    let out = '';
+    let i = 0;
+    for (;;) {
+        const k = value.indexOf('var(', i);
+        if (k < 0)
+            return out + value.slice(i);
+        out += value.slice(i, k);
+        let d = 0;
+        let j = k + 3;
+        for (; j < value.length; j++) {
+            if (value[j] === '(')
+                d++;
+            else if (value[j] === ')' && --d === 0)
+                break;
+        }
+        if (j >= value.length)
+            return null;
+        const inner = value.slice(k + 4, j);
+        const parts = splitCssTopLevel(inner, ',');
+        const name = (parts[0] ?? '').trim();
+        const comma = inner.indexOf(',');
+        const fallback = comma < 0 ? null : inner.slice(comma + 1).trim();
+        let rep = null;
+        for (const s of scope) {
+            if (Object.prototype.hasOwnProperty.call(s, name)) {
+                rep = s[name];
+                break;
+            }
+        }
+        if (rep === null)
+            rep = fallback;
+        if (rep === null)
+            return null;
+        const sub = substituteCssVars(rep, scope, depth + 1);
+        if (sub === null)
+            return null;
+        out += sub;
+        i = j + 1;
+    }
+}
+const CSS_NAMED_COLORS = {
+    transparent: [0, 0, 0, 0], white: [255, 255, 255, 1], black: [0, 0, 0, 1],
+    red: [255, 0, 0, 1], green: [0, 128, 0, 1], blue: [0, 0, 255, 1], yellow: [255, 255, 0, 1],
+    orange: [255, 165, 0, 1], gray: [128, 128, 128, 1], grey: [128, 128, 128, 1],
+    silver: [192, 192, 192, 1], maroon: [128, 0, 0, 1], purple: [128, 0, 128, 1],
+    navy: [0, 0, 128, 1], teal: [0, 128, 128, 1], olive: [128, 128, 0, 1], lime: [0, 255, 0, 1],
+};
+function srgbToOklab(rgb) {
+    const lin = rgb.map((c) => {
+        const s = c / 255;
+        return s <= 0.04045 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+    });
+    const l = Math.cbrt(0.4122214708 * lin[0] + 0.5363325363 * lin[1] + 0.0514459929 * lin[2]);
+    const m = Math.cbrt(0.2119034982 * lin[0] + 0.6806995451 * lin[1] + 0.1073969566 * lin[2]);
+    const s = Math.cbrt(0.0883024619 * lin[0] + 0.2817188376 * lin[1] + 0.6299787005 * lin[2]);
+    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,
+    ];
+}
+/** Oklab to 0-255 sRGB, clipped per channel to the sRGB gamut. */
+function oklabToSrgb(lab) {
+    const [L, a, b] = lab;
+    const l = Math.pow(L + 0.3963377774 * a + 0.2158037573 * b, 3);
+    const m = Math.pow(L - 0.1055613458 * a - 0.0638541728 * b, 3);
+    const s = Math.pow(L - 0.0894841775 * a - 1.291485548 * b, 3);
+    const lin = [
+        4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+        -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
+        -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s,
+    ];
+    return lin.map((c) => {
+        const x = Math.min(1, Math.max(0, c));
+        const g = x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055;
+        return Math.min(1, Math.max(0, g)) * 255;
+    });
+}
+function cssNumber(token, percentScale) {
+    const t = token.trim().toLowerCase();
+    if (t === 'none')
+        return 0;
+    const m = /^([+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?)(%|deg|turn|rad|grad)?$/.exec(t);
+    if (!m)
+        return null;
+    const x = parseFloat(m[1]);
+    if (m[2] === '%')
+        return (x / 100) * percentScale;
+    if (m[2] === 'turn')
+        return x * 360;
+    if (m[2] === 'rad')
+        return (x * 180) / Math.PI;
+    if (m[2] === 'grad')
+        return x * 0.9;
+    return x;
+}
+function cssAlpha(token) {
+    if (token === undefined)
+        return 1;
+    const a = cssNumber(token, 1);
+    return a === null ? null : Math.min(1, Math.max(0, a));
+}
+/** Function arguments as [c1, c2, c3, alpha?], comma or space syntax. */
+function cssColorArgs(args) {
+    const slash = splitCssTopLevel(args, '/');
+    const head = slash[0] ?? '';
+    const channels = head.includes(',') ? splitCssTopLevel(head, ',') : splitCssTopLevel(head, ' ');
+    if (slash.length === 2)
+        channels.push(slash[1]);
+    if (slash.length > 2 || channels.length < 3 || channels.length > 4)
+        return null;
+    return channels;
+}
+function hslToRgb(h, s, l) {
+    const hh = (((h % 360) + 360) % 360) / 360;
+    const f = (n) => {
+        const k = (n + hh * 12) % 12;
+        return l - s * Math.min(l, 1 - l) * Math.max(-1, Math.min(k - 3, 9 - k, 1));
+    };
+    return [f(0) * 255, f(8) * 255, f(4) * 255];
+}
+/**
+ * A CSS colour value, vars already substituted, to [r, g, b, alpha] in 0-255
+ * sRGB. Hex, the common named colours, rgb(), hsl(), oklch(), oklab(),
+ * color(srgb), light-dark(), color-mix() in srgb, oklab or oklch (premultiplied,
+ * rounded to 8 bits as a browser paints it), and the identity form of relative
+ * colour syntax (`rgb(from X r g b / a)`). Anything else returns null: an
+ * unmeasurable colour is left out, never guessed.
+ */
+function parseCssColor(input, dark, depth = 0) {
+    if (depth > 8)
+        return null;
+    const v = input.trim().toLowerCase();
+    if (!v)
+        return null;
+    if (v[0] === '#') {
+        const hex = v.slice(1);
+        if (!/^[0-9a-f]+$/.test(hex) || ![3, 4, 6, 8].includes(hex.length))
+            return null;
+        const full = hex.length <= 4 ? hex.split('').map((c) => c + c).join('') : hex;
+        const ch = [0, 2, 4, 6].map((k) => (k < full.length ? parseInt(full.slice(k, k + 2), 16) : 255));
+        return [ch[0], ch[1], ch[2], ch[3] / 255];
+    }
+    if (CSS_NAMED_COLORS[v])
+        return [...CSS_NAMED_COLORS[v]];
+    const fn = /^([a-z-]+)\(([\s\S]*)\)$/.exec(v);
+    if (!fn)
+        return null;
+    const name = fn[1];
+    const args = fn[2].trim();
+    if (name === 'light-dark') {
+        const pair = splitCssTopLevel(args, ',');
+        return pair.length === 2 ? parseCssColor(pair[dark ? 1 : 0], dark, depth + 1) : null;
+    }
+    if (name === 'color-mix') {
+        const parts = splitCssTopLevel(args, ',');
+        if (parts.length !== 3)
+            return null;
+        const space = /^in\s+([a-z-]+)/.exec(parts[0])?.[1] ?? '';
+        if (!['srgb', 'oklab', 'oklch'].includes(space))
+            return null;
+        const side = (p) => {
+            const after = /^([\s\S]*?)\s+(\d*\.?\d+)%$/.exec(p);
+            const before = /^(\d*\.?\d+)%\s+([\s\S]*)$/.exec(p);
+            if (after)
+                return { color: after[1], pct: parseFloat(after[2]) / 100 };
+            if (before)
+                return { color: before[2], pct: parseFloat(before[1]) / 100 };
+            return { color: p, pct: null };
+        };
+        const a = side(parts[1]);
+        const b = side(parts[2]);
+        const ca = parseCssColor(a.color, dark, depth + 1);
+        const cb = parseCssColor(b.color, dark, depth + 1);
+        if (!ca || !cb)
+            return null;
+        let p1 = a.pct;
+        let p2 = b.pct;
+        if (p1 === null && p2 === null) {
+            p1 = 0.5;
+            p2 = 0.5;
+        }
+        else if (p1 === null)
+            p1 = 1 - p2;
+        else if (p2 === null)
+            p2 = 1 - p1;
+        const sum = p1 + p2;
+        if (sum <= 0)
+            return null;
+        const w1 = p1 / sum;
+        const w2 = p2 / sum;
+        const alpha = ca[3] * w1 + cb[3] * w2;
+        if (alpha <= 0)
+            return [0, 0, 0, 0];
+        let rgb;
+        if (space === 'srgb') {
+            rgb = [0, 1, 2].map((k) => (ca[k] * ca[3] * w1 + cb[k] * cb[3] * w2) / alpha);
+        }
+        else {
+            const la = srgbToOklab([ca[0], ca[1], ca[2]]);
+            const lb = srgbToOklab([cb[0], cb[1], cb[2]]);
+            let lab;
+            if (space === 'oklab') {
+                lab = [0, 1, 2].map((k) => (la[k] * ca[3] * w1 + lb[k] * cb[3] * w2) / alpha);
+            }
+            else {
+                const lch = (x) => [x[0], Math.hypot(x[1], x[2]), (Math.atan2(x[2], x[1]) * 180) / Math.PI];
+                const A = lch(la);
+                const B = lch(lb);
+                let h1 = A[2];
+                let h2 = B[2];
+                if (A[1] < 1e-4)
+                    h1 = h2;
+                if (B[1] < 1e-4)
+                    h2 = h1;
+                if (h2 - h1 > 180)
+                    h1 += 360;
+                else if (h1 - h2 > 180)
+                    h2 += 360;
+                const L = (A[0] * ca[3] * w1 + B[0] * cb[3] * w2) / alpha;
+                const C = (A[1] * ca[3] * w1 + B[1] * cb[3] * w2) / alpha;
+                const H = ((h1 * w1 + h2 * w2) * Math.PI) / 180;
+                lab = [L, C * Math.cos(H), C * Math.sin(H)];
+            }
+            rgb = oklabToSrgb(lab);
+        }
+        const mult = Math.min(1, sum);
+        return [Math.round(rgb[0]), Math.round(rgb[1]), Math.round(rgb[2]), Math.round(alpha * mult * 255) / 255];
+    }
+    const rel = /^from\s+([\s\S]+?)\s+(r\s+g\s+b|h\s+s\s+l|l\s+c\s+h|l\s+a\s+b)\s*(?:\/\s*([\s\S]+))?$/.exec(args);
+    if (rel) {
+        const base = parseCssColor(rel[1], dark, depth + 1);
+        if (!base)
+            return null;
+        const a = rel[3] === undefined ? base[3] : cssAlpha(rel[3]);
+        return a === null ? null : [base[0], base[1], base[2], a];
+    }
+    if (name === 'color') {
+        const m = /^srgb\s+([\s\S]+)$/.exec(args);
+        const ch = m ? cssColorArgs(m[1]) : null;
+        if (!ch)
+            return null;
+        const c = ch.slice(0, 3).map((t) => cssNumber(t, 1));
+        const a = cssAlpha(ch[3]);
+        if (c.some((x) => x === null) || a === null)
+            return null;
+        return [c[0] * 255, c[1] * 255, c[2] * 255, a];
+    }
+    const ch = cssColorArgs(args);
+    if (!ch)
+        return null;
+    const alpha = cssAlpha(ch[3]);
+    if (alpha === null)
+        return null;
+    if (name === 'rgb' || name === 'rgba') {
+        const c = ch.slice(0, 3).map((t) => cssNumber(t, 255));
+        if (c.some((x) => x === null))
+            return null;
+        return [...c.map((x) => Math.min(255, Math.max(0, x))), alpha];
+    }
+    if (name === 'hsl' || name === 'hsla') {
+        const h = cssNumber(ch[0], 1);
+        const s = cssNumber(ch[1].endsWith('%') ? ch[1] : `${ch[1]}%`, 1);
+        const l = cssNumber(ch[2].endsWith('%') ? ch[2] : `${ch[2]}%`, 1);
+        if (h === null || s === null || l === null)
+            return null;
+        return [...hslToRgb(h, Math.min(1, Math.max(0, s)), Math.min(1, Math.max(0, l))), alpha];
+    }
+    if (name === 'oklch' || name === 'oklab') {
+        const L = cssNumber(ch[0], 1);
+        const x = cssNumber(ch[1], 0.4);
+        const y = cssNumber(ch[2], name === 'oklch' ? 1 : 0.4);
+        if (L === null || x === null || y === null)
+            return null;
+        const lab = name === 'oklch'
+            ? [L, x * Math.cos((y * Math.PI) / 180), x * Math.sin((y * Math.PI) / 180)]
+            : [L, x, y];
+        return [...oklabToSrgb(lab), alpha];
+    }
+    return null;
+}
+/** A token value resolved to a colour in a theme scope; bare HSL channels read as hsl(). */
+function resolveThemeColor(value, scope, dark) {
+    const sub = substituteCssVars(value, scope);
+    if (sub === null)
+        return null;
+    const direct = parseCssColor(sub, dark);
+    if (direct)
+        return direct;
+    if (/^\s*-?[\d.]+(?:deg)?\s+[\d.]+%\s+[\d.]+%\s*$/.test(sub))
+        return parseCssColor(`hsl(${sub})`, dark);
+    return null;
+}
+function toHexColor(rgb) {
+    return `#${[0, 1, 2].map((k) => Math.round(rgb[k]).toString(16).padStart(2, '0')).join('')}`;
+}
+/** Name segments of a custom property: camelCase and separators split, lowercased. */
+function tokenNameSegments(name) {
+    return name.replace(/^--/, '').replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase().split(/[-_]+/).filter(Boolean);
+}
+// ── v44 Status colors used as text meet contrast in every declared theme ────
+// A colour picked to mark a state (a dot, a bar, a tint: 3:1 is enough for a
+// mark) gets reused to write the word for that state, and text needs 4.5:1.
+// Found on designesy.org itself: light --warn #b07d04 as text measured 3.51:1
+// on #fbfbfc; mixed toward the ink, color-mix(in oklab, var(--warn) 70%,
+// var(--ink)) paints #7f5e21 and measures 5.76:1.
+//
+// A status hue is a custom property named in the status vocabulary (v43's
+// families plus grade-a to grade-f), or one the stylesheet also paints as a
+// non-text mark (background, border, outline, fill, stroke) whose value has a
+// hue (Oklch chroma 0.06 or more, so white, black and greys are not hues). An
+// on-fill colour (--danger-foreground, --on-error, --x-contrast, --x-inverse)
+// is not a status hue: it is text for a filled surface the stylesheet does not
+// pair with it, and measuring it on the page would be wrong in both directions.
+// A text use is color or -webkit-text-fill-color reading a status hue
+// directly, through one alias, or at reduced alpha.
+//
+// Only a status-named colour can FAIL, and only where it resolves to a hue
+// (Oklch chroma 0.06 or more). A neutral value under a status name (white or
+// grey text for a counter or a hint on a danger button) WARNs at most: it is a
+// general text-contrast miss, not a status colour. A hue that qualifies only
+// because the sheet also paints it as a mark WARNs at most: across the
+// leaderboard cohort those were palette colours (utility classes,
+// illustrations, links) whose real surface is often an ancestor's fill the
+// static model cannot see. Disabled and
+// inactive states (:disabled, [disabled], [aria-disabled=true], .disabled) are
+// exempt, as WCAG 1.4.3 exempts inactive user interface components.
+//
+// Each text use is measured in every theme it applies to: the :root block and
+// every [data-theme]/.dark/.light block and prefers-color-scheme block, each
+// over the root. A theme named by fewer keys than a compound theme that
+// contains it ([data-color-mode=dark] inside [data-color-mode=dark]
+// [data-dark-theme=dark]) also reads that compound's tokens before the root's.
+//
+// The surface is attested, never assumed. Walking the selector from its
+// subject outward, the first rule that paints a background for that element
+// is its surface: the rule itself, another rule for the same selector, then
+// each ancestor compound (its full prefix, the prefix without its interactive
+// state, the compound alone, the compound without its state). A translucent
+// fill composites over the next surface out. With no fill in the selector, the
+// surface is the theme's page background (html/body, else
+// --paper/--bg/--background/--surface, else white or black by scheme), unless
+// an ancestor compound carries an interactive state (:hover, :active, :focus,
+// :checked, [aria-expanded], [aria-selected], [aria-pressed], [aria-current],
+// [open]): such a state usually changes a fill this reading cannot find, so
+// the pairing is unattested and WARNs at most. v44 never FAILs a pairing it
+// cannot attest.
+//
+// Text needs 4.5:1, large text (24px, or 18.66px at weight 700) 3:1. A
+// non-text use is a graphical object under WCAG 1.4.11 and needs 3:1: its
+// subject is an svg element, or a class whose role word (the last word, or a
+// leading icon- or octicon- prefix) is icon, octicon, glyph, spinner or
+// indicator, or a progress or meter bar; or the colour it reads is named for
+// one of those (--button-danger-iconColor); or the element paints its own
+// background with currentColor, so the colour is a fill measured against the
+// surface behind it.
+// Oklch chroma at or above which a colour has a hue; below it, white, black,
+// greys and near-greys are neutral.
+const V44_HUE_CHROMA = 0.06;
+const V44_STATUS_WORDS = ['ok', 'success', 'pass', 'positive', 'warn', 'warning', 'caution', 'error', 'danger', 'fail', 'negative', 'destructive', 'info'];
+const V44_ON_FILL_WORDS = ['on', 'foreground', 'contrast', 'inverse', 'inverted'];
+const V44_THEME_CLASS = /\.((?:theme-)?(?:dark|light)(?:-theme|-mode)?)(?![\w-])/gi;
+/** Theme keys a selector names: [data-theme=dark], [data-color-mode=light], .dark, .light. */
+function themeSelectorKeys(selector) {
+    const keys = [];
+    for (const m of selector.matchAll(/\[\s*([\w-]+)\s*=\s*["']?([\w-]+)["']?\s*\]/g)) {
+        if (/(?:^|-)(?:theme|color-scheme|color-mode|mode|scheme|appearance)$/i.test(m[1]))
+            keys.push(`[${m[1].toLowerCase()}=${m[2].toLowerCase()}]`);
+    }
+    for (const m of selector.matchAll(V44_THEME_CLASS))
+        keys.push(`.${m[1].toLowerCase()}`);
+    return keys;
+}
+/** A selector part with its theme attributes and classes removed. */
+function withoutThemeKeys(part) {
+    return part
+        .replace(/\[[^\]]*\]/g, (a) => (themeSelectorKeys(a).length ? '' : a))
+        .replace(V44_THEME_CLASS, '')
+        .trim();
+}
+/**
+ * The token block a selector part declares: 'root' for :root, html, :host or
+ * body; for one of those (or a bare theme selector) carrying theme attributes
+ * or classes, the theme they name together, sorted
+ * (`[data-color-mode=dark][data-dark-theme=dark]`); null for anything else.
+ */
+function tokenBlockTheme(part) {
+    const bare = part.replace(/:not\([^()]*\)/gi, '');
+    const keys = [...new Set(themeSelectorKeys(bare))].sort();
+    const rest = withoutThemeKeys(bare).replace(/\s+/g, '');
+    if (!/^(?::root|html|:host|body)?$/i.test(rest))
+        return null;
+    if (keys.length === 0)
+        return rest ? 'root' : null;
+    return keys.join('');
+}
+/** A selector with its theme keys removed (and the html/:root/body that carried them), for matching a rule to its themed override. */
+function keylessSelector(selector) {
+    return splitCssTopLevel(selector, ',')
+        .map((p) => {
+        const rest = withoutThemeKeys(p);
+        return (themeSelectorKeys(p).length ? rest.replace(/^(?:html|:root|body)(?=\s|$)/i, '') : rest).replace(/\s+/g, ' ').trim();
+    })
+        .join(',');
+}
+function v44Scheme(at) {
+    const media = at.filter((a) => a.startsWith('@media'));
+    return { media: media.length > 0, scheme: media.map((a) => /prefers-color-scheme\s*:\s*(dark|light)/.exec(a)?.[1]).find(Boolean) };
+}
+function v44Composite(fg, bg) {
+    const a = Math.round(fg[3] * 255) / 255;
+    return [Math.round(fg[0] * a + bg[0] * (1 - a)), Math.round(fg[1] * a + bg[1] * (1 - a)), Math.round(fg[2] * a + bg[2] * (1 - a)), 1];
+}
+/** The colour a background value paints: 'none' when it paints nothing, null when it cannot be read. */
+function v44BackgroundColor(value, scope, dark) {
+    if (/^(?:none|transparent|initial|inherit|unset|revert|revert-layer)$/i.test(value.trim()))
+        return 'none';
+    const layers = splitCssTopLevel(value, ',');
+    for (const tok of splitCssTopLevel(layers[layers.length - 1] ?? '', ' ')) {
+        if (/^(?:url|[a-z-]*gradient|image|image-set|element)\(/i.test(tok))
+            continue;
+        const c = resolveThemeColor(tok, scope, dark);
+        if (c)
+            return c[3] === 0 ? 'none' : c;
+    }
+    return null;
+}
+// Interactive states that usually change a fill.
+const V44_STATE = /^(?::(?:hover|active|focus|focus-visible|focus-within|checked|target)|\[(?:aria-(?:expanded|selected|pressed|current|checked)|open)(?:[~|^$*]?=[^\]]*)?\])$/i;
+const V44_NON_TEXT_TYPES = /^(?:svg|path|circle|rect|ellipse|line|polyline|polygon|use|g)$/i;
+const V44_NON_TEXT_WORDS = ['icon', 'octicon', 'glyph', 'spinner', 'indicator'];
+/** A selector part with its theme keys removed, and the html/:root/body that carried them. */
+function keylessPart(part) {
+    const rest = withoutThemeKeys(part);
+    return (themeSelectorKeys(part).length ? rest.replace(/^(?:html|:root|body)(?=\s|$)/i, '') : rest).trim();
+}
+/** A lookup key for a run of compounds: simple selectors, combinators kept. */
+function compoundsKey(comps, stateless) {
+    return comps
+        .map((c, i) => `${i === 0 ? '' : c.comb === ' ' ? ' ' : c.comb}${simpleSelectors(c.compound).filter((x) => !stateless || !V44_STATE.test(x)).join('')}`)
+        .join('');
+}
+/**
+ * Whether a selector's subject is a graphical object rather than text: every
+ * alternative's subject is an svg element, or has a class whose role word (the
+ * last word, after any CSS-module hash) is icon, octicon, glyph, spinner or
+ * indicator, or that names an icon by prefix (icon-check, octicon-x), or is a
+ * bar of a progress or meter component.
+ */
+function nonTextSubject(part) {
+    return expandIsWhere(part).every((alt) => {
+        const comps = selectorCompounds(alt);
+        const subject = simpleSelectors(comps[comps.length - 1]?.compound ?? '');
+        if (subject.some((x) => V44_NON_TEXT_TYPES.test(x)))
+            return true;
+        return subject.some((x) => {
+            if (!x.startsWith('.'))
+                return false;
+            const segs = x.slice(1).split(/[-_]+/).filter(Boolean);
+            while (segs.length > 1 && /\d/.test(segs[segs.length - 1]))
+                segs.pop();
+            const words = segs.flatMap((w) => w.replace(/([a-z])([A-Z])/g, '$1 $2').toLowerCase().split(' '));
+            const last = words[words.length - 1] ?? '';
+            return V44_NON_TEXT_WORDS.includes(last) || ((words[0] === 'icon' || words[0] === 'octicon') && words.length > 1)
+                || (last === 'bar' && words.some((w) => w === 'progress' || w === 'meter'));
+        });
+    });
+}
+function checkStatusTextContrast(css) {
+    const ID = 'v44';
+    const ITEM = 'Status colors used as text meet contrast in every declared theme';
+    const CATEGORY = 'accessibility';
+    const parsed = parseCssRules(css).rules.map((rule) => ({
+        rule,
+        decls: parseCssDecls(rule.decls),
+        tokenBlock: splitCssTopLevel(rule.selector, ',').map(tokenBlockTheme),
+    }));
+    const themes = new Map();
+    const ensure = (key, keys, media) => {
+        let t = themes.get(key);
+        if (!t) {
+            const name = key === 'root' ? '' : key;
+            // Dark by name: a *-theme attribute's value decides ([data-light-theme=dark]
+            // puts the dark theme in the light slot); else any key that says dark
+            // and none that says light. A color-scheme declaration overrides both.
+            const themeValues = keys.map((k) => /^\[[\w-]*theme=([\w-]+)\]$/.exec(k)?.[1]).filter((v) => Boolean(v));
+            const said = themeValues.length ? themeValues.join(' ') : name;
+            t = { label: key === 'root' ? ':root' : key, dark: /dark/.test(said) && !/light/.test(said), tokens: {}, keys, media };
+            themes.set(key, t);
+        }
+        return t;
+    };
+    const root = ensure('root', [], null);
+    const whereOf = (rule) => {
+        const { scheme } = v44Scheme(rule.at);
+        return { keys: splitCssTopLevel(rule.selector, ',').map((p) => themeSelectorKeys(p)), media: scheme ? `@media (prefers-color-scheme: ${scheme})` : null };
+    };
+    const reaches = (t, w) => (w.media ? t.media === w.media : t.media === null || w.keys.some((k) => k.length === 0))
+        && w.keys.some((k) => k.length === 0 || (t.keys.length > 0 && k.every((x) => t.keys.includes(x))));
+    const themed = (w) => w.media !== null || w.keys.every((k) => k.length > 0);
+    for (const { rule, decls, tokenBlock } of parsed) {
+        const { media, scheme } = v44Scheme(rule.at);
+        if (media && !scheme)
+            continue;
+        for (const t of tokenBlock) {
+            if (!t)
+                continue;
+            const mediaKey = `@media (prefers-color-scheme: ${scheme})`;
+            const theme = t === 'root'
+                ? (scheme ? ensure(mediaKey, [], mediaKey) : root)
+                : ensure(t, t.match(/\[[^\]]*\]|\.[\w-]+/g) ?? [], null);
+            if (t === 'root' && scheme)
+                theme.dark = scheme === 'dark';
+            for (const d of decls) {
+                if (d.prop.startsWith('--'))
+                    theme.tokens[d.prop] = d.value;
+                else if (d.prop === 'color-scheme') {
+                    const v = d.value.trim().toLowerCase();
+                    if (/^(?:only\s+)?dark$/.test(v))
+                        theme.dark = true;
+                    else if (/^(?:only\s+)?light$/.test(v))
+                        theme.dark = false;
+                }
+            }
+        }
+    }
+    // A theme's tokens; then those of every compound theme that contains it,
+    // because a page that matches [data-color-mode=dark] also carries the theme
+    // attribute those compounds add (primer.style declares --fgColor-danger only
+    // under [data-color-mode=dark][data-dark-theme=dark]): nearest first, and
+    // among those the one whose added keys repeat the theme's own value
+    // ([data-dark-theme=dark] for [data-color-mode=dark]), then source order;
+    // then those of every theme it includes (a [data-color-mode=dark] block
+    // also applies under [data-color-mode=dark][data-dark-theme=dark_dimmed]),
+    // most specific first; then the root's.
+    const scopeCache = new Map();
+    const scopeOf = (key) => {
+        const hit = scopeCache.get(key);
+        if (hit)
+            return hit;
+        const t = themes.get(key);
+        const others = key === 'root' || t.media ? [] : [...themes.entries()].filter(([k, o]) => k !== key && k !== 'root' && !o.media);
+        const valueOf = (k) => /=([\w-]+)\]$/.exec(k)?.[1] ?? k.replace(/^\./, '');
+        const own = new Set(t.keys.map(valueOf));
+        const repeats = (o) => o.keys.filter((x) => !t.keys.includes(x)).every((x) => own.has(valueOf(x)));
+        const narrower = others
+            .filter(([, o]) => o.keys.length > t.keys.length && t.keys.every((x) => o.keys.includes(x)))
+            .sort((a, b) => a[1].keys.length - b[1].keys.length || Number(repeats(b[1])) - Number(repeats(a[1])))
+            .map(([, o]) => o.tokens);
+        const wider = others
+            .filter(([, o]) => o.keys.length < t.keys.length && o.keys.every((x) => t.keys.includes(x)))
+            .sort((a, b) => b[1].keys.length - a[1].keys.length)
+            .map(([, o]) => o.tokens);
+        const scope = key === 'root' ? [root.tokens] : [t.tokens, ...narrower, ...wider, root.tokens];
+        scopeCache.set(key, scope);
+        return scope;
+    };
+    // 2. Status hues, and the aliases that read one.
+    const paintRefs = new Set();
+    for (const { decls } of parsed) {
+        for (const d of decls) {
+            if (/^(?:background(?:-color)?|border(?:-(?:top|right|bottom|left|block|inline)(?:-(?:start|end))?)?(?:-color)?|outline(?:-color)?|fill|stroke)$/.test(d.prop)) {
+                for (const m of d.value.matchAll(/var\(\s*(--[\w-]+)/g))
+                    paintRefs.add(m[1]);
+            }
+        }
+    }
+    // 'name': a status colour by its name. 'paint': a hue the sheet also paints
+    // as a mark. null: not a status hue.
+    const hueCache = new Map();
+    const hueKind = (name) => {
+        const hit = hueCache.get(name);
+        if (hit !== undefined)
+            return hit;
+        const segs = tokenNameSegments(name);
+        let kind = null;
+        if (!segs.some((s) => V44_ON_FILL_WORDS.includes(s))) {
+            if (segs.some((s) => V44_STATUS_WORDS.includes(s)) || /(?:^|-)grade-[a-f](?:-|$)/.test(segs.join('-')))
+                kind = 'name';
+            else if (paintRefs.has(name)) {
+                for (const [key, t] of themes) {
+                    const c = resolveThemeColor(`var(${name})`, scopeOf(key), t.dark);
+                    if (!c || c[3] <= 0)
+                        continue;
+                    const lab = srgbToOklab([c[0], c[1], c[2]]);
+                    if (Math.hypot(lab[1], lab[2]) >= V44_HUE_CHROMA)
+                        kind = 'paint';
+                    break;
+                }
+            }
+        }
+        hueCache.set(name, kind);
+        return kind;
+    };
+    const isHue = (name) => hueKind(name) !== null;
+    const huesIn = (value) => [...value.matchAll(/var\(\s*(--[\w-]+)/g)].map((m) => m[1]).filter(isHue);
+    const aliasOf = new Map();
+    const componentAlias = new Map();
+    // Selectors whose text color a themed rule replaces: keyless selector -> where.
+    const themedColor = new Map();
+    for (const { rule, decls, tokenBlock } of parsed) {
+        const where = whereOf(rule);
+        if (themed(where) && decls.some((d) => d.prop === 'color' || d.prop === '-webkit-text-fill-color')) {
+            const k = keylessSelector(rule.selector);
+            themedColor.set(k, [...(themedColor.get(k) ?? []), where]);
+        }
+        for (const d of decls) {
+            if (!d.prop.startsWith('--') || isHue(d.prop))
+                continue;
+            const hues = huesIn(d.value);
+            if (hues.length && !aliasOf.has(d.prop))
+                aliasOf.set(d.prop, hues[0]);
+            // A component-scoped alias keeps every value it takes, hue or not, so a
+            // themed rule that re-points it (to an ink mix, say) is measured too.
+            if (!tokenBlock.some(Boolean) && /var\(\s*--/.test(d.value)) {
+                const keyless = keylessSelector(rule.selector);
+                const subjects = splitCssTopLevel(keyless, ',').map((p) => {
+                    const comps = selectorCompounds(p);
+                    return simpleSelectors(comps[comps.length - 1]?.compound ?? '');
+                }).filter((x) => x.length > 0);
+                componentAlias.set(d.prop, [...(componentAlias.get(d.prop) ?? []), { value: d.value, keyless, where, subjects }]);
+            }
+        }
+    }
+    // 3. The page background of each theme: body, then html, then :root, from
+    //    the theme's own rules first and the root's rules after; then the
+    //    surface tokens; then white, or black for a dark scheme. A theme other
+    //    than the root whose background is only that assumption is not
+    //    measured: nothing in it says what surface its text sits on.
+    const pageBg = new Map();
+    const assumedBg = new Set();
+    const bgRules = [];
+    for (let r = parsed.length - 1; r >= 0; r--) {
+        const { rule, decls } = parsed[r];
+        if (!/(?:^|[\s,>(])(?:html|body|:root)\b|\[|\.(?:theme-)?(?:dark|light)/i.test(rule.selector))
+            continue;
+        const bg = [...decls].reverse().find((d) => d.prop === 'background-color' || d.prop === 'background');
+        if (!bg)
+            continue;
+        const { media, scheme } = v44Scheme(rule.at);
+        if (media && !scheme)
+            continue;
+        const parts = splitCssTopLevel(rule.selector, ',').map((p) => {
+            const keys = themeSelectorKeys(p);
+            const comps = withoutThemeKeys(p).split(/\s+/).filter(Boolean);
+            return { keys, subject: (comps[comps.length - 1] ?? (keys.length ? 'html' : '')).toLowerCase() };
+        }).filter((p) => p.subject === 'body' || p.subject === 'html' || p.subject === ':root');
+        if (parts.length)
+            bgRules.push({ parts, media: scheme ? `@media (prefers-color-scheme: ${scheme})` : null, bg });
+    }
+    for (const [key, t] of themes) {
+        const scope = scopeOf(key);
+        const plain = t.dark ? [0, 0, 0, 1] : [255, 255, 255, 1];
+        let found = null;
+        for (const pass of key === 'root' ? ['root'] : ['own', 'root']) {
+            for (const subject of ['body', 'html', ':root']) {
+                for (const cand of bgRules) {
+                    if (found)
+                        break;
+                    const hit = cand.parts.some((p) => p.subject === subject && (pass === 'own'
+                        ? (t.media ? cand.media === t.media && p.keys.length === 0 : cand.media === null && p.keys.length > 0 && p.keys.every((x) => t.keys.includes(x)))
+                        : cand.media === null && p.keys.length === 0));
+                    if (!hit)
+                        continue;
+                    const c = v44BackgroundColor(cand.bg.value, scope, t.dark);
+                    if (c && c !== 'none')
+                        found = c[3] >= 1 ? c : v44Composite(c, plain);
+                }
+                if (found)
+                    break;
+            }
+            if (found)
+                break;
+        }
+        if (!found) {
+            for (const name of ['--paper', '--bg', '--background', '--surface']) {
+                if (!scope.some((x) => Object.prototype.hasOwnProperty.call(x, name)))
+                    continue;
+                const c = resolveThemeColor(`var(${name})`, scope, t.dark);
+                if (c && c[3] > 0) {
+                    found = c[3] >= 1 ? c : v44Composite(c, plain);
+                    break;
+                }
+            }
+        }
+        // A theme whose scheme differs from the root's but whose page background
+        // is the root's did not theme its surface: measuring its text there would
+        // pair a dark palette with a light page, or the reverse.
+        const rootBg = pageBg.get('root');
+        if (key !== 'root' && (!found || (t.dark !== root.dark && rootBg && toHexColor(found) === toHexColor(rootBg))))
+            assumedBg.add(key);
+        pageBg.set(key, found ?? plain);
+    }
+    // Every background a rule paints, by selector (theme keys removed), for
+    // attesting a text use's surface. Latest rule first.
+    const bgIndex = new Map();
+    for (let r = parsed.length - 1; r >= 0; r--) {
+        const { rule, decls } = parsed[r];
+        const bg = [...decls].reverse().find((d) => d.prop === 'background-color' || d.prop === 'background');
+        if (!bg)
+            continue;
+        if (rule.at.some((a) => /^@media\b.*\b(?:print|forced-colors)\b/.test(a)))
+            continue;
+        const where = whereOf(rule);
+        for (const part of splitCssTopLevel(rule.selector, ',')) {
+            // Indexed as written: a :hover rule's fill is the hovered element's,
+            // never the resting one's. The lookup side drops a state, not this side.
+            const k = compoundsKey(selectorCompounds(keylessPart(part)), false);
+            const list = bgIndex.get(k) ?? [];
+            list.push({ where, value: bg.value });
+            bgIndex.set(k, list);
+        }
+    }
+    const findings = [];
+    const seen = new Set();
+    let uses = 0;
+    let unresolved = 0;
+    for (const { rule, decls } of parsed) {
+        const texts = decls.filter((d) => d.prop === 'color' || d.prop === '-webkit-text-fill-color');
+        if (!texts.length)
+            continue;
+        if (rule.at.some((a) => /^@media\b.*\b(?:print|forced-colors)\b/.test(a)))
+            continue;
+        const text = texts[texts.length - 1];
+        const refs = [...text.value.matchAll(/var\(\s*(--[\w-]+)/g)].map((m) => m[1]);
+        const direct = refs.find(isHue);
+        const alias = refs.find((r) => aliasOf.has(r));
+        if (!direct && !alias)
+            continue;
+        // Inactive controls carry no contrast requirement (WCAG 1.4.3). A rule is
+        // exempt when every selector in it names a disabled state; :not(:disabled)
+        // names the opposite and does not count.
+        const disabled = splitCssTopLevel(rule.selector, ',').every((p) => /:disabled\b|\[disabled\]|\[aria-disabled(?:=["']?true["']?)?\]|\.disabled(?![\w-])/i.test(p.replace(/:not\((?:[^()]|\([^()]*\))*\)/gi, '')));
+        if (disabled)
+            continue;
+        uses++;
+        const token = direct ?? `${alias} -> ${aliasOf.get(alias)}`;
+        const byName = hueKind(direct ?? aliasOf.get(alias)) === 'name';
+        const where = whereOf(rule);
+        const replacedBy = themed(where) ? [] : themedColor.get(keylessSelector(rule.selector)) ?? [];
+        const applies = [...themes.keys()].filter((k) => {
+            const t = themes.get(k);
+            return !assumedBg.has(k) && reaches(t, where) && !replacedBy.some((w) => reaches(t, w));
+        });
+        // Large text: the rule's own font-size (a clamp() reads its minimum) or
+        // the size in a font shorthand, with its weight.
+        let px = null;
+        let weight = 400;
+        for (const d of decls) {
+            if (d.prop === 'font-size' || d.prop === 'font') {
+                const v = d.value.toLowerCase();
+                const kw = /(?:^|\s)(xxx-large|xx-large|x-large)(?:\s|$)/.exec(v);
+                const m = /^clamp\(\s*([\d.]+)(px|rem|em)/.exec(v)
+                    ?? (d.prop === 'font-size' ? /^([\d.]+)(px|rem|em)$/.exec(v) : /(?:^|\s)([\d.]+)(px|rem|em)(?:\s*\/|\s|$)/.exec(v));
+                if (kw)
+                    px = kw[1] === 'xxx-large' ? 48 : kw[1] === 'xx-large' ? 32 : 24;
+                else if (m)
+                    px = parseFloat(m[1]) * (m[2] === 'px' ? 1 : 16);
+                const w = d.prop === 'font' ? /(?:^|\s)(bold|bolder|[1-9]00)(?:\s|$)/.exec(v) : null;
+                if (w)
+                    weight = /bold/.test(w[1]) ? 700 : parseInt(w[1], 10);
+            }
+            if (d.prop === 'font-weight') {
+                const w = d.value.trim().toLowerCase();
+                if (/^bold(?:er)?$/.test(w))
+                    weight = 700;
+                else if (/^\d+$/.test(w))
+                    weight = parseInt(w, 10);
+            }
+        }
+        // A colour named for a graphic (an icon colour) is not text.
+        const graphicToken = [direct, alias, alias ? aliasOf.get(alias) : undefined].some((nm) => nm && tokenNameSegments(nm).some((w) => V44_NON_TEXT_WORDS.includes(w)));
+        const need = graphicToken || (px !== null && (px >= 24 || (px >= 18.66 && weight >= 700))) ? 3 : 4.5;
+        const ownBg = [...decls].reverse().find((d) => d.prop === 'background-color' || d.prop === 'background');
+        const ownTokens = {};
+        for (const d of decls)
+            if (d.prop.startsWith('--'))
+                ownTokens[d.prop] = d.value;
+        // An alias set on a component reaches only text inside that component, so
+        // a value is a variant here only when this rule's selector names the
+        // component (`.card .label` for an alias set on `.card`). A themed rule
+        // for the same component replaces the unthemed one.
+        const compounds = splitCssTopLevel(rule.selector, ',').flatMap((p) => selectorCompounds(p).map((c) => simpleSelectors(c.compound)));
+        const variantsIn = (key) => {
+            if (direct || !alias || Object.prototype.hasOwnProperty.call(ownTokens, alias))
+                return [{}];
+            const t = themes.get(key);
+            const decl = (componentAlias.get(alias) ?? []).filter((a) => reaches(t, a.where)
+                && a.subjects.some((subject) => compounds.some((c) => compoundCovers(subject, c))));
+            const forTheme = new Set(decl.filter((a) => themed(a.where)).map((a) => a.keyless));
+            const values = decl.filter((a) => themed(a.where) || !forTheme.has(a.keyless)).map((a) => a.value);
+            return [{}, ...[...new Set(values)].map((value) => ({ [alias]: value }))];
+        };
+        const sel = shortSelector(rule.selector);
+        const parts = splitCssTopLevel(rule.selector, ',');
+        for (const key of applies) {
+            const t = themes.get(key);
+            for (const variant of variantsIn(key)) {
+                const scope = [ownTokens, variant, ...scopeOf(key)];
+                const fg = resolveThemeColor(text.value, scope, t.dark);
+                if (!fg) {
+                    unresolved++;
+                    continue;
+                }
+                if (fg[3] <= 0)
+                    continue;
+                // One fill: its color in this theme; 'stale' when, in a theme whose
+                // scheme differs from the root's, it resolves exactly as in the root
+                // (the surface did not follow the theme, so it is not measured).
+                const fill = (value) => {
+                    const c = v44BackgroundColor(value, scope, t.dark);
+                    if (c === null)
+                        return 'unreadable';
+                    if (c !== 'none' && key !== 'root' && t.dark !== root.dark) {
+                        const inRoot = v44BackgroundColor(value, [ownTokens, variant, root.tokens], root.dark);
+                        if (inRoot && inRoot !== 'none' && toHexColor(inRoot) === toHexColor(c) && inRoot[3] === c[3])
+                            return 'stale';
+                    }
+                    return c;
+                };
+                const indexed = (k) => {
+                    for (const e of bgIndex.get(k) ?? [])
+                        if (reaches(t, e.where))
+                            return e.value;
+                    return null;
+                };
+                const surfaces = parts.map((part) => {
+                    const comps = selectorCompounds(keylessPart(part));
+                    const n = comps.length - 1;
+                    let partNeed = nonTextSubject(keylessPart(part)) ? 3 : need;
+                    const layers = [];
+                    for (let k = n; k >= 0; k--) {
+                        let value = null;
+                        if (k === n && ownBg)
+                            value = ownBg.value;
+                        const prefix = comps.slice(0, k + 1);
+                        const lone = [{ comb: '', compound: comps[k].compound }];
+                        for (const cand of [compoundsKey(prefix, false), compoundsKey(prefix, true), compoundsKey(lone, false), compoundsKey(lone, true)]) {
+                            if (value !== null)
+                                break;
+                            value = indexed(cand);
+                        }
+                        if (value === null)
+                            continue;
+                        // An element that paints its own background with currentColor
+                        // (a progress bar, a dot) uses the colour as a fill: a graphic,
+                        // measured against the surface behind it.
+                        if (k === n && /^\s*currentcolor\s*$/i.test(value)) {
+                            partNeed = 3;
+                            continue;
+                        }
+                        const c = fill(value);
+                        if (c === 'stale')
+                            return { bg: null, attested: false, stale: true, need: partNeed };
+                        if (c === 'unreadable')
+                            return { bg: null, attested: true, stale: false, need: partNeed };
+                        if (c === 'none')
+                            continue;
+                        layers.push(c);
+                        if (c[3] >= 1)
+                            break;
+                    }
+                    const opaque = layers.length > 0 && layers[layers.length - 1][3] >= 1;
+                    const stateAbove = comps.slice(0, n).some((c) => simpleSelectors(c.compound).some((x) => V44_STATE.test(x)));
+                    let base = opaque ? layers.pop() : pageBg.get(key);
+                    for (let i = layers.length - 1; i >= 0; i--)
+                        base = v44Composite(layers[i], base);
+                    return { bg: base, attested: opaque || !stateAbove, stale: false, need: partNeed };
+                });
+                const solid = [Math.round(fg[0]), Math.round(fg[1]), Math.round(fg[2]), 1];
+                const fgLab = srgbToOklab([solid[0], solid[1], solid[2]]);
+                const neutral = Math.hypot(fgLab[1], fgLab[2]) < V44_HUE_CHROMA;
+                const value = toHexColor(solid) + (fg[3] < 1 ? ` at ${Math.round(fg[3] * 100)}%` : '');
+                const measured = [];
+                for (const sf of surfaces) {
+                    if (sf.stale)
+                        continue;
+                    if (!sf.bg) {
+                        measured.push({ background: 'unresolved', ratio: null, need: sf.need, status: 'WARN', note: 'its background cannot be resolved' });
+                        continue;
+                    }
+                    const bg = sf.bg;
+                    const full = contrastRatio([solid[0], solid[1], solid[2]], [bg[0], bg[1], bg[2]]);
+                    const shown = fg[3] < 1 ? v44Composite(fg, bg) : solid;
+                    const painted = contrastRatio([shown[0], shown[1], shown[2]], [bg[0], bg[1], bg[2]]);
+                    let status = full < sf.need ? 'FAIL' : painted < sf.need ? 'WARN' : 'PASS';
+                    let note = status === 'WARN' ? `clears ${sf.need}:1 only at full alpha (${full.toFixed(2)}:1)` : '';
+                    if (status === 'FAIL' && !sf.attested) {
+                        status = 'WARN';
+                        note = 'is only a warning: the surface is unresolved, because an ancestor in an interactive state (hover, active, focus, expanded, open) usually changes a fill this check cannot find';
+                    }
+                    else if (status === 'FAIL' && !byName) {
+                        status = 'WARN';
+                        note = 'is only a warning: the color is not named as a status, it counts because the stylesheet also paints it as a mark, and its real surface may be a fill this check cannot see';
+                    }
+                    else if (status === 'FAIL' && neutral) {
+                        status = 'WARN';
+                        note = 'neutral text on a status fill: a general text-contrast miss, not a status color';
+                    }
+                    // Shown to two places; a miss that would round up to the bar is
+                    // rounded down instead, so 4.497 reads 4.49, never 4.50 against 4.5.
+                    const rounded = Math.round(painted * 100) / 100;
+                    const shownRatio = painted < sf.need && rounded >= sf.need ? Math.floor(painted * 100) / 100 : rounded;
+                    measured.push({ background: toHexColor(bg), ratio: shownRatio, need: sf.need, status, note });
+                }
+                if (!measured.length) {
+                    unresolved++;
+                    continue;
+                }
+                const order = { FAIL: 0, WARN: 1, PASS: 2 };
+                measured.sort((a, b) => order[a.status] - order[b.status] || (a.ratio === null ? 0 : a.ratio / a.need) - (b.ratio === null ? 0 : b.ratio / b.need));
+                const worst = measured[0];
+                const dedupe = `${sel}|${token}|${value}|${worst.background}|${worst.need}|${worst.status}`;
+                if (seen.has(dedupe))
+                    continue;
+                seen.add(dedupe);
+                findings.push({ selector: sel, token, theme: t.label, value, ...worst });
+            }
+        }
+    }
+    if (findings.length === 0) {
+        return {
+            id: ID, item: ITEM, category: CATEGORY, status: 'SKIP',
+            detail: uses === 0
+                ? 'not applicable: no status color is used as text'
+                : `not applicable: ${uses} status-color text use(s), none resolvable to a measurable color`,
+        };
+    }
+    const rank = { FAIL: 0, WARN: 1, PASS: 2 };
+    const margin = (f) => (f.ratio === null ? 0 : f.ratio / f.need);
+    findings.sort((a, b) => rank[a.status] - rank[b.status] || margin(a) - margin(b));
+    const fails = findings.filter((f) => f.status === 'FAIL');
+    const warns = findings.filter((f) => f.status === 'WARN');
+    const status = fails.length ? 'FAIL' : warns.length ? 'WARN' : 'PASS';
+    const say = (f) => (f.ratio === null
+        ? `${f.selector} uses ${f.token} ${f.value} in ${f.theme}, and ${f.note}`
+        : `${f.selector} uses ${f.token} ${f.value} on ${f.background} in ${f.theme} at ${f.ratio.toFixed(2)}:1 (needs ${f.need}:1)${f.note ? `; ${/^(?:is|clears) /.test(f.note) ? 'this ' : ''}${f.note}` : ''}`);
+    const lead = status === 'FAIL' ? fails : warns;
+    const detail = status === 'PASS'
+        ? `${findings.length} status-color text use(s) clear contrast in ${themes.size} theme(s); the closest: ${say(findings[0])}`
+        : `${lead.length} status-color text use(s) ${status === 'FAIL' ? 'under contrast' : 'to review'}: ${lead.slice(0, 2).map(say).join(' | ')}${lead.length > 2 ? ` | ${lead.length - 2} more` : ''}`;
+    return {
+        id: ID, item: ITEM, category: CATEGORY, status, detail,
+        evidence: {
+            findings: findings.slice(0, 20).map((f) => ({ selector: f.selector, token: f.token, theme: f.theme, value: f.value, background: f.background, ratio: f.ratio, need: f.need, status: f.status, note: f.note || null })),
+            truncated: Math.max(0, findings.length - 20),
+        },
+    };
+}
+/** The compounds of one complex selector and the combinator before each. */
+function selectorCompounds(part) {
+    const out = [];
+    let depth = 0;
+    let cur = '';
+    let comb = '';
+    for (let i = 0; i < part.length; i++) {
+        const ch = part[i];
+        if (ch === '(' || ch === '[')
+            depth++;
+        else if ((ch === ')' || ch === ']') && depth > 0)
+            depth--;
+        if (depth === 0 && (ch === ' ' || ch === '\n' || ch === '\t' || ch === '>' || ch === '+' || ch === '~')) {
+            if (cur) {
+                out.push({ comb, compound: cur });
+                cur = '';
+                comb = ' ';
+            }
+            if (ch !== ' ' && ch !== '\n' && ch !== '\t')
+                comb = ch;
+            continue;
+        }
+        cur += ch;
+    }
+    if (cur)
+        out.push({ comb, compound: cur });
+    return out;
+}
+/** The simple selectors of one compound, attribute quotes and spacing normalised. */
+function simpleSelectors(compound) {
+    const out = [];
+    let depth = 0;
+    let cur = '';
+    for (let i = 0; i < compound.length; i++) {
+        const ch = compound[i];
+        if (depth === 0 && (ch === '.' || ch === '#' || ch === '[' || (ch === ':' && compound[i - 1] !== ':')) && cur) {
+            out.push(cur);
+            cur = '';
+        }
+        if (ch === '(' || ch === '[')
+            depth++;
+        else if ((ch === ')' || ch === ']') && depth > 0)
+            depth--;
+        cur += ch;
+    }
+    if (cur)
+        out.push(cur);
+    return out.map((s) => (s.startsWith('[') ? s.replace(/["'\s]/g, '').toLowerCase() : s)).filter((s) => s !== '*');
+}
+/** Specificity [ids, classes, types] of one complex selector. */
+function selectorSpecificity(part) {
+    const spec = [0, 0, 0];
+    for (const { compound } of selectorCompounds(part)) {
+        for (const s of simpleSelectors(compound)) {
+            const fn = /^:(is|not|has|matches|where|nth-child|nth-last-child)\(([\s\S]*)\)$/i.exec(s);
+            if (fn) {
+                const name = fn[1].toLowerCase();
+                if (name === 'where')
+                    continue;
+                if (name.startsWith('nth')) {
+                    spec[1]++;
+                    continue;
+                }
+                let best = [0, 0, 0];
+                for (const arg of splitCssTopLevel(fn[2], ',')) {
+                    const sp = selectorSpecificity(arg);
+                    if (sp[0] > best[0] || (sp[0] === best[0] && (sp[1] > best[1] || (sp[1] === best[1] && sp[2] > best[2]))))
+                        best = sp;
+                }
+                for (let k = 0; k < 3; k++)
+                    spec[k] += best[k];
+                continue;
+            }
+            if (s.startsWith('#'))
+                spec[0]++;
+            else if (s.startsWith('::') || /^:(?:before|after|first-line|first-letter)$/i.test(s))
+                spec[2]++;
+            else if (s.startsWith('.') || s.startsWith('[') || s.startsWith(':'))
+                spec[1]++;
+            else
+                spec[2]++;
+        }
+    }
+    return spec;
+}
+function compareSpecificity(a, b) {
+    for (let k = 0; k < 3; k++)
+        if (a[k] !== b[k])
+            return a[k] - b[k];
+    return 0;
+}
+/** One time value in ms, null when it is not a literal time. */
+function cssTimeMs(token) {
+    const m = /^(-?(?:\d+\.?\d*|\.\d+))(ms|s)$/i.exec(token.trim());
+    return m ? parseFloat(m[1]) * (m[2].toLowerCase() === 's' ? 1000 : 1) : null;
+}
+/** :is() and :where() in a selector, expanded into their alternatives (bounded). */
+function expandIsWhere(part, budget = 64) {
+    const m = /:(?:is|where|matches|-webkit-any)\(/i.exec(part);
+    if (!m)
+        return [part];
+    const open = m.index + m[0].length - 1;
+    let depth = 0;
+    let close = -1;
+    for (let i = open; i < part.length; i++) {
+        if (part[i] === '(')
+            depth++;
+        else if (part[i] === ')' && --depth === 0) {
+            close = i;
+            break;
+        }
+    }
+    if (close < 0)
+        return [part];
+    const out = [];
+    for (const alt of splitCssTopLevel(part.slice(open + 1, close), ',')) {
+        for (const x of expandIsWhere(part.slice(0, m.index) + alt + part.slice(close + 1), budget)) {
+            if (out.length >= budget)
+                return out;
+            out.push(x);
+        }
+    }
+    return out;
+}
+/** Whether every simple selector of `inner` holds for an element matching `outer` ([x] holds wherever [x=...] does). */
+function compoundCovers(inner, outer) {
+    return inner.every((s) => outer.includes(s)
+        || (/^\[[\w-]+\]$/.test(s) && outer.some((o) => o.startsWith(`${s.slice(0, -1)}=`) || o.startsWith(`${s.slice(0, -1)}~=`) || o.startsWith(`${s.slice(0, -1)}|=`))));
+}
+/**
+ * Whether selector `r` matches every element selector `e` matches: r's
+ * compounds, read from the subject outward, each hold for e's compound at the
+ * same position, joined by the same combinator (a descendant combinator in r
+ * also holds where e has a child combinator).
+ */
+function selectorCovers(r, e) {
+    const rc = selectorCompounds(r);
+    const ec = selectorCompounds(e);
+    if (!rc.length || rc.length > ec.length)
+        return false;
+    for (let k = 1; k <= rc.length; k++) {
+        const a = rc[rc.length - k];
+        const b = ec[ec.length - k];
+        if (!compoundCovers(simpleSelectors(a.compound), simpleSelectors(b.compound)))
+            return false;
+        if (k < rc.length && a.comb !== b.comb && !(a.comb === ' ' && b.comb === '>'))
+            return false;
+    }
+    return true;
+}
+const V45_USER_ACTION = /^:(?:hover|focus|focus-within|focus-visible|active|target|checked)$/i;
+// A document-level motion toggle: an attribute that names motion or animation
+// ([data-motion=paused], [data-reduced-motion]), or a class that is one
+// (.reduce-motion, .no-motion, .motion-paused, .animations-off). Component
+// classes that only end in "paused" (a marquee's .logobar--paused) are not.
+const V45_TOGGLE_ATTR = /^\[[\w-]*(?:motion|anim)[\w-]*(?:[~|^$*]?=[^\]]*)?\]$/i;
+const V45_TOGGLE_CLASS = /^\.(?:is-|has-|prefers-)?(?:reduced?-motion|no-motion|motion-(?:off|paused|reduced?|none)|paused-motion|(?:no-)?animations?(?:-(?:off|paused|disabled|none))?|(?:pause|stop)-animations?|still)$/i;
+/**
+ * Whether a compound before `*` reaches the whole document: html, :root or
+ * body with any qualifier, or a bare motion toggle (an attribute that names
+ * motion or animation, or a class that is a motion toggle), never a
+ * user-action state.
+ */
+function isDocumentScope(compound) {
+    const simple = simpleSelectors(compound);
+    if (!simple.length)
+        return false;
+    if (simple.some((s) => V45_USER_ACTION.test(s)))
+        return false;
+    const type = simple.find((s) => /^[a-z]/i.test(s) || /^:root$/i.test(s));
+    if (type)
+        return /^(?:html|body|:root)$/i.test(type);
+    return simple.every((s) => s.startsWith('.') || s.startsWith('['))
+        && simple.some((s) => V45_TOGGLE_ATTR.test(s) || V45_TOGGLE_CLASS.test(s));
+}
+function checkPausedEntrances(css) {
+    const ID = 'v45';
+    const ITEM = 'Pausing motion keeps content visible';
+    const CATEGORY = 'motion';
+    const { rules, keyframes } = parseCssRules(css);
+    const parsed = rules.map((rule) => ({ rule, decls: parseCssDecls(rule.decls) }));
+    const isReduce = (at) => at.some((a) => a.startsWith('@media') && /prefers-reduced-motion(?!\s*:\s*no-preference)/.test(a));
+    const isNoPreference = (at) => at.some((a) => a.startsWith('@media') && /prefers-reduced-motion\s*:\s*no-preference/.test(a));
+    const rootTokens = {};
+    for (const { rule, decls } of parsed) {
+        if (rule.at.some((a) => a.startsWith('@media')))
+            continue;
+        if (!splitCssTopLevel(rule.selector, ',').some((p) => /^\s*(?::root|html)\s*$/i.test(p)))
+            continue;
+        for (const d of decls)
+            if (d.prop.startsWith('--'))
+                rootTokens[d.prop] = d.value;
+    }
+    // 1. Pause scopes.
+    const scopes = [];
+    for (const { rule, decls } of parsed) {
+        const pause = [...decls].reverse().find((d) => d.prop === 'animation-play-state');
+        if (!pause || !/^paused(?:\s*,\s*paused)*$/i.test(pause.value))
+            continue;
+        const media = isReduce(rule.at);
+        for (const part of splitCssTopLevel(rule.selector, ',')) {
+            const comps = selectorCompounds(part);
+            const subject = comps[comps.length - 1];
+            if (!subject || !/^\*(?:::?(?:before|after))?$/i.test(subject.compound))
+                continue;
+            let prefix = '';
+            if (comps.length === 2 && comps[1].comb === ' ' && isDocumentScope(comps[0].compound))
+                prefix = simpleSelectors(comps[0].compound).join('');
+            else if (comps.length !== 1)
+                continue;
+            if (scopes.some((s) => s.prefix === prefix && s.media === media))
+                continue;
+            scopes.push({ prefix, media, selector: part, important: pause.important, spec: selectorSpecificity(part), order: rule.order, decls });
+        }
+    }
+    if (!scopes.length) {
+        return { id: ID, item: ITEM, category: CATEGORY, status: 'SKIP', detail: 'not applicable: no rule pauses every element (animation-play-state: paused on *)' };
+    }
+    // 2. Keyframes that start invisible (the last block of a name wins).
+    const hiddenNames = new Set();
+    const byName = new Map();
+    for (const k of keyframes)
+        byName.set(k.name, k);
+    for (const [name, k] of byName) {
+        // The first frame, and the last: an animation that also ends invisible
+        // (a flash or a glow that fades out) hides nothing a pause would reveal.
+        const frameHides = (edge) => {
+            let opacity = null;
+            let visibility = null;
+            for (const f of k.frames) {
+                if (!f.selector.split(',').some((x) => edge.test(x.trim())))
+                    continue;
+                for (const d of parseCssDecls(f.decls)) {
+                    if (d.prop === 'opacity')
+                        opacity = d.value.trim();
+                    if (d.prop === 'visibility')
+                        visibility = d.value.trim().toLowerCase();
+                }
+            }
+            return (opacity !== null && /\d/.test(opacity) && /^(?:0*\.?0*|0*(?:\.0+)?%)$/.test(opacity)) || visibility === 'hidden';
+        };
+        if (frameHides(/^(?:from|0*(?:\.0+)?%)$/) && !frameHides(/^(?:to|100(?:\.0+)?%)$/))
+            hiddenNames.add(name);
+    }
+    const entrances = [];
+    if (hiddenNames.size) {
+        for (const { rule, decls } of parsed) {
+            if (isReduce(rule.at))
+                continue;
+            const anim = [...decls].reverse().find((d) => d.prop === 'animation' || d.prop === 'animation-name');
+            if (!anim)
+                continue;
+            const list = (prop) => {
+                const d = [...decls].reverse().find((x) => x.prop === prop);
+                return d ? splitCssTopLevel(substituteCssVars(d.value, [rootTokens]) ?? d.value, ',') : null;
+            };
+            const segments = splitCssTopLevel(anim.value, ',');
+            segments.forEach((segment, idx) => {
+                const resolved = substituteCssVars(segment, [rootTokens]) ?? segment;
+                const tokens = splitCssTopLevel(resolved, ' ');
+                const name = anim.prop === 'animation-name' ? segment.trim() : splitCssTopLevel(segment, ' ').find((t) => hiddenNames.has(t));
+                if (!name || !hiddenNames.has(name))
+                    return;
+                let infinite = anim.prop === 'animation' && tokens.some((t) => t.toLowerCase() === 'infinite');
+                const times = anim.prop === 'animation' ? tokens.map(cssTimeMs).filter((x) => x !== null) : [];
+                const unknownTime = anim.prop === 'animation' && tokens.some((t) => /^var\(/i.test(t));
+                let durationMs = anim.prop === 'animation' ? (times.length ? times[0] : unknownTime ? null : 0) : null;
+                let delayMs = anim.prop === 'animation' ? (times.length > 1 ? times[1] : unknownTime ? null : 0) : 0;
+                let fill = anim.prop === 'animation' ? (tokens.find((t) => /^(?:none|forwards|backwards|both)$/i.test(t)) ?? 'none').toLowerCase() : 'none';
+                const pick = (l) => (l && l.length ? l[idx % l.length] : null);
+                const count = pick(list('animation-iteration-count'));
+                if (count !== null)
+                    infinite = /infinite/i.test(count);
+                const dur = pick(list('animation-duration'));
+                if (dur !== null)
+                    durationMs = cssTimeMs(dur);
+                const del = pick(list('animation-delay'));
+                if (del !== null)
+                    delayMs = cssTimeMs(del);
+                const fm = pick(list('animation-fill-mode'));
+                if (fm !== null)
+                    fill = fm.toLowerCase();
+                if (infinite || durationMs === 0)
+                    return;
+                if (delayMs !== null && delayMs > 0 && (fill === 'none' || fill === 'forwards'))
+                    return;
+                for (const part of splitCssTopLevel(rule.selector, ',')) {
+                    entrances.push({ name, part, spec: selectorSpecificity(part), order: rule.order, important: anim.important, shorthand: anim.prop === 'animation', durationMs, gated: isNoPreference(rule.at) });
+                }
+            });
+        }
+    }
+    // 4. Overrides: rules that end or remove an animation, with what they reach.
+    const neutralises = (decls, durationMs) => {
+        let best = 'no';
+        for (const d of decls) {
+            const v = d.value.trim().toLowerCase();
+            if ((d.prop === 'animation' || d.prop === 'animation-name') && /^none(?:\s*,\s*none)*$/.test(v))
+                return 'yes';
+            if (d.prop === 'animation-play-state' && /^running(?:\s*,\s*running)*$/.test(v))
+                return 'yes';
+            if (d.prop === 'animation-delay') {
+                const ms = splitCssTopLevel(substituteCssVars(v, [rootTokens]) ?? v, ',').map(cssTimeMs);
+                if (ms.length && ms.every((x) => x !== null && x < 0)) {
+                    const shortest = Math.min(...ms.map((x) => -x));
+                    if (durationMs !== null ? shortest >= durationMs : shortest >= 60000)
+                        return 'yes';
+                    if (durationMs === null)
+                        best = 'maybe';
+                }
+            }
+        }
+        return best;
+    };
+    const overrides = parsed
+        .map(({ rule, decls }) => ({ rule, decls }))
+        .filter(({ decls }) => decls.some((d) => /^animation(?:-name|-play-state|-delay)?$/.test(d.prop)));
+    const verdicts = [];
+    const seen = new Set();
+    for (const scope of scopes) {
+        for (const e of entrances) {
+            if (scope.media && e.gated)
+                continue;
+            const reaches = scope.important || !e.shorthand || compareSpecificity(scope.spec, e.spec) > 0
+                || (compareSpecificity(scope.spec, e.spec) === 0 && scope.order > e.order);
+            if (!reaches)
+                continue;
+            const key = `${scope.prefix}|${scope.media}|${e.name}|${e.part}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const eComps = selectorCompounds(e.part);
+            const eSubject = simpleSelectors(eComps[eComps.length - 1]?.compound ?? '');
+            let status = 'FAIL';
+            let override = null;
+            const own = neutralises(scope.decls, e.durationMs);
+            if (own === 'yes') {
+                status = 'PASS';
+                override = scope.selector;
+            }
+            for (const o of overrides) {
+                if (status === 'PASS')
+                    break;
+                for (const oPart of splitCssTopLevel(o.rule.selector, ',')) {
+                    if (status === 'PASS')
+                        break;
+                    const oComps = selectorCompounds(oPart);
+                    let rel = null;
+                    let otherScope = false;
+                    if (scope.media) {
+                        if (isReduce(o.rule.at))
+                            rel = oPart;
+                        else if (oComps.length > 1 && isDocumentScope(oComps[0].compound))
+                            otherScope = true;
+                    }
+                    else if (scope.prefix) {
+                        const first = simpleSelectors(oComps[0]?.compound ?? '').join('');
+                        if (oComps.length > 1 && oComps[1].comb === ' ' && first === scope.prefix && !isReduce(o.rule.at)) {
+                            rel = oPart.slice(oPart.indexOf(oComps[0].compound) + oComps[0].compound.length).trim();
+                        }
+                        else if (isReduce(o.rule.at) || (oComps.length > 1 && isDocumentScope(oComps[0].compound)))
+                            otherScope = true;
+                    }
+                    else {
+                        rel = oPart;
+                    }
+                    if (rel === null && !otherScope)
+                        continue;
+                    const effect = neutralises(o.decls, e.durationMs);
+                    if (effect === 'no')
+                        continue;
+                    // Under another scope: the selector after its document prefix, or
+                    // all of it inside a reduced-motion block.
+                    const target = rel ?? (isReduce(o.rule.at) && !(oComps.length > 1 && isDocumentScope(oComps[0].compound))
+                        ? oPart
+                        : oPart.slice(oPart.indexOf(oComps[0].compound) + oComps[0].compound.length).trim());
+                    let match = null;
+                    for (const alt of expandIsWhere(target)) {
+                        const aComps = selectorCompounds(alt);
+                        const aSubject = simpleSelectors(aComps[aComps.length - 1]?.compound ?? '');
+                        if (selectorCovers(alt, e.part)) {
+                            match = 'exact';
+                            break;
+                        }
+                        const named = (x) => x.startsWith('.') || x.startsWith('#') || x.startsWith('[');
+                        if (aSubject.some((x) => named(x) && compoundCovers([x], eSubject)))
+                            match = 'partial';
+                    }
+                    if (!match)
+                        continue;
+                    const oSpec = selectorSpecificity(oPart);
+                    const wins = o.decls.some((d) => d.important && /^animation(?:-name|-play-state|-delay)?$/.test(d.prop)) || (!e.important && (compareSpecificity(oSpec, e.spec) > 0
+                        || (compareSpecificity(oSpec, e.spec) === 0 && o.rule.order > e.order)));
+                    if (match === 'exact' && effect === 'yes' && wins && rel !== null) {
+                        status = 'PASS';
+                        override = oPart;
+                    }
+                    else if (status === 'FAIL') {
+                        status = 'WARN';
+                        override = oPart;
+                    }
+                }
+            }
+            verdicts.push({ entrance: e, scope, status, override });
+        }
     }
-    const found = Object.entries(families).filter(([, v]) => v).map(([k]) => k);
-    const missing = Object.entries(families).filter(([, v]) => !v).map(([k]) => k);
-    if (found.length >= 3) {
-        return { id: 'v43', item, category: 'semantic', status: 'PASS', detail: `${found.length}/4 status families present (${found.join(', ')}): states expressed as semantic roles` };
+    const scopeNames = scopes.map((s) => (s.media ? `@media (prefers-reduced-motion: reduce) ${shortSelector(s.selector)}` : shortSelector(s.selector)));
+    if (!verdicts.length) {
+        return {
+            id: ID, item: ITEM, category: CATEGORY, status: 'PASS',
+            detail: `pause scope ${scopeNames.join(', ')}: no one-shot entrance it holds starts at opacity 0`,
+            evidence: { findings: [], truncated: 0 },
+        };
     }
-    return { id: 'v43', item, category: 'semantic', status: 'WARN', detail: `${found.length}/4 status families present${found.length ? ` (${found.join(', ')})` : ''}; missing: ${missing.join(', ')}` };
+    const rank = { FAIL: 0, WARN: 1, PASS: 2 };
+    verdicts.sort((a, b) => rank[a.status] - rank[b.status]);
+    const fails = verdicts.filter((v) => v.status === 'FAIL');
+    const warns = verdicts.filter((v) => v.status === 'WARN');
+    const status = fails.length ? 'FAIL' : warns.length ? 'WARN' : 'PASS';
+    const pauseRule = (v) => (v.scope.media ? `@media (prefers-reduced-motion: reduce) ${shortSelector(v.scope.selector)}` : shortSelector(v.scope.selector));
+    const say = (v) => `@keyframes ${v.entrance.name} on ${shortSelector(v.entrance.part)} under ${pauseRule(v)}${v.override ? ` (override: ${shortSelector(v.override)})` : ''}`;
+    const lead = status === 'FAIL' ? fails : warns;
+    const detail = status === 'PASS'
+        ? `${verdicts.length} entrance(s) that start at opacity 0 end or are removed under the pause (${scopeNames.join(', ')})`
+        : status === 'FAIL'
+            ? `${fails.length} entrance(s) start at opacity 0 and stay held invisible under the pause: ${fails.slice(0, 2).map(say).join(' | ')}${fails.length > 2 ? ` | ${fails.length - 2} more` : ''}`
+            : `${warns.length} entrance(s) with an override whose selector or scope does not clearly match: ${lead.slice(0, 2).map(say).join(' | ')}${warns.length > 2 ? ` | ${warns.length - 2} more` : ''}`;
+    return {
+        id: ID, item: ITEM, category: CATEGORY, status, detail,
+        evidence: {
+            findings: verdicts.slice(0, 20).map((v) => ({ keyframes: v.entrance.name, selector: shortSelector(v.entrance.part), pauseRule: pauseRule(v), override: v.override === null ? null : shortSelector(v.override), status: v.status })),
+            truncated: Math.max(0, verdicts.length - 20),
+        },
+    };
 }
 // v34 — AI-Disclosure Readiness (EU AI Act Article 50, effective 2026-08-02).
 // Static-only v1: scans fetched HTML for AI-interactive surfaces (chatbots,
@@ -2063,6 +3757,191 @@ async function checkDesignMdSpec(targetUrl) {
         return { id: 'v37', item: ITEM, category: CATEGORY, status: 'WARN', detail: `/DESIGN.md fetched but lint failed: ${msg}. The file may use a format version the linter doesn't support yet.` };
     }
 }
+// ── Score arithmetic, shared by both engine copies ─────────────────────────
+// Everything between the check verdicts and the grade: category weights, the
+// weighted score, the slop deduction, the originality lift, the per-category
+// sub-scores, the accessibility floor and the hard-fail ceilings. It is one
+// function so the source-drift gate compares it as one unit. Until engine
+// 1.2.0 the arithmetic sat inline in each orchestrator, outside the gate, and
+// the copies disagreed on the floor: the site capped at 70 when the
+// accessibility category was under 60%, the npm engine on any accessibility
+// FAIL. The site's rule is the one documented on /methodology.
+function scoreArithmetic(checks, slopTotal, originalityPoints) {
+    // ── Tier 2: per-category weighted scoring ──────────────────────────────────
+    // Weights follow the contract's section emphasis (the contract IS the scoring
+    // basis), with an accessibility floor so contract sections covering real-user
+    // harm cannot be drowned out by cadence's 8 checks. SKIPs fall out of BOTH
+    // numerator and denominator (Lighthouse precedent: manual/N/A audits excluded).
+    //
+    // Weight table (relative weights, sums to 117 — the scoring formula
+    // normalizes via Σ(points)/Σ(total). Derived from AnySearch research against
+    // Lighthouse axe user-impact, design-auditor category %, and DSAF 50/50):
+    //   cadence 18, accessibility 15, semantic 12, motion 10, tokens 9,
+    //   takt 8, poise 7, identity 6, interaction 6, performance 6, responsive 3
+    // v0.4.0 additions: copywriting 8, security 5, spec 4
+    const CATEGORY_WEIGHTS = {
+        cadence: 18, accessibility: 15, semantic: 12, motion: 10, tokens: 9,
+        takt: 8, poise: 7, identity: 6, interaction: 6, performance: 6, responsive: 3,
+        security: 5, spec: 4, copywriting: 8,
+    };
+    // Per-check weight = category weight / number of checks in that category
+    // (so each category contributes its full weight, split evenly among its checks).
+    const categoryCounts = {};
+    for (const c of checks) {
+        if (c.status === 'SKIP' || c.status === 'MANUAL')
+            continue;
+        categoryCounts[c.category] = (categoryCounts[c.category] || 0) + 1;
+    }
+    let weightedPoints = 0;
+    let weightedTotal = 0;
+    for (const c of checks) {
+        if (c.status === 'SKIP' || c.status === 'MANUAL')
+            continue;
+        const catWeight = CATEGORY_WEIGHTS[c.category] || 5;
+        const checkWeight = catWeight / (categoryCounts[c.category] || 1);
+        weightedTotal += checkWeight;
+        if (c.status === 'PASS')
+            weightedPoints += checkWeight;
+        else if (c.status === 'WARN')
+            weightedPoints += checkWeight * 0.5;
+        // FAIL = 0 points
+    }
+    let score = weightedTotal === 0 ? 0 : Math.round((weightedPoints / weightedTotal) * 1000) / 10;
+    // ── Anti-slop deduction ─────────────────────────────────────────────────────
+    // Apply detected slop patterns as a direct subtraction from the weighted score.
+    // The deduction is flat (not percentage-scaled) so it cannot be gamed by making
+    // the site more minimal. Capped at 20 total.
+    if (slopTotal > 0) {
+        score = Math.max(0, score - slopTotal);
+    }
+    // ── Originality lift ─────────────────────────────────────────────────────────
+    // Reward positive craft signals. Applied after the slop deduction so a generic
+    // site with no distinctive signals stays at its (already-slop-deducted) score,
+    // while a distinctive site is lifted above the compliant-but-generic baseline.
+    // Capped at +8. Score clamped to ≤100 since this is a bonus on a 100-scale base.
+    if (originalityPoints > 0) {
+        score = Math.min(100, score + originalityPoints);
+    }
+    // One decimal, the precision scores are shown at: subtracting a fractional
+    // slop total leaves float noise (72.6 - 20 + 4 is 56.599999999999994).
+    score = Math.round(score * 10) / 10;
+    // ── Per-category sub-scores (the constellation) ─────────────────────────
+    // Each category gets its own 0-100 score using the same weighting rule as
+    // the composite (PASS 1.0 / WARN 0.5 / FAIL 0, SKIP excluded). Categories
+    // with zero scored checks report null so the client can render them as
+    // "unscored" rather than fabricating a 0 or 100. This is the same math the
+    // composite uses — one source of truth, no client-side re-derivation.
+    const catAgg = {};
+    for (const c of checks) {
+        const agg = catAgg[c.category] || (catAgg[c.category] = { wp: 0, wt: 0, pass: 0, fail: 0, warn: 0, skip: 0, manual: 0 });
+        if (c.status === 'SKIP') {
+            agg.skip += 1;
+            continue;
+        }
+        if (c.status === 'MANUAL') {
+            agg.manual += 1;
+            continue;
+        }
+        const checkWeight = (CATEGORY_WEIGHTS[c.category] || 5) / (categoryCounts[c.category] || 1);
+        agg.wt += checkWeight;
+        if (c.status === 'PASS') {
+            agg.wp += checkWeight;
+            agg.pass += 1;
+        }
+        else if (c.status === 'WARN') {
+            agg.wp += checkWeight * 0.5;
+            agg.warn += 1;
+        }
+        else
+            agg.fail += 1; // FAIL
+    }
+    const categoryScores = {};
+    for (const [cat, agg] of Object.entries(catAgg)) {
+        categoryScores[cat] = {
+            score: agg.wt === 0 ? null : Math.round((agg.wp / agg.wt) * 1000) / 10,
+            weight: CATEGORY_WEIGHTS[cat] || 5,
+            pass: agg.pass,
+            fail: agg.fail,
+            warn: agg.warn,
+            skip: agg.skip,
+            manual: agg.manual,
+        };
+    }
+    // ── Tier 2: accessibility floor (DSAF enterprise-grade precedent) ──────────
+    // DSAF enforces A8 Accessibility ≥75% — a system can score 90% combined and
+    // still fail enterprise-grade if a11y is 73%. We apply a softer version: if
+    // the accessibility category scores below 60%, cap the overall grade at C.
+    // This prevents "perfect tokens, zero a11y = A" dishonesty.
+    const a11yChecks = checks.filter((c) => c.category === 'accessibility' && c.status !== 'SKIP' && c.status !== 'MANUAL');
+    const a11yPass = a11yChecks.filter((c) => c.status === 'PASS').length;
+    const a11yWarn = a11yChecks.filter((c) => c.status === 'WARN').length;
+    const a11yScored = a11yChecks.length;
+    const a11yPct = a11yScored === 0 ? 100 : ((a11yPass + a11yWarn * 0.5) / a11yScored) * 100;
+    let a11yFloorApplied = false;
+    if (a11yScored > 0 && a11yPct < 60) {
+        // Cap at C (70). If the weighted score is already below 70, leave it.
+        if (score > 70) {
+            score = 70;
+            a11yFloorApplied = true;
+        }
+    }
+    // ── Hard-fail ceilings (PixelJury precedent) ────────────────────────────────
+    // Certain check FAILures are so severe they cap the score regardless of other
+    // strengths. These are design-integrity failures — a site that FAILs on
+    // contrast or horizontal overflow cannot be A-grade no matter how good its
+    // tokens are. Caps are applied AFTER the a11y floor (floor wins over ceilings).
+    const hardFailChecks = checks.filter((c) => c.status === 'FAIL');
+    let hardFailCeilingApplied = false;
+    let hardFailCeilingReason = null;
+    for (const c of hardFailChecks) {
+        let cap = null;
+        let reason = null;
+        // v06 Contrast readable — fundamental legibility failure
+        if (c.id === 'v06') {
+            cap = 65;
+            reason = 'Contrast below WCAG minimum: text is unreadable for many users.';
+        }
+        // v22 Contrast signal — CTA text unreadable on brand color
+        if (c.id === 'v22') {
+            cap = 70;
+            reason = 'Primary CTA contrast below WCAG AA: the most important interaction on the page is hard to read.';
+        }
+        // v02 Horizontal overflow — broken layout on mobile
+        if (c.id === 'v02') {
+            cap = 70;
+            reason = 'Horizontal overflow detected: content is cut off or scrolls sideways on smaller viewports.';
+        }
+        // v24 Touch targets — interactive elements too small to use
+        if (c.id === 'v24') {
+            cap = 75;
+            reason = 'Interactive elements below the 44px minimum touch target (WCAG 2.5.5 Enhanced): inaccessible on touch devices.';
+        }
+        // v25 Heading hierarchy — broken document outline
+        if (c.id === 'v25') {
+            cap = 75;
+            reason = 'Multiple h1 elements or skipped heading levels: document outline is broken.';
+        }
+        // v16 Rem scale — root font-size under 16px (iOS zoom break)
+        if (c.id === 'v16') {
+            cap = 70;
+            reason = 'Root font-size below 16px: triggers iOS Safari auto-zoom, breaks mobile UX.';
+        }
+        if (cap !== null && score > cap) {
+            score = cap;
+            hardFailCeilingApplied = true;
+            hardFailCeilingReason = reason;
+        }
+    }
+    return {
+        score,
+        categoryWeights: CATEGORY_WEIGHTS,
+        categoryCounts,
+        categoryScores,
+        a11yFloorApplied,
+        hardFailCeilingApplied,
+        hardFailCeilingReason,
+    };
+}
 function computeGrade(score) {
     if (score >= 90)
         return 'A';
@@ -2172,7 +4051,7 @@ export async function scoreFromParts(input) {
         checkTouchTargets(css),
         checkHeadingHierarchy(html),
         checkFontFamilyCount(css, tokens),
-        checkInputFontFloor(css),
+        checkInputFontFloor(css, html),
         checkReadingWidth(css),
         checkTokenLayerDepth(tokens),
         checkSemanticColorVocabulary(tokens),
@@ -2184,6 +4063,8 @@ export async function scoreFromParts(input) {
         checkNoTrailingPeriod(html),
         checkLinkTextDescriptive(html),
         checkNoAllCaps(html),
+        checkStatusTextContrast(css),
+        checkPausedEntrances(css),
     ];
     // v37 is async — added after the synchronous checks array
     //
@@ -2242,39 +4123,98 @@ export async function scoreFromParts(input) {
         if (usedFonts.size > 0)
             slopFindings.push({ id: 'S1', label: 'Overused font family', severity: 5, instances: usedFonts.size, evidence: [...usedFonts] });
     }
-    // S2. Full-page gradient background
+    // S2. Full-page gradient background: a multi-stop linear gradient that
+    // covers the viewport. Not: a gradient on a component (the glass score hero,
+    // a window sheen, a cell fill), a hairline, or a grid.
+    //
+    // Viewport evidence is required: the gradient is painted on html, body or
+    // :root, the rule is position: fixed and pinned to all four edges (or sized
+    // to the viewport), or it is sized in viewport units.
+    // Until engine 1.2.0 `inset: 0` counted as full-bleed, but inset: 0 fills
+    // the nearest positioned ancestor, which is a component; designesy.org lost
+    // 5 points to a 1px window sheen, a cell fill and a heatmap bar that all
+    // matched on it. A viewport-sized rule with border-radius: inherit is still
+    // a component. A gradient sized to 1px (height, width, border width, or a
+    // background-size with a 1px dimension, as in `top / 100% 1px`) is a hairline.
     {
         // A repeating hairline pattern is a GRID, not a decorative gradient wash.
         //
-        // The previous pattern required the colour to precede the stop —
-        // `(transparent|rgba(...))\s+1px` — which only matches
-        // `linear-gradient(transparent 1px, ...)`. The form actually used on
-        // designesy.org is the reverse: `linear-gradient(color-mix(...) 1px,
-        // transparent 1px)`, so the filter never fired and a graph-paper grid
-        // overlay was reported as "Full-page gradient background" at severity 5 —
-        // the maximum — deducting the full 20-point slop budget on a page whose
-        // background is a 1px grid on near-black.
-        //
-        // Match a 1px stop in EITHER order, which is what "hairline" means
-        // regardless of how the colour and the stop are written.
+        // An earlier pattern required the colour to precede the stop, which only
+        // matches `linear-gradient(transparent 1px, ...)`; designesy.org writes the
+        // reverse, `linear-gradient(color-mix(...) 1px, transparent 1px)`, and its
+        // graph-paper grid was reported at the maximum severity. Match a 1px stop
+        // in EITHER order, which is what "hairline" means however it is written.
         const isGridPattern = (text) => /(?:transparent|rgba\([^)]+\)|color-mix\([^)]*\)|var\([^)]*\)|#[0-9a-fA-F]{3,8})\s+1px(?:\s*,)/.test(text)
             || /\s+1px\s*,\s*(?:transparent|rgba\([^)]+\)|color-mix\([^)]*\)|var\([^)]*\))/.test(text);
-        const bodyGrad = css.match(/(?:^|})\s*(?:body|html)(?!::)[^{]*\{[^}]*background(?:-image)?\s*:[^;{}]*linear-gradient\s*\([^)]*,\s*[^)]*\)/gi) || [];
-        const overlayGrad = [];
-        const gradBlockRe = /\{[^{}]{0,500}?linear-gradient\s*\(\s*[^)]*,\s*[^)]{4,}\)[^{}]{0,500}?\}/gi;
-        let block;
-        while ((block = gradBlockRe.exec(css)) !== null) {
-            const decl = block[0];
-            const fullBleed = /position\s*:\s*fixed/i.test(decl) || /inset\s*:\s*0\b/i.test(decl) || /width\s*:\s*100vw/i.test(decl) || /height\s*:\s*100vh/i.test(decl);
-            const hairline = /(?:height|width)\s*:\s*1px\b/.test(decl) || /border(?:-top|-bottom)?-width\s*:\s*1px\b/.test(decl);
-            if (fullBleed && !hairline)
-                overlayGrad.push(decl.slice(0, 160));
-        }
-        const bodyGradFiltered = bodyGrad.filter(m => !isGridPattern(m));
-        const overlayGradFiltered = overlayGrad.filter(m => !isGridPattern(m));
-        const instances = bodyGradFiltered.length + overlayGradFiltered.length;
-        if (instances > 0)
-            slopFindings.push({ id: 'S2', label: 'Full-page gradient background', severity: 5, instances, evidence: [...bodyGradFiltered, ...overlayGradFiltered].slice(0, 3) });
+        // Two or more colour stops in some linear-gradient() of the value.
+        const multiStop = (value) => {
+            let from = 0;
+            for (;;) {
+                const at = value.toLowerCase().indexOf('linear-gradient(', from);
+                if (at < 0)
+                    return false;
+                let depth = 0;
+                let end = -1;
+                for (let i = at + 15; i < value.length; i++) {
+                    if (value[i] === '(')
+                        depth++;
+                    else if (value[i] === ')' && --depth === 0) {
+                        end = i;
+                        break;
+                    }
+                }
+                if (end < 0)
+                    return false;
+                const args = splitCssTopLevel(value.slice(at + 16, end), ',');
+                const stops = /^(?:to\s|[-+]?[\d.]+(?:deg|turn|rad|grad)\b)/i.test(args[0] ?? '') ? args.slice(1) : args;
+                if (stops.length >= 2)
+                    return true;
+                from = end;
+            }
+        };
+        const pageGrad = [];
+        for (const rule of parseCssRules(css).rules) {
+            if (!/linear-gradient\s*\(/i.test(rule.decls))
+                continue;
+            const decls = parseCssDecls(rule.decls);
+            if (!decls.some((d) => (d.prop === 'background' || d.prop === 'background-image') && multiStop(d.value)))
+                continue;
+            const text = `${rule.selector}{${rule.decls}}`;
+            if (isGridPattern(text))
+                continue;
+            const last = (prop) => [...decls].reverse().find((d) => d.prop === prop)?.value.trim().toLowerCase() ?? '';
+            const pageSelector = splitCssTopLevel(rule.selector, ',').some((p) => {
+                const comps = selectorCompounds(p);
+                const subject = comps[comps.length - 1]?.compound ?? '';
+                return /^(?:html|body|:root)(?![\w-])/i.test(subject) && !/::?(?:before|after|marker|backdrop)/i.test(subject);
+            });
+            // A fixed element covers the viewport only when it is pinned to all four
+            // edges or sized to it; a fixed drawer or toast is not a page background.
+            const zero = (v) => /^0(?:px|rem|em|%)?$/.test(v);
+            const inset = last('inset');
+            const pinned = (inset !== '' && inset.split(/\s+/).every(zero))
+                || ['top', 'right', 'bottom', 'left'].every((side) => zero(last(side)));
+            const viewportSized = decls.some((d) => /^(?:width|height|min-width|min-height|inline-size|block-size|min-inline-size|min-block-size)$/.test(d.prop)
+                && /(?:^|[\s(,])100(?:d|s|l)?v(?:w|h|i|b)\b/i.test(d.value));
+            const component = last('border-radius') === 'inherit';
+            const hairline = decls.some((d) => (/^(?:height|width|block-size|inline-size)$/.test(d.prop) && d.value.trim() === '1px')
+                || (/^border(?:-top|-bottom)?-width$/.test(d.prop) && d.value.trim() === '1px')
+                || (d.prop === 'background-size' && /(?:^|[\s,])1px(?:$|[\s,])/.test(d.value))
+                || (d.prop === 'background' && /\/\s*[^,/]*(?:^|\s)1px(?:$|[\s,])/.test(d.value)));
+            const fixedCover = last('position') === 'fixed' && (pinned || viewportSized);
+            if ((pageSelector || fixedCover || (viewportSized && !component)) && !hairline)
+                pageGrad.push(text.replace(/\s+/g, ' ').slice(0, 160));
+        }
+        const instances = pageGrad.length;
+        if (instances > 0) {
+            slopFindings.push({
+                id: 'S2',
+                label: 'Full-page gradient background',
+                severity: 5,
+                instances,
+                evidence: pageGrad.slice(0, 3),
+            });
+        }
     }
     // S3. Purple/violet gradient
     {
@@ -2377,12 +4317,68 @@ export async function scoreFromParts(input) {
         if (emojiInButtons && emojiInButtons.length >= 2)
             slopFindings.push({ id: 'S7', label: 'Emoji as UI icons', severity: 4, instances: emojiInButtons.length, evidence: [`${emojiInButtons.length} emoji in button/CTA elements`] });
     }
-    // S8. AI-pill badges
+    // S8. AI-pill badges: "AI-powered", "Generate", "Chat with AI" and the like
+    // as the short text of a pill, badge, chip, tag or call to action.
+    //
+    // Until engine 1.2.0 this matched the whole HTML with no word boundary and
+    // no element scope, so it read prose and the framework's <script> payload:
+    // on designesy.org it counted three sentences arguing against AI sameness,
+    // twice each, because "Generate" matched "generates" and "AI-generated".
+    // Now <script>, <style>, <template> and comments are stripped, the phrases
+    // match whole words only, and only a pill counts: an element whose class or
+    // role names a badge, pill, chip, tag or CTA, a button, a link, or a span
+    // with a border-radius of its own, holding 40 characters of text or fewer.
+    // Skipped on a page that documents the rules (see isDocumentingSlopRules):
+    // the anti-slop rule table on /methodology lists these phrases.
     {
-        const pillPattern = /(?:AI-powered|Generate|Chat with AI|Powered by AI|Built with AI|AI-driven)/gi;
-        const matches = html.match(pillPattern) || [];
-        if (matches.length > 0 && !isDocumentingSlopRules)
-            slopFindings.push({ id: 'S8', label: 'AI-pill badge text', severity: 3, instances: matches.length, evidence: [...new Set(matches.map(m => m.trim()))].slice(0, 3) });
+        const visible = html
+            .replace(/<script\b[\s\S]*?<\/script\s*>/gi, ' ')
+            .replace(/<style\b[\s\S]*?<\/style\s*>/gi, ' ')
+            .replace(/<template\b[\s\S]*?<\/template\s*>/gi, ' ')
+            .replace(/<!--[\s\S]*?-->/g, ' ');
+        const pillPhrase = /\b(?:AI-powered|Generate|Chat with AI|Powered by AI|Built with AI|AI-driven)\b/i;
+        const openRe = /<(span|a|button|div|small|strong|b|em|mark|label|p|li)\b([^<>]*)>/gi;
+        const tagRe = {};
+        const pills = [];
+        let open;
+        while ((open = openRe.exec(visible)) !== null) {
+            const tag = open[1].toLowerCase();
+            const attrs = open[2];
+            const named = [...attrs.matchAll(/\b(?:class|role)\s*=\s*["']([^"']*)["']/gi)].map((a) => a[1]).join(' ');
+            const pillish = /(?:^|[\s_-])(?:badge|pill|chip|tag|cta)(?:$|[\s_-])/i.test(named);
+            const rounded = tag === 'span' && /\bstyle\s*=\s*["'][^"']*border-radius\s*:/i.test(attrs);
+            if (!pillish && !rounded && tag !== 'button' && tag !== 'a')
+                continue;
+            // The element's content, to its matching close tag, within 2,000 characters.
+            const start = open.index + open[0].length;
+            const windowText = visible.slice(start, start + 2000);
+            const re = tagRe[tag] ?? (tagRe[tag] = new RegExp(`<(/?)${tag}\\b[^<>]*>`, 'gi'));
+            re.lastIndex = 0;
+            let depth = 1;
+            let end = -1;
+            let t;
+            while ((t = re.exec(windowText)) !== null) {
+                depth += t[1] ? -1 : 1;
+                if (depth === 0) {
+                    end = t.index;
+                    break;
+                }
+            }
+            if (end < 0)
+                continue;
+            const text = windowText.slice(0, end).replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
+            if (text && text.length <= 40 && pillPhrase.test(text))
+                pills.push(text);
+        }
+        if (pills.length > 0 && !isDocumentingSlopRules) {
+            slopFindings.push({
+                id: 'S8',
+                label: 'AI-pill badge text',
+                severity: 3,
+                instances: pills.length,
+                evidence: [...new Set(pills)].slice(0, 3),
+            });
+        }
     }
     // S9. Lorem ipsum
     {
@@ -2539,116 +4535,8 @@ export async function scoreFromParts(input) {
     const originalitySummary = originalitySignals.length > 0
         ? `${originalitySignals.length} craft signal${originalitySignals.length !== 1 ? 's' : ''} (+${originalityPoints}pts${rawOriginality > ORIGINALITY_CAP ? `, capped from +${rawOriginality}` : ''}${slopGateApplied ? ', slop-gated ×0.5' : ''})`
         : null;
-    // ── Weighted scoring ─────────────────────────────────────────────────────
-    const CATEGORY_WEIGHTS = {
-        cadence: 18, accessibility: 15, semantic: 12, motion: 10, tokens: 9, takt: 8, poise: 7, identity: 6, interaction: 6, performance: 6, responsive: 3, security: 5, spec: 4, copywriting: 8,
-    };
-    const categoryCounts = {};
-    for (const c of checks) {
-        if (c.status === 'SKIP' || c.status === 'MANUAL')
-            continue;
-        categoryCounts[c.category] = (categoryCounts[c.category] || 0) + 1;
-    }
-    let weightedPoints = 0;
-    let weightedTotal = 0;
-    for (const c of checks) {
-        if (c.status === 'SKIP' || c.status === 'MANUAL')
-            continue;
-        const catWeight = CATEGORY_WEIGHTS[c.category] || 5;
-        const checkWeight = catWeight / (categoryCounts[c.category] || 1);
-        weightedTotal += checkWeight;
-        if (c.status === 'PASS')
-            weightedPoints += checkWeight;
-        else if (c.status === 'WARN')
-            weightedPoints += checkWeight * 0.5;
-    }
-    let score = weightedTotal === 0 ? 0 : Math.round((weightedPoints / weightedTotal) * 1000) / 10;
-    if (slopTotal > 0)
-        score = Math.max(0, score - slopTotal);
-    if (originalityPoints > 0)
-        score = Math.min(100, score + originalityPoints);
-    // Per-category sub-scores
-    const catAgg = {};
-    for (const c of checks) {
-        const agg = catAgg[c.category] || (catAgg[c.category] = { wp: 0, wt: 0, pass: 0, fail: 0, warn: 0, skip: 0, manual: 0 });
-        if (c.status === 'SKIP') {
-            agg.skip += 1;
-            continue;
-        }
-        if (c.status === 'MANUAL') {
-            agg.manual += 1;
-            continue;
-        }
-        const checkWeight = (CATEGORY_WEIGHTS[c.category] || 5) / (categoryCounts[c.category] || 1);
-        agg.wt += checkWeight;
-        if (c.status === 'PASS') {
-            agg.wp += checkWeight;
-            agg.pass += 1;
-        }
-        else if (c.status === 'WARN') {
-            agg.wp += checkWeight * 0.5;
-            agg.warn += 1;
-        }
-        else
-            agg.fail += 1;
-    }
-    const categoryScores = {};
-    for (const [cat, agg] of Object.entries(catAgg)) {
-        categoryScores[cat] = {
-            score: agg.wt === 0 ? null : Math.round((agg.wp / agg.wt) * 1000) / 10,
-            weight: CATEGORY_WEIGHTS[cat] || 5,
-            pass: agg.pass, fail: agg.fail, warn: agg.warn, skip: agg.skip, manual: agg.manual,
-        };
-    }
-    // A11y floor: cap score at C (70) when any accessibility FAIL exists
-    let a11yFloorApplied = false;
-    for (const c of checks) {
-        if (c.category === 'accessibility' && c.status === 'FAIL') {
-            if (score > 70) {
-                score = 70;
-                a11yFloorApplied = true;
-            }
-            break;
-        }
-    }
-    // Hard-fail ceilings for critical issues
-    let hardFailCeilingApplied = false;
-    let hardFailCeilingReason = null;
-    for (const c of checks) {
-        if (c.status !== 'FAIL')
-            continue;
-        let cap = null;
-        let reason = '';
-        if (c.id === 'v06') {
-            cap = 65;
-            reason = 'Contrast below WCAG minimum: text is unreadable for many users.';
-        }
-        if (c.id === 'v22') {
-            cap = 70;
-            reason = 'Primary CTA contrast below WCAG AA: the most important interaction on the page is hard to read.';
-        }
-        if (c.id === 'v02') {
-            cap = 70;
-            reason = 'Horizontal overflow detected: content is cut off or scrolls sideways on smaller viewports.';
-        }
-        if (c.id === 'v24') {
-            cap = 75;
-            reason = 'Interactive elements below the 44px minimum touch target: inaccessible on touch devices.';
-        }
-        if (c.id === 'v25') {
-            cap = 75;
-            reason = 'Multiple h1 elements or skipped heading levels: document outline is broken.';
-        }
-        if (c.id === 'v16') {
-            cap = 70;
-            reason = 'Root font-size below 16px: triggers iOS Safari auto-zoom, breaks mobile UX.';
-        }
-        if (cap !== null && score > cap) {
-            score = cap;
-            hardFailCeilingApplied = true;
-            hardFailCeilingReason = reason;
-        }
-    }
+    // The arithmetic is shared with the other engine copy; see scoreArithmetic.
+    const { score, categoryWeights: CATEGORY_WEIGHTS, categoryCounts, categoryScores, a11yFloorApplied, hardFailCeilingApplied, hardFailCeilingReason, } = scoreArithmetic(checks, slopTotal, originalityPoints);
     const grade = computeGrade(score);
     const checksWithRemediation = checks.map((c) => {
         const catWeight = CATEGORY_WEIGHTS[c.category] || 5;
@@ -2668,9 +4556,11 @@ export async function scoreFromParts(input) {
 /**
  * The contract revision these checks implement, reported by every emission.
  * The site derives its copy from the contract source; this standalone engine
- * pins it here, once, and each release moves it.
+ * pins it here, once, and each release moves it. 0.6.0 shipped v0.4.1 while
+ * the site served v0.4.3; test/engine-1-2-0.test.mjs now reads the site's
+ * contract source and fails when the two differ.
  */
-export const CONTRACT_VERSION = 'v0.4.1';
+export const CONTRACT_VERSION = 'v0.4.3';
 /**
  * The one verdict rule, shared by every emission format.
  *