@surea11y/core 1.3.0 → 1.4.0

package/src/checks/manual/css-hidden-focus.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -194,6 +196,163 @@ function runInPage(ctx) {
     }
   }
 
+  function getDeepActiveElement(docRef) {
+    let cur = docRef && docRef.activeElement ? docRef.activeElement : null;
+    let guard = 0;
+    while (cur && cur.shadowRoot && cur.shadowRoot.activeElement && guard++ < 20) {
+      cur = cur.shadowRoot.activeElement;
+    }
+    return cur;
+  }
+
+  function focusElementSafe(el) {
+    if (!el || typeof el.focus !== 'function') return false;
+    try {
+      el.focus({ preventScroll: true });
+      return true;
+    } catch {
+      try {
+        el.focus();
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  }
+
+  function runFocusObservationWindow(docRef, fn) {
+    const w =
+      docRef && docRef.defaultView
+        ? docRef.defaultView
+        : typeof window !== 'undefined'
+          ? window
+          : null;
+    if (!w || typeof fn !== 'function') return;
+
+    const originalSetTimeout = typeof w.setTimeout === 'function' ? w.setTimeout.bind(w) : null;
+    const originalRequestAnimationFrame =
+      typeof w.requestAnimationFrame === 'function' ? w.requestAnimationFrame.bind(w) : null;
+    const originalQueueMicrotask =
+      typeof w.queueMicrotask === 'function' ? w.queueMicrotask.bind(w) : null;
+
+    const queuedMicrotasks = [];
+    const queuedRaf = [];
+    const queuedTimers = [];
+    let fakeTimerId = 1;
+
+    const patchedSetTimeout = function (cb, delay) {
+      const d = Number.isFinite(Number(delay)) ? Number(delay) : 0;
+      if (typeof cb === 'function' && d <= 200) {
+        const args = [];
+        for (let i = 2; i < arguments.length; i++) args.push(arguments[i]);
+        queuedTimers.push({ delay: d, cb: () => cb.apply(w, args) });
+        return fakeTimerId++;
+      }
+      if (originalSetTimeout) return originalSetTimeout.apply(w, arguments);
+      return fakeTimerId++;
+    };
+
+    const patchedRaf = function (cb) {
+      if (typeof cb === 'function') {
+        queuedRaf.push(cb);
+        return fakeTimerId++;
+      }
+      if (originalRequestAnimationFrame) return originalRequestAnimationFrame.apply(w, arguments);
+      return fakeTimerId++;
+    };
+
+    const patchedQueueMicrotask = function (cb) {
+      if (typeof cb === 'function') queuedMicrotasks.push(cb);
+    };
+
+    try {
+      if (originalSetTimeout) w.setTimeout = patchedSetTimeout;
+      if (originalRequestAnimationFrame) w.requestAnimationFrame = patchedRaf;
+      if (originalQueueMicrotask) w.queueMicrotask = patchedQueueMicrotask;
+      fn();
+
+      let guard = 0;
+      while (
+        (queuedMicrotasks.length || queuedRaf.length || queuedTimers.length) &&
+        guard++ < 100
+      ) {
+        while (queuedMicrotasks.length) {
+          const mt = queuedMicrotasks.shift();
+          try {
+            mt();
+          } catch {}
+        }
+        while (queuedRaf.length) {
+          const rf = queuedRaf.shift();
+          try {
+            rf(16);
+          } catch {}
+        }
+        if (queuedTimers.length) {
+          queuedTimers.sort((a, b) => a.delay - b.delay);
+          const tt = queuedTimers.shift();
+          try {
+            tt.cb();
+          } catch {}
+        }
+      }
+    } finally {
+      if (originalSetTimeout) w.setTimeout = originalSetTimeout;
+      if (originalRequestAnimationFrame) w.requestAnimationFrame = originalRequestAnimationFrame;
+      if (originalQueueMicrotask) w.queueMicrotask = originalQueueMicrotask;
+    }
+  }
+
+  function probeImmediateFocusRedirect(candidate) {
+    if (!candidate || typeof candidate.addEventListener !== 'function') return null;
+
+    let focusedByEvent = false;
+    const onFocusCapture = () => {
+      focusedByEvent = true;
+    };
+    try {
+      candidate.addEventListener('focus', onFocusCapture, true);
+    } catch {}
+
+    const before = getDeepActiveElement(document);
+    let focused = false;
+    runFocusObservationWindow(document, () => {
+      focused = focusElementSafe(candidate);
+    });
+
+    try {
+      candidate.removeEventListener('focus', onFocusCapture, true);
+    } catch {}
+    if (!focused || !focusedByEvent) return null;
+
+    const after = getDeepActiveElement(document);
+
+    if (before && before !== after) {
+      focusElementSafe(before);
+    }
+
+    if (!after || after === candidate) return null;
+    const redirectedTag = (() => {
+      try {
+        return lower(after.tagName || '');
+      } catch {
+        return '';
+      }
+    })();
+    const redirectedId = (() => {
+      try {
+        return trim(after.getAttribute && after.getAttribute('id'));
+      } catch {
+        return '';
+      }
+    })();
+    return {
+      redirected: true,
+      redirectedToTag: redirectedTag || null,
+      redirectedToId: redirectedId || null
+    };
+  }
+
   function isTabbable(el, info) {
     const f = info || getFocusableInfoSafe(el);
     return !!(f && f.focusable && f.tabbable);
@@ -226,6 +385,8 @@ function runInPage(ctx) {
   }
 
   const occurrences = [];
+  const maxRuntimeProbeCount = 3;
+  let runtimeProbeCount = 0;
 
   for (const el of candidates) {
     if (!el || !el.getAttribute) continue;
@@ -251,18 +412,32 @@ function runInPage(ctx) {
     const hintsArr = [];
     for (const k of hintOrder) if (hints.includes(k)) hintsArr.push(k);
 
+    const runtimeProbe =
+      runtimeProbeCount < maxRuntimeProbeCount ? probeImmediateFocusRedirect(el) : null;
+    if (runtimeProbeCount < maxRuntimeProbeCount) runtimeProbeCount += 1;
+    const downgradedToRedirectReview = !!(runtimeProbe && runtimeProbe.redirected);
+
     const baseOccurrence = {
-      summary: `Focusable ${tagName} appears visually hidden (${hintsArr.join(',')}). Verify it becomes visible on keyboard focus.`,
-      hint: 'Manually tab to the element and confirm a visible focus indicator and that the element is visible when focused. If it remains hidden while focused, fix CSS/JS so it becomes visible or is removed from the tab order until visible.',
-      i18n: {
-        summaryKey: 'cssHidden_focus_summary_cantTell',
-        hintKey: 'cssHidden_focus_hint_cantTell',
-        params: { element: tagName, visibilityHints: hintsArr.join(',') }
-      },
+      summary: downgradedToRedirectReview
+        ? `Focusable ${tagName} appears visually hidden but focus moved immediately to another element. Verify sentinel/focus-trap behavior.`
+        : `Focusable ${tagName} appears visually hidden (${hintsArr.join(',')}). Verify it becomes visible on keyboard focus.`,
+      hint: downgradedToRedirectReview
+        ? 'Verify this is an intentional focus sentinel/focus-trap handoff and that keyboard users never remain on visually hidden focus targets.'
+        : 'Manually tab to the element and confirm a visible focus indicator and that the element is visible when focused. If it remains hidden while focused, fix CSS/JS so it becomes visible or is removed from the tab order until visible.',
+      i18n: downgradedToRedirectReview
+        ? null
+        : {
+            summaryKey: 'cssHidden_focus_summary_cantTell',
+            hintKey: 'cssHidden_focus_hint_cantTell',
+            params: { element: tagName, visibilityHints: hintsArr.join(',') }
+          },
       data: {
         details: {
-          reasonCode: 'cssHiddenTabbable_needsFocusStateVerification',
-          metrics: { visibilityHints: hintsArr.slice(0) }
+          reasonCode: downgradedToRedirectReview
+            ? 'cssHiddenTabbable_runtimeRedirect_needsReview'
+            : 'cssHiddenTabbable_needsFocusStateVerification',
+          metrics: { visibilityHints: hintsArr.slice(0) },
+          runtimeProbe: runtimeProbe || null
         }
       }
     };

package/src/checks/manual/embed-text-alternative-quality-manual.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -154,23 +156,26 @@ function runInPage(ctx) {
 
     // Only resolve IDREF text if aria-labelledby is present and aria-label is not already sufficient
     let labelledByText = '';
-    let hasLabelledByMechanism = false;
-
-    if (!ariaLabel && ariaLabelledBy) {
-      hasLabelledByMechanism = true;
 
-      if (getTextFromIdRefs) {
-        try {
-          const t = getTextFromIdRefs(ariaLabelledBy, ctx);
-          labelledByText = trim(t && t.text);
-          // If it resolves to empty, still treat as a mechanism present for manual review.
-        } catch {
-          labelledByText = '';
-        }
+    if (!ariaLabel && ariaLabelledBy && getTextFromIdRefs) {
+      try {
+        const t = getTextFromIdRefs(ariaLabelledBy, ctx);
+        labelledByText = trim(t && t.text);
+      } catch {
+        labelledByText = '';
       }
     }
 
-    const hasNameMechanism = !!(ariaLabel || title || hasLabelledByMechanism);
+    // A broken/empty-resolving aria-labelledby (e.g. pointing at a
+    // nonexistent id) is not a "detected" text alternative to review the
+    // QUALITY of -- there's no text here at all, and this element's
+    // sibling automatic rule (embed-text-alternative-present) already
+    // reports it as a fail (no accessible name). Like object-/svg-/
+    // canvas-text-alternative-quality-manual, require aria-labelledby to
+    // actually resolve to non-empty text rather than merely being present
+    // as an attribute; a present-but-broken aria-labelledby has no text
+    // alternative to review.
+    const hasNameMechanism = !!(ariaLabel || title || labelledByText);
     if (!hasNameMechanism) continue;
 
     const details = {

package/src/checks/manual/empty-heading-manual.js

@@ -1,10 +1,12 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
  * @check empty-heading
  * @atomic true
  * @summary Heading elements must not be empty
- * @standard Best Practices (a widely-used reference engine's classification; no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
+ * @standard Best Practices (no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
  * @applicability
  *   Applies to elements with a heading role: native <h1>-<h6>, or any
  *   element with explicit role="heading" (unless overridden by another
@@ -19,23 +21,21 @@
  * - Not WCAG-normative — authored as an advisory, cantTell-capped
  *   `type: 'manual'` rule; see landmark-banner-is-top-level's
  *   header comment for the shared rationale/precedent.
- * - This is also the reconciliation point for the "heading-name-present"
- *   gap surfaced by the 2026-07-19 ACT-rules research pass (see
- *   ROADMAP.md "Tier 5 candidates"): that gap was already closed by this
- *   pre-existing rule under a different name, not a real gap. Fixed two
- *   real false-positive bugs found while confirming that (2026-07-19):
- *   `title` wasn't accepted as a naming fallback, and hidden/aria-hidden/
- *   display:none headings weren't excluded (not gated on
- *   `isAccTreeEligible`), so an empty heading no AT user could ever
- *   reach was still flagged.
- * - 2026-07-21: the subtree-text walker's own hand-rolled descendant
- *   handling (aria-label/aria-labelledby only) never checked an `<img>`
- *   descendant's `alt` text — found via Party City's
- *   `<h1><a><div><img alt="..."></div></a></h1>` logo header, a false
- *   "empty heading" cantTell. Replaced with the shared, accname-aligned
+ * - This is also the reconciliation point for the ACT-rules
+ *   "heading-name-present" requirement (see ROADMAP.md "Tier 5
+ *   candidates"): already covered by this pre-existing rule under a
+ *   different name, not a separate gap. `title` is accepted as a naming
+ *   fallback, and hidden/aria-hidden/display:none headings are excluded
+ *   (gated on `isAccTreeEligible`), so an empty heading no AT user could
+ *   ever reach is not flagged.
+ * - Descendant name resolution uses the shared, accname-aligned
  *   `helpers.getContentNameInfo` (see dom-helpers.js) — the same "name
- *   from content" implementation the 19 `-name-present` rules already use
- *   — instead of maintaining a third, narrower copy of this logic here.
+ *   from content" implementation the 19 `-name-present` rules already
+ *   use — rather than a narrower hand-rolled walker, so an `<img alt="...">`
+ *   descendant's alt text (e.g. a
+ *   `<h1><a><div><img alt="..."></div></a></h1>` logo header) is correctly
+ *   picked up as the heading's name instead of producing a false "empty
+ *   heading" cantTell.
  */
 
 const id = 'empty-heading';

package/src/checks/manual/empty-table-header-manual.js

@@ -1,36 +1,30 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
  * @check empty-table-header
  * @atomic true
  * @summary Table header cells must not be empty
- * @standard Best Practices (a widely-used reference engine's classification; no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
+ * @standard Best Practices (no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
  * @applicability
  *   Applies to <th> elements that don't carry a conflicting explicit role,
  *   plus any element (native <th> or not) with role="columnheader" or
- *   role="rowheader" — matches a widely-used reference engine's own
- *   `empty-table-header` selector exactly (`th:not([role]), [role="columnheader"], [role="rowheader"]`,
- *   verified directly against its rule descriptor): a <th> that explicitly
- *   restates role="columnheader"/"rowheader" is still covered via the second
- *   clause, but a <th role="presentation"> (no longer meaningfully a header)
- *   is correctly excluded, and an ARIA-role-only header (e.g. a <div
- *   role="columnheader"> in a role="grid"/role="table" widget) is caught too
- *   — found missing entirely via the cross-engine diff tool 2026-07-23.
+ *   role="rowheader" (`th:not([role]), [role="columnheader"], [role="rowheader"]`):
+ *   a <th> that explicitly restates role="columnheader"/"rowheader" is still
+ *   covered via the second clause, but a <th role="presentation"> (no longer
+ *   meaningfully a header) is correctly excluded, and an ARIA-role-only header
+ *   (e.g. a <div role="columnheader"> in a role="grid"/role="table" widget) is
+ *   caught too.
  * @expectation
  *   The header cell has visible text content. A <th> named only via
  *   aria-label/aria-labelledby (no visible text) is ALSO flagged, not
- *   treated as equivalent — real screen-reader/browser testing (found via
- *   a live-DOM cross-engine run 2026-07-21, verified against
- *   https://butterpep.com/table-header-naming.html and
- *   https://html5accessibility.com/stuff/2024/05/22/not-so-short-note-on-aria-label-usage-big-table-edition/)
- *   confirms aria-label support on <th> is genuinely inconsistent in
- *   practice: NVDA+Firefox and iOS VoiceOver+Safari ignore it entirely
- *   (only visible text is announced), JAWS+Chrome/IE11 also only announce
- *   visible text in the header cell itself. Visible text is the one
- *   mechanism confirmed to work across every tested combination. A widely-used
- *   reference engine's own equivalent check (`has-visible-text` only, no aria-label/
- *   aria-labelledby alternative — confirmed directly against its rule
- *   descriptor) reaches the same conclusion.
+ *   treated as equivalent — aria-label support on <th> is genuinely
+ *   inconsistent in practice: NVDA+Firefox and iOS VoiceOver+Safari ignore
+ *   it entirely (only visible text is announced), JAWS+Chrome/IE11 also only
+ *   announce visible text in the header cell itself. Visible text is the one
+ *   mechanism confirmed to work across every tested combination. See
+ *   https://html5accessibility.com/stuff/2024/05/22/not-so-short-note-on-aria-label-usage-big-table-edition/.
  * @implementation-notes
  * - Not WCAG-normative — authored as an advisory, cantTell-capped
  *   `type: 'manual'` rule; see landmark-banner-is-top-level's
@@ -72,8 +66,36 @@ function runInPage(ctx) {
       .trim();
   }
 
+  const isAccTreeEligible =
+    helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+
+  function isEligible(node) {
+    if (!isAccTreeEligible) return true;
+    try {
+      const r = isAccTreeEligible(node, ctx);
+      return !!(r && r.eligible);
+    } catch {
+      return true;
+    }
+  }
+
+  // Plain el.textContent includes text from aria-hidden descendants, which
+  // a real screen reader never announces. A <th> whose only text comes from
+  // an aria-hidden descendant (e.g. <th><span aria-hidden="true">Name</span
+  // ></th>) would otherwise be treated as having visible text, even though
+  // AT announces nothing for it.
   function getVisibleText(el) {
-    return normalizeWs(el.textContent);
+    function walk(node) {
+      if (node.nodeType === 3) return node.nodeValue || '';
+      if (node.nodeType !== 1) return '';
+      if (!isEligible(node)) return '';
+      let text = '';
+      for (const child of node.childNodes || []) text += walk(child);
+      return text;
+    }
+    let text = '';
+    for (const child of el.childNodes || []) text += walk(child);
+    return normalizeWs(text);
   }
 
   function getAriaOnlyName(el) {
@@ -97,9 +119,8 @@ function runInPage(ctx) {
     return '';
   }
 
-  // Matches a widely-used reference engine's own empty-table-header selector exactly: a <th> with
-  // no conflicting explicit role, plus any element carrying an explicit
-  // columnheader/rowheader role (native or not).
+  // A <th> with no conflicting explicit role, plus any element carrying an
+  // explicit columnheader/rowheader role (native or not).
   const selector = 'th:not([role]), [role="columnheader"], [role="rowheader"]';
   const nodes = helpers.queryAllSmart
     ? helpers.queryAllSmart(selector)
@@ -110,6 +131,12 @@ function runInPage(ctx) {
 
   for (const el of nodes) {
     if (!el) continue;
+
+    // A fully aria-hidden header cell isn't part of the AT-perceived
+    // table structure at all -- queryAllSmart's default hidden-content
+    // policy only excludes "hard" CSS-based hiding, not aria-hidden.
+    if (!isEligible(el)) continue;
+
     applicableCount += 1;
 
     if (getVisibleText(el)) continue;

package/src/checks/manual/focus-order-semantics-manual.js

@@ -1,10 +1,12 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
  * @check focus-order-semantics
  * @atomic true
  * @summary Elements added to the tab order should have interactive semantics
- * @standard Best Practices (a widely-used reference engine's classification; no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
+ * @standard Best Practices (no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
  * @applicability
  *   Elements with an explicit `tabindex` of `0` or greater (in the tab
  *   order) AND an explicit `role` attribute that is one of a curated set
@@ -16,8 +18,8 @@
  *   announce, which is confusing for keyboard users who land on it and
  *   get no indication of what activating it (if anything) would do.
  * @implementation-notes
- * - Not WCAG-normative by a widely-used reference engine's own classification — authored as an
- *   advisory, cantTell-capped `type: 'manual'` rule.
+ * - Not WCAG-normative — authored as an advisory, cantTell-capped
+ *   `type: 'manual'` rule.
  * - The non-interactive role list is deliberately curated and
  *   conservative (structural/document roles only) — legitimate custom
  *   widget patterns using `tabindex` with a genuinely interactive role
@@ -25,6 +27,17 @@
  *   `tabindex` and NO role at all are also not flagged: native semantics
  *   or an intentionally generic custom-interactive pattern cannot be
  *   distinguished from markup alone with the same confidence.
+ * - `region` is deliberately NOT in the non-interactive role list: a
+ *   tabbable `role="region"` is a real, WCAG 2.1.1/2.1.3-grounded pattern
+ *   this engine's own `scrollable-region-focusable` check exists to
+ *   RECOMMEND (a scrollable landmark with no other focusable content
+ *   needs `tabindex="0"` to be keyboard-reachable at all) — flagging it
+ *   here would be internally inconsistent with that sibling check. A
+ *   `role="region"` is also commonly made tabbable on its own merits
+ *   (e.g. a cookie-consent banner or notification/toast region a keyboard
+ *   user should be able to reach directly, as in
+ *   `<div role="region" tabindex="0">`). Scoped to `region` only;
+ *   navigation/status/tabpanel remain flagged pending their own evidence.
  */
 
 const id = 'focus-order-semantics';
@@ -59,7 +72,6 @@ function runInPage(ctx) {
     'none',
     'img',
     'heading',
-    'region',
     'article',
     'banner',
     'contentinfo',

package/src/checks/manual/form-control-programmatic-label-quality-manual.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**

package/src/checks/manual/heading-order-manual.js

@@ -1,10 +1,12 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
  * @check heading-order
  * @atomic true
  * @summary Heading levels must not skip a level going deeper
- * @standard Best Practices (a widely-used reference engine's classification; no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
+ * @standard Best Practices (no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
  * @applicability
  *   Applies whenever the page contains two or more heading elements
  *   (native <h1>-<h6>, or explicit role="heading" with aria-level —
@@ -83,6 +85,31 @@ function runInPage(ctx) {
   for (const el of nodes) {
     if (!el || seen.has(el)) continue;
     seen.add(el);
+
+    // queryAllSmart's default hidden-content policy only excludes "hard"
+    // CSS-based hiding (display:none, visibility:hidden, etc.) -- it does
+    // NOT exclude aria-hidden, a softer/semantic removal from the
+    // accessibility tree that still leaves an element visually rendered.
+    // A heading order rule whose whole premise is "the document outline
+    // assistive technology users rely on" (see this rule's own header
+    // comment) must not let an aria-hidden heading participate in that
+    // outline at all: it's invisible to exactly the users this rule
+    // exists to protect. Without this check an aria-hidden heading is both
+    // flagged itself (though it isn't part of the AT-perceived outline)
+    // and can mask a real skip immediately after it, by advancing the
+    // "highest level reached so far" tracker on a level no AT user
+    // actually encountered.
+    if (helpers.isAccTreeEligible) {
+      const elig = (() => {
+        try {
+          return helpers.isAccTreeEligible(el, ctx);
+        } catch {
+          return { eligible: true, reasons: [] };
+        }
+      })();
+      if (elig && elig.eligible === false) continue;
+    }
+
     const level = getHeadingLevel(el);
     if (level > 0) headings.push({ el, level });
   }

package/src/checks/manual/identical-links-same-purpose-manual.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**

package/src/checks/manual/image-redundant-alt-manual.js

@@ -1,10 +1,12 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
  * @check image-redundant-alt
  * @atomic true
  * @summary An image's alt text must not duplicate adjacent visible text
- * @standard Best Practices (a widely-used reference engine's classification; no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
+ * @standard Best Practices (no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
  * @applicability
  *   Applies to <img> elements with non-empty alt text whose immediate
  *   parent element also has other visible text content (i.e. text nodes
@@ -57,12 +59,30 @@ function runInPage(ctx) {
   }
 
   function getOwnTextExcludingImg(parent, imgEl) {
+    const isAccTreeEligible =
+      helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+
     let text = '';
     for (const child of parent.childNodes || []) {
       if (child === imgEl) continue;
       if (child.nodeType === 3) {
         text += ' ' + (child.nodeValue || '');
       } else if (child.nodeType === 1 && child !== imgEl) {
+        // An aria-hidden sibling is never actually announced to assistive
+        // technology, so its text can't cause the "same words twice"
+        // double-announcement this rule exists to catch -- counting it
+        // anyway flags a redundancy that doesn't exist in what AT users
+        // actually hear.
+        if (isAccTreeEligible) {
+          const elig = (() => {
+            try {
+              return isAccTreeEligible(child, ctx);
+            } catch {
+              return { eligible: true, reasons: [] };
+            }
+          })();
+          if (elig && elig.eligible === false) continue;
+        }
         text += ' ' + (child.textContent || '');
       }
     }

package/src/checks/manual/img-alt-decorative-manual.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**

package/src/checks/manual/img-alt-quality-manual.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**

package/src/checks/manual/input-image-alt-decorative-manual.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**

package/src/checks/manual/input-image-alt-quality-manual.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**