pour-engine 1.33.0 → 1.34.0

package/engine/rules/wcag/1.4.1-link-in-text-block.js

@@ -1,5 +1,112 @@
 // WCAG SC 1.4.1 Use of Color (Level A)
-import { parseColor, contrastRatio } from '../../lib/contrast.js';
+import { parseColor, contrastRatio, composite, effectiveBackground, backgroundImageSource } from '../../lib/contrast.js';
+
+// Split a computed list value ("a, b(c, d), e") on the commas OUTSIDE
+// parentheses: gradients and colour functions carry commas of their own.
+const splitList = (value) => (value ?? '').split(/,(?![^(]*\))/).map((part) => part.trim());
+
+const SIDES = ['Top', 'Right', 'Bottom', 'Left'];
+
+// A border side paints only when it has width, a style and a visible
+// colour. 2026-08-25 overnight audit: "border-bottom: 1px solid transparent"
+// is the reveal-on-hover idiom and paints nothing at rest, and F73 says a cue
+// "only provided on hover" still fails, so alpha is required here exactly as
+// the background test already required it.
+const sidePaints = (s, side) => parseFloat(s[`border${side}Width`]) > 0
+  && s[`border${side}Style`] !== 'none'
+  && (parseColor(s[`border${side}Color`])?.a ?? 0) > 0;
+
+// A box-shadow paints only when some layer has a visible colour and a
+// non-zero geometry: "0 0 0 0 currentColor" and a fully transparent shadow
+// are the same hover-reveal idiom as the transparent border (2026-08-25
+// overnight audit). Chrome's computed value reads "rgb(a)(...) x y blur
+// spread [inset]" per layer.
+function boxShadowPaints(boxShadow) {
+  if (!boxShadow || boxShadow === 'none') return false;
+  return splitList(boxShadow).some((layer) => {
+    const colorText = layer.match(/[a-z-]+\([^)]*\)/)?.[0];
+    const color = colorText ? parseColor(colorText) : null;
+    if (color && color.a === 0) return false;
+    const lengths = layer.replace(colorText ?? '', '').match(/-?[\d.]+(?=px)/g) ?? [];
+    return !(lengths.length && lengths.every((n) => parseFloat(n) === 0));
+  });
+}
+
+// Does a background-image paint anything at rest? 'no' when every layer is
+// sized to nothing (the "background-size: 0 1px, grown on hover" underline
+// idiom, 2026-08-25 overnight audit), 'unclear' when a no-repeat layer is
+// parked outside the box so its resting geometry cannot be settled from
+// computed style, 'yes' otherwise.
+function backgroundImagePaints(s, rect) {
+  if (!s.backgroundImage || s.backgroundImage === 'none') return 'no';
+  const images = splitList(s.backgroundImage);
+  const sizes = splitList(s.backgroundSize);
+  const repeats = splitList(s.backgroundRepeat);
+  const positions = splitList(s.backgroundPosition);
+  let verdict = 'no';
+  images.forEach((image, i) => {
+    if (image === 'none') return;
+    const size = sizes[i % sizes.length] || 'auto';
+    if (/(^|\s)0(px|%)?(\s|$)/.test(size)) return; // a zero dimension paints nothing
+    const repeat = repeats[i % repeats.length] || 'repeat';
+    const position = positions[i % positions.length] || '0% 0%';
+    if (repeat.includes('no-repeat')) {
+      const outside = position.split(/\s+/).some((component, axis) => {
+        const n = parseFloat(component);
+        if (Number.isNaN(n)) return false;
+        if (component.endsWith('%')) return n < 0 || n > 100;
+        const extent = axis === 0 ? rect?.width : rect?.height;
+        return n < 0 || (Number.isFinite(extent) && n > extent);
+      });
+      if (outside) { if (verdict === 'no') verdict = 'unclear'; return; }
+    }
+    verdict = 'yes';
+  });
+  return verdict;
+}
+
+// Read one ::before / ::after box on the link. 2026-08-25 overnight audit:
+// querySelectorAll never yields pseudo-elements, so the everyday "custom
+// underline" (an absolutely positioned 2px bar in ::after) was invisible to
+// this rule. Returns 'cue' when the pseudo provably paints a shape at rest,
+// 'glyph' when it draws text or an icon (a judgment by eye), 'unclear' when
+// it paints something whose box computed style cannot measure, and null when
+// it paints nothing (no content, collapsed by scaleX(0), zero box, hidden).
+function pseudoCue(element, which) {
+  let p;
+  try { p = getComputedStyle(element, which); } catch { return null; }
+  const content = p.content;
+  if (!content || content === 'none' || content === 'normal' || p.display === 'none') return null;
+  if (p.visibility !== 'visible' || parseFloat(p.opacity) === 0) return null;
+  const matrix = (p.transform ?? 'none').match(/^matrix(3d)?\((.*)\)$/);
+  if (matrix) {
+    const n = matrix[2].split(',').map(parseFloat);
+    const [a, b, c, d] = matrix[1] ? [n[0], n[1], n[4], n[5]] : n;
+    if ((a === 0 && b === 0) || (c === 0 && d === 0)) return null; // scaleX(0) / scaleY(0): grown on hover
+  }
+  const width = parseFloat(p.width);
+  const height = parseFloat(p.height);
+  const glyph = (/^["'].+["']$/s.test(content) && parseFloat(p.fontSize) > 0)
+    || /^(url|counter|counters|attr|image-set)\(/.test(content);
+  const paintedBackground = (parseColor(p.backgroundColor)?.a ?? 0) > 0
+    || backgroundImagePaints(p, Number.isNaN(width) ? null : { width, height }) === 'yes';
+  const paintedBorder = SIDES.some((side) => sidePaints(p, side));
+  if (paintedBackground || paintedBorder) {
+    if (Number.isNaN(width) || Number.isNaN(height)) return glyph ? 'glyph' : 'unclear';
+    const extra = (edges) => edges.reduce((sum, edge) => sum + (parseFloat(p[edge]) || 0), 0);
+    const boxWidth = width + extra(['paddingLeft', 'paddingRight', 'borderLeftWidth', 'borderRightWidth']);
+    const boxHeight = height + extra(['paddingTop', 'paddingBottom', 'borderTopWidth', 'borderBottomWidth']);
+    if (boxWidth > 0 && boxHeight > 0) return 'cue';
+  }
+  if (glyph) {
+    // A 1px clip box is the sr-only pattern: text for a screen reader, not a glyph anyone sees.
+    if (!Number.isNaN(width) && !Number.isNaN(height) && width <= 1 && height <= 1) return null;
+    return 'glyph';
+  }
+  return null;
+}
+
+const GRAPHIC = 'svg, img, picture, canvas, video, object, embed';
 
 export default {
   id: 'link-in-text-block',
@@ -28,28 +135,51 @@ export default {
     const style = getComputedStyle(element);
     const parentStyle = getComputedStyle(parent);
     const weight = (s) => parseInt(s.fontWeight, 10) || 400;
+    const slanted = (s) => /italic|oblique/.test(s.fontStyle ?? '');
+    const parentSize = parseFloat(parentStyle.fontSize) || 16;
     // A cue counts wherever it is painted: sites routinely reset
     // text-decoration on the anchor and underline (or embolden) an inner
     // span that carries the text, so every visible text-bearing element in
     // the link vouches, not just the anchor. The >1px rect floor keeps
     // 1×1 sr-only clip spans from vouching for a cue nobody can see.
-    const cueBearers = [style];
+    // Empty descendants with a real box (an icon font's <i>, a decorative
+    // span) vouch for painted shapes only, never for text properties.
+    const cueBearers = [{ s: style, el: element, text: true }];
+    // 2026-08-25 overnight audit: a rendered graphic inside the link (an
+    // external-link arrow, a chevron, a download icon) is "some other means"
+    // in F73's words, but whether it reads as part of the link is a judgment
+    // by eye, so it demotes a colour-only verdict to review, never to pass.
+    let graphic = false;
     for (const el of element.querySelectorAll('*')) {
-      if (!el.textContent.trim()) continue;
-      if ([...el.getClientRects()].some((r) => r.width > 1 && r.height > 1)) cueBearers.push(getComputedStyle(el));
+      const rects = [...el.getClientRects()].filter((r) => r.width > 1 && r.height > 1);
+      if (!rects.length) continue;
+      if (el.matches(GRAPHIC)) {
+        if (rects.some((r) => r.width >= 4 && r.height >= 4)) graphic = true;
+        continue;
+      }
+      if (el.closest(GRAPHIC)) continue; // svg internals
+      cueBearers.push({ s: getComputedStyle(el), el, text: !!el.textContent.trim() });
     }
-    for (const s of cueBearers) {
-      if ((s.textDecorationLine ?? s.textDecoration ?? '').includes('underline')) return { status: 'pass' };
+    let unclear = false;
+    for (const { s, el, text } of cueBearers) {
+      if (text && (s.textDecorationLine ?? s.textDecoration ?? '').includes('underline')) return { status: 'pass' };
       // Underline substitutes count as non-colour cues too: border-bottom
       // "underlines", box-shadow underlines, and background chips/pills all
       // mark the link by shape, not colour alone.
-      if (parseFloat(s.borderBottomWidth) > 0 && s.borderBottomStyle !== 'none') return { status: 'pass' };
-      if (s.boxShadow && s.boxShadow !== 'none') return { status: 'pass' };
+      if (sidePaints(s, 'Bottom')) return { status: 'pass' };
+      if (boxShadowPaints(s.boxShadow)) return { status: 'pass' };
       const ownBackground = parseColor(s.backgroundColor);
       if (ownBackground && ownBackground.a > 0) return { status: 'pass' };
-      if (s.backgroundImage !== 'none') return { status: 'pass' }; // gradient/image underline technique
+      const painted = backgroundImagePaints(s, el.getBoundingClientRect()); // gradient/image underline technique
+      if (painted === 'yes') return { status: 'pass' };
+      if (painted === 'unclear') unclear = true;
+      if (!text) continue;
       // A clear weight difference is a non-colour distinction too.
       if (Math.abs(weight(s) - weight(parentStyle)) >= 300) return { status: 'pass' };
+      // 2026-08-25 overnight audit: F73's own list of other means names
+      // "italicized" without qualification, so italic or oblique against
+      // upright prose (either way round) is a cue in its own right.
+      if (slanted(s) !== slanted(parentStyle)) return { status: 'pass' };
     }
     // A weight step of 200–299 (600-semibold links in 400 prose, the common
     // case) is a REAL non-colour cue, just not a clear one: whether it reads
@@ -59,11 +189,44 @@ export default {
     // passing waves through faces where the step is invisible — so it goes
     // to review. Below 200 the step is imperceptible at body sizes and earns
     // nothing.
-    const weightStep = Math.max(...cueBearers.map((s) => Math.abs(weight(s) - weight(parentStyle))));
+    const textBearers = cueBearers.filter((b) => b.text).map((b) => b.s);
+    const weightStep = Math.max(...textBearers.map((s) => Math.abs(weight(s) - weight(parentStyle))));
+    // G182 also names "changes to the font size" as a cue. How large a step
+    // reads as one is a judgment by eye, so a step of at least 2px and a
+    // tenth of the prose size goes to the same review band as semibold
+    // (2026-08-25 overnight audit).
+    const sizeStep = Math.max(...textBearers.map((s) => Math.abs((parseFloat(s.fontSize) || parentSize) - parentSize)));
+    const sizeCue = sizeStep >= 2 && sizeStep / parentSize >= 0.1;
 
-    const linkColor = parseColor(style.color);
-    const textColor = parseColor(parentStyle.color);
+    let linkColor = parseColor(style.color);
+    let textColor = parseColor(parentStyle.color);
     if (!linkColor || !textColor) return { status: 'pass' };
+    // 2026-08-25 overnight audit: a translucent colour is presented
+    // composited over its backdrop (rgba(0,0,0,.3) in black prose on white
+    // is a light grey, about 10:1 from the prose), and G183's ratio is a
+    // property of the colours as presented. Composite both sides over the
+    // effective background before the equality test and the ratio; over an
+    // image there is no colour to composite against, so abstain.
+    if ((linkColor.a ?? 1) < 1 || (textColor.a ?? 1) < 1) {
+      if (backgroundImageSource(element)) {
+        return {
+          status: 'incomplete',
+          message: 'This link has no underline and its colour is translucent over a background image or gradient, so its colour difference from the surrounding text depends on the pixels behind it. Check by eye that something other than colour identifies it as a link.',
+          fix: 'Underline links inside text (text-decoration: underline), or add a non-colour indicator.',
+        };
+      }
+      const backdrop = effectiveBackground(element);
+      if (!backdrop) {
+        return {
+          status: 'incomplete',
+          message: 'This link has no underline and its colour is translucent, but the background it composites over could not be determined. Check by eye that something other than colour identifies it as a link.',
+          fix: 'Underline links inside text (text-decoration: underline), or add a non-colour indicator.',
+        };
+      }
+      const over = (color) => ((color.a ?? 1) < 1 ? composite(color, backdrop) : color);
+      linkColor = over(linkColor);
+      textColor = over(textColor);
+    }
 
     // A link styled to look NO different from the surrounding prose is not
     // a 1.4.1 failure — Understanding 1.4.1, in its own words: "a hyperlink
@@ -77,9 +240,10 @@ export default {
     // Channel equality, NOT the luminance ratio: a hue-only difference at
     // equal luminance also lands at 1.00:1, and that is the clearest F73
     // failure there is — the two cases are opposites and the ratio cannot
-    // tell them apart.
-    if (linkColor.r === textColor.r && linkColor.g === textColor.g
-      && linkColor.b === textColor.b && (linkColor.a ?? 1) === (textColor.a ?? 1)) {
+    // tell them apart. (Compared after compositing, so both sides are the
+    // opaque colours actually presented.)
+    const same = (x, y) => Math.round(x) === Math.round(y);
+    if (same(linkColor.r, textColor.r) && same(linkColor.g, textColor.g) && same(linkColor.b, textColor.b)) {
       return { status: 'pass' };
     }
 
@@ -88,6 +252,26 @@ export default {
     // colour difference for identifying a link.
     if (ratio >= 3) return { status: 'pass' };
 
+    // 2026-08-25 overnight audit: text-decoration propagates from an
+    // ancestor to its inline descendants and a descendant's "none" cannot
+    // cancel it, so <u><a style="text-decoration:none"> is underlined. Walk
+    // up to (but excluding) the block: an ancestor that wraps only the link
+    // underlines the link; one that also wraps prose underlines the prose
+    // too and singles nothing out, so it earns nothing.
+    for (let ancestor = element.parentElement; ancestor && ancestor !== parent; ancestor = ancestor.parentElement) {
+      if (!(getComputedStyle(ancestor).textDecorationLine ?? '').includes('underline')) continue;
+      if (ancestor.textContent.replace(/\s+/g, '') === element.textContent.replace(/\s+/g, '')) return { status: 'pass' };
+      break;
+    }
+    // Generated content on the anchor: read only now, on the failing path,
+    // so passing links never pay for the two extra style reads.
+    for (const which of ['::after', '::before']) {
+      const verdict = pseudoCue(element, which);
+      if (verdict === 'cue') return { status: 'pass' };
+      if (verdict === 'glyph') graphic = true;
+      if (verdict === 'unclear') unclear = true;
+    }
+
     // LAST, because it's the expensive check (tree walk + line geometry)
     // and only failing candidates should ever pay for it: a link occupying
     // its own line (<br>-separated address blocks, one-link-per-line
@@ -116,13 +300,36 @@ export default {
       }
       if (!sharesLine) return { status: 'pass' };
     }
+    const shown = ratio.toFixed(2);
+    const reviewFix = 'Underline links inside text (text-decoration: underline), or add another clear non-colour indicator.';
+    if (graphic) {
+      return {
+        status: 'incomplete',
+        message: `This link has no underline and only ${shown}:1 colour difference from the surrounding text, but it carries an icon or image. Judge by eye whether the graphic reads as part of the link and marks it out from the prose; if it does not, this fails SC 1.4.1.`,
+        fix: reviewFix,
+      };
+    }
+    if (unclear) {
+      return {
+        status: 'incomplete',
+        message: `This link has no underline and only ${shown}:1 colour difference from the surrounding text, but a generated box or background image is painted on it whose size at rest could not be measured. Check by eye whether it draws a visible underline or shape; if nothing shows until hover, this fails SC 1.4.1.`,
+        fix: reviewFix,
+      };
+    }
     if (weightStep >= 200) {
       return {
         status: 'incomplete',
-        message: `This link has no underline and only ${ratio.toFixed(2)}:1 colour difference from the surrounding text, but its font weight differs from the prose by ${weightStep}: a visible non-colour cue that falls short of a clear bold step. Judge by eye whether the weight alone identifies it as a link in this face and size; if it does not, this fails SC 1.4.1.`,
+        message: `This link has no underline and only ${shown}:1 colour difference from the surrounding text, but its font weight differs from the prose by ${weightStep}: a visible non-colour cue that falls short of a clear bold step. Judge by eye whether the weight alone identifies it as a link in this face and size; if it does not, this fails SC 1.4.1.`,
         fix: 'Underline links inside text (text-decoration: underline), raise the weight difference to a clear bold step, or add another non-colour indicator.',
       };
     }
+    if (sizeCue) {
+      return {
+        status: 'incomplete',
+        message: `This link has no underline and only ${shown}:1 colour difference from the surrounding text, but its font size differs from the prose by ${sizeStep.toFixed(1).replace(/\.0$/, '')}px, one of the cues G182 names. Judge by eye whether the size alone identifies it as a link; if it does not, this fails SC 1.4.1.`,
+        fix: reviewFix,
+      };
+    }
     return {
       status: 'fail',
       // The measured fact is the ratio against G183's threshold, and that is
@@ -132,7 +339,7 @@ export default {
       // colour blindness, where the red darkens and the gap widens.
       message: ratio < 1.01
         ? 'This link has no underline and its colour differs from the surrounding text in hue alone, with no luminance difference: the distinction disappears entirely without colour vision, the exact failure F73 describes.'
-        : `This link has no underline and only ${ratio.toFixed(2)}:1 colour difference from the surrounding text, below the 3:1 WCAG technique G183 asks for when colour is the only thing marking a link.`,
+        : `This link has no underline and only ${shown}:1 colour difference from the surrounding text, below the 3:1 WCAG technique G183 asks for when colour is the only thing marking a link.`,
       fix: 'Underline links inside text (text-decoration: underline), or add a non-colour indicator.',
     };
   },

package/engine/rules/wcag/1.4.11-non-text-contrast.js

@@ -10,14 +10,25 @@ import { parseColor, contrastRatio, composite, effectiveBackground, showRatio }
 
 export default {
   id: 'non-text-contrast',
-  name: 'Control & icon contrast',
+  // Named for what the rule measures: field fills and borders. It never
+  // examines an icon, and the Understanding document says a boundary is not
+  // required when the field has other visible identifiers, so the old
+  // "icons need a visible boundary" wording overclaimed twice (2026-08-25
+  // overnight audit).
+  name: 'Form field boundary contrast',
   impact: 'serious',
   tags: ['wcag21aa', 'wcag1411'],
-  help: 'Form fields and icons need a 3:1 visible boundary',
+  help: 'Form field fills and borders below 3:1 need checking against the field\'s other identifiers',
   helpUrl: 'https://www.w3.org/WAI/WCAG22/Understanding/non-text-contrast.html',
+  // range and file are excluded: untouched, both are drawn by the user agent
+  // (the 1.4.11 user-agent exception), and Chrome's UA default for file is
+  // already appearance:none so the appearance test cannot tell an author
+  // restyle from the default. An author-styled range needs a track-and-thumb
+  // judgment this rule does not attempt, so the field-boundary message would
+  // be wrong for it either way (2026-08-25 overnight audit).
   selector:
     'input:not([type="hidden"]):not([type="checkbox"]):not([type="radio"]):not([type="submit"])'
-    + ':not([type="button"]):not([type="reset"]):not([type="image"]), select, textarea',
+    + ':not([type="button"]):not([type="reset"]):not([type="image"]):not([type="range"]):not([type="file"]), select, textarea',
   visibility: 'visual',
   evaluate(element) {
     // Inactive controls are exempt (same carve-out 1.4.3 makes).
@@ -56,6 +67,19 @@ export default {
       boundaries.push(color.a >= 1 ? color : composite(color, surrounding));
       if (color.a < 1) translucentSeen = true;
     }
+    // An outline drawn at rest IS a boundary: "border: none; outline: 1px
+    // solid" is used in place of a border to avoid layout shift, and a 1px
+    // black outline on white is 21:1 with nothing left to review. Same
+    // tests as a border side: width, a style, a visible colour, composited
+    // the same way (2026-08-25 overnight audit).
+    if (parseFloat(style.outlineWidth) > 0 && style.outlineStyle !== 'none') {
+      const color = parseColor(style.outlineColor);
+      if (color && color.a > 0) {
+        hasBorder = true;
+        boundaries.push(color.a >= 1 ? color : composite(color, surrounding));
+        if (color.a < 1) translucentSeen = true;
+      }
+    }
     const best = Math.max(1, ...boundaries.map((color) => contrastRatio(color, surrounding)));
     if (best >= 3) return { status: 'pass' };
     // Box-shadow outlines and background images can also draw the boundary;

package/engine/rules/wcag/1.4.2-audio-control.js

@@ -1,4 +1,17 @@
 // WCAG SC 1.4.2 Audio Control (Level A)
+// "If any audio on a Web page plays automatically for more than 3 seconds,
+// either a mechanism is available to pause or stop the audio, or a
+// mechanism is available to control audio volume independently from the
+// overall system volume level."
+//
+// The DOM proves autoplay, the absence of native controls and the length.
+// It cannot prove the two things a failure also needs: that the media has
+// an audio track at all (a video file may carry none, F93 step 1 asks for
+// "an active audio track"), and that no pause, stop or volume control
+// exists anywhere on the page (G170, a plain button near the top of the
+// page, is a sufficient technique). So an autoplaying, unmuted, control-less
+// element is a question for a human, never an assertion. (2026-08-25
+// overnight audit: the old fail was asserted without either proof.)
 export default {
   id: 'audio-control',
   name: 'Auto-playing audio control',
@@ -16,26 +29,44 @@ export default {
     if (element.muted || element.volume === 0) return { status: 'pass' };
     if (element.hasAttribute('muted') || element.hasAttribute('controls')) return { status: 'pass' };
     // The criterion applies to audio playing for MORE than 3 seconds; a
-    // short non-looping chime is exempt — but a LOOPING clip exceeds any
-    // duration by definition, so it fails without needing metadata.
-    if (element.loop) {
-      return {
-        status: 'fail',
-        message: 'This media auto-plays on a loop with no controls and no muting — its audio talks over screen readers indefinitely.',
-        fix: 'Add controls (or muted), or don’t autoplay.',
-      };
+    // short non-looping chime is exempt, but a LOOPING clip exceeds any
+    // duration by definition, so it needs no metadata.
+    if (!element.loop) {
+      if (Number.isFinite(element.duration) && element.duration <= 3) return { status: 'pass' };
+      if (!Number.isFinite(element.duration)) {
+        return {
+          status: 'incomplete',
+          message: 'This media auto-plays without controls or muting; its duration isn’t loaded yet, and only audio playing longer than 3 seconds fails 1.4.2 — check whether it has sound and how long it plays.',
+        };
+      }
     }
-    if (Number.isFinite(element.duration) && element.duration <= 3) return { status: 'pass' };
-    if (!Number.isFinite(element.duration)) {
+    const span = element.loop ? 'on a loop' : 'for more than three seconds';
+    const fix = 'Add controls (or muted), or do not autoplay. Otherwise put a pause, stop or volume control near the start of the page, before the media.';
+    if (element.tagName === 'VIDEO') {
+      // A video without a soundtrack cannot fail an audio criterion, and the
+      // markup does not say whether one exists. Chromium counts decoded
+      // audio bytes: a count still at zero after a second of playback is
+      // evidence there is nothing to hear; a positive count proves sound.
+      const decoded = element.webkitAudioDecodedByteCount;
+      const started = !element.paused && !element.ended && element.currentTime >= 1;
+      if (started && decoded === 0) return { status: 'pass' };
+      if (decoded > 0) {
+        return {
+          status: 'incomplete',
+          message: `This video auto-plays with sound ${span}, with no controls and no muting, so its audio talks over a screen reader unless the page offers a way to stop it. Check for a pause, stop or volume control near the top of the page; if there is none, 1.4.2 is not met.`,
+          fix,
+        };
+      }
       return {
         status: 'incomplete',
-        message: 'This media auto-plays without controls or muting; its duration isn’t loaded yet, and only audio playing longer than 3 seconds fails 1.4.2 — check whether it has sound and how long it plays.',
+        message: `This video auto-plays ${span} with no controls and no muting. If this video has a soundtrack, its audio talks over a screen reader unless the page offers a way to stop it. Check whether it has sound and, if so, that a pause, stop or volume control sits near the top of the page.`,
+        fix,
       };
     }
     return {
-      status: 'fail',
-      message: 'This media auto-plays with no controls and no muting — its audio talks over screen readers.',
-      fix: 'Add controls (or muted), or don’t autoplay.',
+      status: 'incomplete',
+      message: `This audio auto-plays ${span} with no controls and no muting, so it talks over a screen reader unless the page offers a way to stop it. Check for a pause, stop or volume control near the top of the page; if there is none, 1.4.2 is not met.`,
+      fix,
     };
   },
 };