@designesy/score 0.7.2 → 0.8.0

package/dist/engine.js

@@ -312,7 +312,9 @@ async function fetchPageResilient(targetUrl) {
 function extractRootTokens(css) {
     const stripped = css.replace(/@media[^{]*\{[^@]*?\}\s*\}/gi, '');
     const tokens = {};
-    const rootRe = /:root\s*\{([^}]*)\}/g;
+    // `:root, :host { ... }` is the block Tailwind v4 writes its theme into;
+    // until engine 1.3.0 only `:root {` was read, so those tokens were missed.
+    const rootRe = /:root(?:\s*,\s*:host)?\s*\{([^}]*)\}/g;
     let m;
     while ((m = rootRe.exec(stripped)) !== null) {
         const block = m[1];
@@ -360,22 +362,6 @@ function inferTokensFromCss(css, tokens) {
     return result;
 }
 // ── Color utilities ──────────────────────────────────────────────────────────
-function hexToRgb(color) {
-    color = color.trim();
-    if (!color.startsWith('#'))
-        return null;
-    let hex = color.slice(1);
-    if (hex.length === 3)
-        hex = hex.split('').map((c) => c + c).join('');
-    if (hex.length !== 6)
-        return null;
-    const r = parseInt(hex.slice(0, 2), 16);
-    const g = parseInt(hex.slice(2, 4), 16);
-    const b = parseInt(hex.slice(4, 6), 16);
-    if (isNaN(r) || isNaN(g) || isNaN(b))
-        return null;
-    return [r, g, b];
-}
 function srgbChannelToLinear(c) {
     const s = c / 255;
     return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
@@ -388,23 +374,32 @@ function contrastRatio(a, b) {
     const lb = relativeLuminance(b);
     return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
 }
-function resolveColor(value, tokens) {
-    const v = value.trim();
-    if (!v)
+/**
+ * A token value as the opaque sRGB colour v06 and v22 measure.
+ *
+ * Read through the CSS Color 4 parser v44 uses (resolveThemeColor): var()
+ * chains with fallbacks, hex of 3, 4, 6 or 8 digits, rgb() and hsl() in comma
+ * or space syntax, oklch(), oklab(), color(srgb), color-mix(), light-dark()
+ * (its light side: these two checks read one theme) and bare HSL channels.
+ * Until engine 1.3.0 they read only 3- and 6-digit hex and comma rgb(), with
+ * alpha ignored, so a stylesheet written in oklch() (Tailwind v4, shadcn)
+ * SKIPped both checks and a page with illegible text scored 100.
+ *
+ * A translucent colour is composited over `under` as a browser paints it;
+ * with nothing under it, it is not measured.
+ */
+function resolveTokenColor(value, tokens, under) {
+    if (!value.trim())
         return null;
-    if (v.startsWith('#'))
-        return hexToRgb(v);
-    const varMatch = v.match(/^var\(\s*(--[\w-]+)/);
-    if (varMatch) {
-        const ref = tokens[varMatch[1]];
-        if (ref)
-            return resolveColor(ref, tokens);
+    const c = resolveThemeColor(value, [tokens], false);
+    if (!c)
         return null;
-    }
-    const rgbMatch = v.match(/rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/i);
-    if (rgbMatch)
-        return [parseInt(rgbMatch[1]), parseInt(rgbMatch[2]), parseInt(rgbMatch[3])];
-    return null;
+    if (c[3] >= 1)
+        return [c[0], c[1], c[2]];
+    if (!under)
+        return null;
+    const painted = v44Composite(c, [under[0], under[1], under[2], 1]);
+    return [painted[0], painted[1], painted[2]];
 }
 // APCA-W3 0.0.98G-4g
 function sRGBtoY_APCA(rgb) {
@@ -471,7 +466,7 @@ const REMEDIATION = {
     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).',
+    v34: 'If the page hosts an AI chatbot or agent, tell people they are talking to an AI no later than their first interaction, in a form assistive technology announces. EU AI Act Article 50(1), which applies from 2026-08-02, places this duty on the provider of the AI system (the organisation that develops it and places it on the market or puts it into service under its own name); it does not apply where the AI nature is obvious from the context, and Article 50(5) asks for the information to be clear and accessible. The check reads any one of: visible "AI assistant" or "Chatbot" text, aria-label="AI assistant" on the chat container, or a data-ai-disclosure attribute on the widget. A live chat answered by people needs no AI disclosure: if the check flagged one for review, confirm who answers. US laws differ in scope: California\'s bot-disclosure law (SB 1001, Bus. & Prof. Code §§17940-17943) covers bots that mislead people about being bots to drive a sale or influence a vote; Colorado SB 24-205 was repealed and re-enacted by SB 26-189 (signed 2026-05-14, obligations from 2027-01-01), which governs automated decision-making in consequential decisions. This is not legal advice.',
     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 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.',
@@ -513,9 +508,11 @@ function checkContrastSignal(tokens) {
     // (designers choose the higher-contrast pairing).
     const actionVal = tokens['--action'];
     const onActionVal = tokens['--on-action'];
+    // The page under a translucent fill is --paper; a translucent label sits on the fill.
+    const pageRgb = resolveTokenColor(tokens['--paper'] || '', tokens, null);
     if (actionVal && onActionVal) {
-        const fillRgb = resolveColor(actionVal, tokens);
-        const labelRgb = resolveColor(onActionVal, tokens);
+        const fillRgb = resolveTokenColor(actionVal, tokens, pageRgb);
+        const labelRgb = fillRgb ? resolveTokenColor(onActionVal, tokens, fillRgb) : null;
         if (!fillRgb || !labelRgb)
             return { id: 'v22', item: 'Primary button text passes WCAG AA contrast against --signal fill', category: 'accessibility', status: 'SKIP', detail: `--action ${actionVal} or --on-action ${onActionVal} unresolvable to RGB` };
         const pairRatio = contrastRatio(labelRgb, fillRgb);
@@ -529,12 +526,12 @@ function checkContrastSignal(tokens) {
     const signalVal = tokens['--signal'];
     if (!signalVal)
         return { id: 'v22', item: 'Primary button text passes WCAG AA contrast against --signal fill', category: 'accessibility', status: 'WARN', detail: '--signal accent token not declared' };
-    const signalRgb = resolveColor(signalVal, tokens);
+    const signalRgb = resolveTokenColor(signalVal, tokens, pageRgb);
     if (!signalRgb)
         return { id: 'v22', item: 'Primary button text passes WCAG AA contrast against --signal fill', category: 'accessibility', status: 'SKIP', detail: `--signal value ${signalVal} unresolvable to RGB` };
     const candidates = [
-        { name: '--paper', rgb: resolveColor(tokens['--paper'] || '', tokens) },
-        { name: '--ink', rgb: resolveColor(tokens['--ink'] || '', tokens) },
+        { name: '--paper', rgb: resolveTokenColor(tokens['--paper'] || '', tokens, signalRgb) },
+        { name: '--ink', rgb: resolveTokenColor(tokens['--ink'] || '', tokens, signalRgb) },
     ];
     let bestRatio = 0;
     let bestName = '';
@@ -560,14 +557,20 @@ function checkContrastSignal(tokens) {
 // Computes both WCAG 2.1 ratio (the scoring standard) AND APCA Lc (the
 // WCAG 3 candidate, polarity-aware). APCA is supplementary — it does not
 // change pass/fail, but surfaces dark-mode contrast issues WCAG 2.1 misses.
+//
+// Where a stylesheet declares --muted-foreground, that is the muted text
+// measured: in the shadcn convention --muted is a surface and
+// --muted-foreground the text on it. Engine 1.3.0 reads oklch() (see
+// resolveTokenColor), so without this every default shadcn theme would
+// measure its --muted surface as text, at about 1.1:1, and FAIL.
 function checkContrastReadable(tokens) {
     const paperVal = tokens['--paper'];
     if (!paperVal)
         return { id: 'v06', item: 'Contrast remains readable for ink, muted, and accent on paper', category: 'accessibility', status: 'SKIP', detail: '--paper not declared: cannot test contrast' };
-    const paperRgb = resolveColor(paperVal, tokens);
+    const paperRgb = resolveTokenColor(paperVal, tokens, null);
     if (!paperRgb)
         return { id: 'v06', item: 'Contrast remains readable for ink, muted, and accent on paper', category: 'accessibility', status: 'SKIP', detail: `--paper value ${paperVal} unresolvable to RGB` };
-    const textTokens = ['--ink', '--muted', '--muted-dim'];
+    const textTokens = ['--ink', tokens['--muted-foreground'] ? '--muted-foreground' : '--muted', '--muted-dim'];
     const results = [];
     let worst = { name: '', ratio: Infinity, status: 'PASS' };
     for (const name of textTokens) {
@@ -576,7 +579,7 @@ function checkContrastReadable(tokens) {
             results.push(`${name}: not declared`);
             continue;
         }
-        const rgb = resolveColor(val, tokens);
+        const rgb = resolveTokenColor(val, tokens, paperRgb);
         if (!rgb) {
             results.push(`${name}: unresolvable`);
             continue;
@@ -1300,15 +1303,61 @@ function classifyColorToken(name) {
         return 'hue';
     return 'neutral';
 }
+/**
+ * The color tokens v42 and v43 read, and the palette layer among them
+ * (engine 1.3.0).
+ *
+ * A token is a color token when its value is written as a color, or when,
+ * with var() aliases followed through the token set, it is one. Until 1.3.0 only a literal counted, so a
+ * role token that aliases a primitive (--error: var(--red-700), the structure
+ * v42's own remediation recommends) was dropped before classification and the
+ * verdict inverted: a site that did what the check asks scored worse.
+ *
+ * The palette layer is every hue-named color token that a role-named token
+ * reaches through its aliases. That is the two-tier structure the token
+ * standards describe: DTCG 2025.10 §3.8 defines an alias as a token whose
+ * value references another (its example is $color-text-primary aliasing
+ * $color-palette-black); Spectrum's primitive tokens "are typically used
+ * indirectly through semantic tokens as an alias"; Primer's base tokens are
+ * "generally used as a reference for functional tokens"; Material's reference
+ * tokens hold the concrete values that system tokens give roles to. A palette
+ * used that way is not a hue vocabulary, so it leaves v42's denominator. A
+ * hue-named token that no role token reaches is consumed directly, or not at
+ * all, and still counts against the role share.
+ */
+function colorTokenTiers(tokens) {
+    const refs = (value) => [...value.matchAll(/var\(\s*(--[\w-]+)/g)].map((m) => m[1]);
+    // A value written as a color counts as one, as before 1.3.0, even when its
+    // var() cannot be followed (hsl(var(--x)) whose --x refers back to itself);
+    // anything else counts when its aliases resolve to a color.
+    const color = Object.keys(tokens).filter((name) => {
+        if (isColorValue(tokens[name]))
+            return true;
+        const resolved = substituteCssVars(tokens[name], [tokens]);
+        return resolved !== null && isColorValue(resolved);
+    });
+    const reached = new Set();
+    const queue = color.filter((name) => classifyColorToken(name) === 'role').flatMap((name) => refs(tokens[name]));
+    while (queue.length > 0) {
+        const name = queue.pop();
+        if (reached.has(name) || !Object.prototype.hasOwnProperty.call(tokens, name))
+            continue;
+        reached.add(name);
+        queue.push(...refs(tokens[name]));
+    }
+    return { color, palette: new Set(color.filter((name) => reached.has(name) && classifyColorToken(name) === 'hue')) };
+}
 function checkSemanticColorVocabulary(tokens) {
     const item = 'Semantic color vocabulary: tokens named by role rather than hue';
-    const colorTokens = Object.entries(tokens).filter(([, v]) => isColorValue(v));
-    if (colorTokens.length < 4) {
-        return { id: 'v42', item, category: 'semantic', status: 'SKIP', detail: `too few color tokens to assess (${colorTokens.length})` };
+    const { color, palette } = colorTokenTiers(tokens);
+    if (color.length < 4) {
+        return { id: 'v42', item, category: 'semantic', status: 'SKIP', detail: `too few color tokens to assess (${color.length})` };
     }
     let role = 0;
     let hue = 0;
-    for (const [name] of colorTokens) {
+    for (const name of color) {
+        if (palette.has(name))
+            continue;
         const c = classifyColorToken(name);
         if (c === 'role')
             role++;
@@ -1317,22 +1366,26 @@ function checkSemanticColorVocabulary(tokens) {
     }
     const named = role + hue;
     if (named === 0) {
-        return { id: 'v42', item, category: 'semantic', status: 'SKIP', detail: `${colorTokens.length} color tokens, all neutrally named: vocabulary unclassifiable` };
+        return { id: 'v42', item, category: 'semantic', status: 'SKIP', detail: `${color.length} color tokens, all neutrally named: vocabulary unclassifiable` };
     }
     const share = Math.round((role / named) * 100);
+    const layer = palette.size > 0 ? `; ${palette.size} hue-named primitive(s) that role tokens alias are the palette layer, not counted` : '';
     if (role >= 3 && share >= 60) {
-        return { id: 'v42', item, category: 'semantic', status: 'PASS', detail: `${role} role-named vs ${hue} hue-named color tokens (${share}% role share): colors are named by role` };
+        return { id: 'v42', item, category: 'semantic', status: 'PASS', detail: `${role} role-named vs ${hue} hue-named color tokens (${share}% role share): colors are named by role${layer}` };
     }
-    return { id: 'v42', item, category: 'semantic', status: 'WARN', detail: `${role} role-named vs ${hue} hue-named color tokens (${share}% role share): color vocabulary leans on hue names` };
+    return { id: 'v42', item, category: 'semantic', status: 'WARN', detail: `${role} role-named vs ${hue} hue-named color tokens (${share}% role share): color vocabulary leans on hue names${layer}` };
 }
+// v43 reads the same color tokens as v42, aliases followed, so --error:
+// var(--red-700) is an error family. The palette layer needs no exclusion
+// here: v43 counts families, and a hue-named primitive is never one.
 function checkSemanticStatusRoles(tokens) {
     const item = 'Semantic status colors: ok/warn/error/info state roles present';
-    const colorTokens = Object.entries(tokens).filter(([, v]) => isColorValue(v));
-    if (colorTokens.length === 0) {
+    const { color } = colorTokenTiers(tokens);
+    if (color.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) {
+    for (const name of color) {
         const segments = name.toLowerCase().split(/[-_]/);
         if (segments.some((s) => ['ok', 'success', 'pass', 'positive'].includes(s)))
             families.ok = true;
@@ -1725,7 +1778,9 @@ function parseCssColor(input, dark, depth = 0) {
         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])
+    // Own keys only: 'constructor' or 'toString' as a value read Object.prototype
+    // and threw, which failed the whole score (engine 1.3.0 reads token values here).
+    if (Object.prototype.hasOwnProperty.call(CSS_NAMED_COLORS, v))
         return [...CSS_NAMED_COLORS[v]];
     const fn = /^([a-z-]+)\(([\s\S]*)\)$/.exec(v);
     if (!fn)
@@ -2966,17 +3021,25 @@ function checkPausedEntrances(css) {
         },
     };
 }
-// v34 — AI-Disclosure Readiness (EU AI Act Article 50, effective 2026-08-02).
-// Static-only v1: scans fetched HTML for AI-interactive surfaces (chatbots,
-// AI agents, AI-generated content) and disclosure signals (visible labels,
-// aria-label, C2PA meta, generator meta, JSON-LD, data-ai-disclosure).
-// Four conditions:
-//   A — no AI surface detected → PASS (disclosure not required)
-//   B — AI surface + disclosure signal → PASS
-//   C — AI surface + NO disclosure → FAIL (Art 50 violation)
-//   D — uncertain (possible AI surface) → WARN (manual review)
-// Green-field check: no competitor (Mozaika, Lighthouse, axe, WAVE, DESIGN.md)
-// has an AI-disclosure check. Designesy can be first.
+// v34 — AI-Disclosure Readiness (EU AI Act Article 50, which applies from
+// 2026-08-02). Static, from the fetched HTML: it looks for an AI chat surface
+// and for a disclosure signal (visible text, aria-label, data-ai-disclosure,
+// generator meta, C2PA, JSON-LD).
+//
+// Article 50(1) puts the duty on the PROVIDER of an AI system that talks with
+// people: they must be told it is an AI, unless that is obvious from the
+// context, at the latest at the first interaction (50(5)). A site that embeds
+// a vendor's assistant may not be that provider, so the check says "may
+// require", never "requires", and it is not a legal finding.
+//
+// Only a positively identified AI chat surface with no disclosure FAILs: a
+// container or input that names itself a chatbot or an AI assistant, or a
+// script from a chatbot, AI-widget or Dialogflow path. Anything weaker WARNs
+// "possible AI surface: review": live-chat vendors (Intercom, Drift, Zendesk,
+// LiveChat, Tawk, Crisp), which are often answered by people; a generic chat
+// container or an "assistant" script; page text about AI, which is not a chat
+// surface. Until engine 1.3.0 those FAILed, and so did Google Publisher Tag,
+// an ad tag, because its gpt.js matched the word "gpt".
 function checkAiDisclosure(html) {
     const ITEM = 'AI-Disclosure Readiness (EU AI Act Art 50, effective 2026-08-02)';
     const CATEGORY = 'identity';
@@ -2989,20 +3052,31 @@ function checkAiDisclosure(html) {
     // false-positive as disclosure TEXT. Disclosure text must be human-readable
     // content between tags, not class/id/aria attribute values.
     const textOnly = visibleHtml.replace(/<[^>]+>/g, ' ');
-    // ── AI-surface detection ────────────────────────────────────────────────
-    const chatbotContainerRe = /<(?:iframe|div|section|aside)\b[^>]*(?:class|id)\s*=\s*["'][^"']*\b(?:chatbot|chat-bot|ai-assistant|ai_chat|assistant-widget|intercom|drift|zendesk-chat|tawk(?:\.to)?|crisp\.chat|livechat|chat-widget|chat-container)\b/i;
-    const aiScriptRe = /<script\b[^>]*src\s*=\s*["'][^"']*\b(?:chatbot|assistant|ai-widget|gpt|claude|gemini|dialogflow|rasa|intercom|drift|tawk|crisp|livechat|chatbot\.ai|conversational)\b/i;
-    const aiTextRe = /\b(?:chat\s*with\s*(?:ai|our\s*bot|ai\s*assistant)|ask\s+ai|ai\s+assistant|talk\s+to\s+(?:our\s+)?bot|powered\s+by\s+ai|ai-generated|ai\s+chatbot|virtual\s+assistant)\b/i;
+    // ── AI chat surfaces, positively identified ─────────────────────────────
+    const aiContainerRe = /<(?:iframe|div|section|aside)\b[^>]*(?:class|id)\s*=\s*["'][^"']*\b(?:chatbot|chat-bot|ai-assistant|ai_chat)\b/i;
+    const aiScriptRe = /<script\b[^>]*src\s*=\s*["'][^"']*\b(?:chatbot|ai-widget|dialogflow)\b/i;
     const aiInputRe = /<(?:input|textarea|form)\b[^>]*(?:placeholder|aria-label)\s*=\s*["'][^"']*\b(?:ask\s+ai|message\s+ai|chat\s+with\s+ai|ai\s+assistant)\b/i;
+    // ── Possible AI surfaces: a review item, never a FAIL ───────────────────
+    const chatContainerRe = /<(?:iframe|div|section|aside)\b[^>]*(?:class|id)\s*=\s*["'][^"']*\b(?:assistant-widget|intercom|drift|zendesk-chat|tawk(?:\.to)?|crisp\.chat|livechat|chat-widget|chat-container)\b/i;
+    const chatScriptRe = /<script\b[^>]*src\s*=\s*["'][^"']*\b(?:assistant|claude|gemini|rasa|intercom|drift|tawk|crisp|livechat|conversational)\b/i;
+    const aiTextRe = /\b(?:chat\s*with\s*(?:ai|our\s*bot|ai\s*assistant)|ask\s+ai|ai\s+assistant|talk\s+to\s+(?:our\s+)?bot|powered\s+by\s+ai|ai-generated|ai\s+chatbot|virtual\s+assistant)\b/i;
+    const ambiguousRe = /<(?:iframe|div|section)\b[^>]*(?:class|id)\s*=\s*["'][^"']*\b(?:contact-widget|smart-search|virtual-agent|message-us|help-widget)\b/i;
     const surfaceSignals = [];
-    if (chatbotContainerRe.test(html))
+    if (aiContainerRe.test(html))
         surfaceSignals.push('chatbot container');
     if (aiScriptRe.test(html))
         surfaceSignals.push('AI widget script');
-    if (aiTextRe.test(textOnly))
-        surfaceSignals.push('AI prompt text');
     if (aiInputRe.test(html))
         surfaceSignals.push('AI input');
+    const possibleSignals = [];
+    if (chatContainerRe.test(html))
+        possibleSignals.push('chat widget container');
+    if (chatScriptRe.test(html))
+        possibleSignals.push('chat or assistant script');
+    if (aiTextRe.test(textOnly))
+        possibleSignals.push('AI prompt text');
+    if (ambiguousRe.test(html))
+        possibleSignals.push('ambiguous widget');
     // ── Disclosure detection ────────────────────────────────────────────────
     const disclosureTextRe = /\b(?:ai\s+assistant|ai\s+chatbot|ai-powered|powered\s+by\s+ai|automated\s+assistant|virtual\s+assistant|chatbot)\b/i;
     const ariaDisclosureRe = /aria-(?:label|description)\s*=\s*["'][^"']*\b(?:ai|assistant|bot|automated|chatbot)\b/i;
@@ -3024,17 +3098,17 @@ function checkAiDisclosure(html) {
     if (dataAiRe.test(html))
         disclosureSignals.push('data-ai-disclosure');
     // ── Condition evaluation ────────────────────────────────────────────────
-    if (surfaceSignals.length === 0) {
-        const ambiguousRe = /<(?:iframe|div|section)\b[^>]*(?:class|id)\s*=\s*["'][^"']*\b(?:contact-widget|smart-search|virtual-agent|message-us|help-widget)\b/i;
-        if (ambiguousRe.test(html)) {
-            return { id: 'v34', item: ITEM, category: CATEGORY, status: 'WARN', detail: 'possible AI-interactive surface (ambiguous widget): manual review recommended for Art 50 compliance' };
-        }
+    if (surfaceSignals.length === 0 && possibleSignals.length === 0) {
         return { id: 'v34', item: ITEM, category: CATEGORY, status: 'PASS', detail: 'no AI-interactive surface detected: disclosure not required' };
     }
     if (disclosureSignals.length > 0) {
-        return { id: 'v34', item: ITEM, category: CATEGORY, status: 'PASS', detail: `AI surface detected (${surfaceSignals.join(', ')}); disclosure present (${disclosureSignals.join(', ')})` };
+        const found = surfaceSignals.length > 0 ? `AI surface detected (${surfaceSignals.join(', ')})` : `possible AI surface (${possibleSignals.join(', ')})`;
+        return { id: 'v34', item: ITEM, category: CATEGORY, status: 'PASS', detail: `${found}; disclosure present (${disclosureSignals.join(', ')})` };
+    }
+    if (surfaceSignals.length > 0) {
+        return { id: 'v34', item: ITEM, category: CATEGORY, status: 'FAIL', detail: `AI chat surface detected (${surfaceSignals.join(', ')}) and no AI disclosure found: EU AI Act Art. 50(1) may require telling people at their first interaction that they are talking to an AI (a duty on the AI system's provider, applying from 2026-08-02)` };
     }
-    return { id: 'v34', item: ITEM, category: CATEGORY, status: 'FAIL', detail: `AI-interactive surface detected (${surfaceSignals.join(', ')}) but no disclosure found: EU AI Act Art 50(1) requires disclosure at first interaction` };
+    return { id: 'v34', item: ITEM, category: CATEGORY, status: 'WARN', detail: `possible AI surface (${possibleSignals.join(', ')}): review. If it is an AI system and no disclosure is shown, EU AI Act Art. 50(1) may require one (a duty on the AI system's provider); a chat answered by people needs none` };
 }
 // v35 — Forced-colors readiness (Windows High Contrast Mode / Chrome forced-colors).
 // Verifies the site has a @media (forced-colors: active) block, ideally with
@@ -3936,9 +4010,25 @@ function scoreArithmetic(checks, slopTotal, originalityPoints) {
     // 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).
+    //
+    // No A while any check FAILs (engine 1.3.0, owner decision 2026-10-11). A
+    // FAIL is the engine's own finding that the page breaks a rule, so any FAIL
+    // caps the score at 89.9, a B at most. Until 1.3.0 a page could score 100, an
+    // A, beside FAIL verdicts, including the engine's own WCAG contrast FAIL
+    // (v44). The specific ceilings below are lower and win where they apply.
+    // Every cap here runs after the originality lift, so the lift can carry a
+    // score up to a cap but never past one.
     const hardFailChecks = checks.filter((c) => c.status === 'FAIL');
     let hardFailCeilingApplied = false;
     let hardFailCeilingReason = null;
+    const ANY_FAIL_CAP = 89.9;
+    if (hardFailChecks.length > 0 && score > ANY_FAIL_CAP) {
+        const ids = hardFailChecks.map((c) => c.id);
+        const named = ids.length === 1 ? `${ids[0]} fails` : `${ids.slice(0, -1).join(', ')} and ${ids[ids.length - 1]} fail`;
+        score = ANY_FAIL_CAP;
+        hardFailCeilingApplied = true;
+        hardFailCeilingReason = `A FAIL caps the grade at B: ${named}, and the score cannot exceed 89.9 while any check fails.`;
+    }
     for (const c of hardFailChecks) {
         let cap = null;
         let reason = null;
@@ -3947,6 +4037,14 @@ function scoreArithmetic(checks, slopTotal, originalityPoints) {
             cap = 65;
             reason = 'Contrast below WCAG minimum: text is unreadable for many users.';
         }
+        // v44 Status text contrast — the words that report a state fail WCAG
+        // 1.4.3 (or 1.4.11 for a graphic) on a surface the stylesheet attests.
+        // Same cap as v06 (engine 1.3.0, owner decision 2026-10-11): both are
+        // measured WCAG contrast failures on text.
+        if (c.id === 'v44') {
+            cap = 65;
+            reason = 'Status text below WCAG contrast (4.5:1, or 3:1 for large text and graphics): the words that report errors, warnings and success are hard to read.';
+        }
         // v22 Contrast signal — CTA text unreadable on brand color
         if (c.id === 'v22') {
             cap = 70;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@designesy/score",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "Standalone 44-check design-contract scoring engine: fetches a URL, extracts CSS + tokens, and runs all checks locally. No required dependencies.",
   "license": "MIT",
   "author": "Designesy <hello@designesy.org>",