@surea11y/core 1.3.0 → 1.4.1

package/src/checks/automatic/meta-viewport-zoom-enabled.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -7,17 +9,19 @@
  * @standard WCAG 2.2
  * @sc 1.4.4
  * @applicability
- *   Applies to <meta name="viewport"> elements that carry a non-empty
- *   content attribute.
+ *   Applies to <meta name="viewport"> elements whose content attribute sets
+ *   maximum-scale or user-scalable. Content setting neither cannot restrict
+ *   zoom.
  * @expectation
- *   The content attribute does not set user-scalable to "no"/"0", and does
- *   not set maximum-scale below 2 (200%). Either disables the user's
- *   ability to zoom text to at least 200%, which WCAG 1.4.4 (Resize Text)
- *   requires be possible.
+ *   user-scalable is absent, yes, device-width, device-height, or a number
+ *   outside the range -1 to 1; and maximum-scale is absent, device-width,
+ *   device-height, negative, or 2 or more. Anything else stops the user
+ *   zooming text to 200%, which WCAG 1.4.4 (Resize Text) requires.
  * @implementation-notes
- * - Malformed/unparseable maximum-scale values are ignored (not flagged) —
- *   this rule only reports a clearly-detected zoom restriction, matching
- *   this engine's no-false-positives policy.
+ * - An unparseable value counts as a restriction, because CSS Device
+ *   Adaptation translates it to 0: maximum-scale=yes disables zoom exactly
+ *   as maximum-scale=0 does. A negative maximum-scale is out of range and
+ *   dropped by the browser, so it restricts nothing and passes.
  */
 
 const id = 'meta-viewport-zoom-enabled';
@@ -87,20 +91,40 @@ function runInPage(ctx) {
     const raw = String(el.getAttribute('content') || '').trim();
     if (!raw) continue;
 
-    applicableCount += 1;
-
     const parsed = parseContent(raw);
+
+    // ACT b4f0c3 applies only when content carries maximum-scale or
+    // user-scalable; content that sets neither cannot restrict zoom.
+    if (parsed['user-scalable'] === undefined && parsed['maximum-scale'] === undefined) continue;
+
+    applicableCount += 1;
     const reasons = [];
 
+    // CSS Device Adaptation translates an unparseable value to 0, so
+    // user-scalable=invalid and maximum-scale=yes disable zoom just as
+    // user-scalable=no does. A negative maximum-scale is out of range and
+    // dropped instead, which is why it does not restrict anything.
     const userScalable = parsed['user-scalable'];
-    if (userScalable === 'no' || userScalable === '0') {
-      reasons.push('user-scalable=' + userScalable);
+    if (
+      userScalable !== undefined &&
+      userScalable !== 'yes' &&
+      userScalable !== 'device-width' &&
+      userScalable !== 'device-height'
+    ) {
+      const scale = parseFloat(userScalable);
+      if (Number.isNaN(scale) || (scale > -1 && scale < 1)) {
+        reasons.push('user-scalable=' + userScalable);
+      }
     }
 
     const maxScaleRaw = parsed['maximum-scale'];
-    if (maxScaleRaw !== undefined) {
+    if (
+      maxScaleRaw !== undefined &&
+      maxScaleRaw !== 'device-width' &&
+      maxScaleRaw !== 'device-height'
+    ) {
       const maxScale = parseFloat(maxScaleRaw);
-      if (!Number.isNaN(maxScale) && maxScale < 2) {
+      if (Number.isNaN(maxScale) || (maxScale >= 0 && maxScale < 2)) {
         reasons.push('maximum-scale=' + maxScaleRaw);
       }
     }

package/src/checks/automatic/meter-name-present.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 const id = 'meter-name-present';
@@ -65,9 +67,16 @@ function runInPage(ctx) {
     return '';
   }
 
+  // Naming rules apply only to elements included in the accessibility tree
+  // (ACT c487ae and siblings), which excludes focusable aria-hidden content.
+  // aria-hidden-focus (ACT 6cfa84) covers that markup instead.
   function isEligibleAcc(helpers, el, ctx) {
     const fn =
-      helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+      helpers && typeof helpers.isIncludedInAccessibilityTree === 'function'
+        ? helpers.isIncludedInAccessibilityTree
+        : helpers && typeof helpers.isAccTreeEligible === 'function'
+          ? helpers.isAccTreeEligible
+          : null;
     if (!fn) return true;
     try {
       const r = fn(el, ctx);
@@ -96,9 +105,8 @@ function runInPage(ctx) {
     const title = getAttr(el, 'title');
     if (title) return { ok: true, method: 'title' };
 
-    // role="meter" is name-from-author-only per WAI-ARIA (verified against
-    // a widely-used reference engine's own aria-meter-name check: any: ['aria-label',
-    // 'aria-labelledby', title] — no content-based naming method at all).
+    // role="meter" is name-from-author-only per WAI-ARIA: aria-label,
+    // aria-labelledby, or title — no content-based naming method at all.
     // It must NOT fall back to subtree content — visible text near/inside a
     // custom meter widget is not reliably exposed as its accessible name.
     return { ok: false, method: 'none' };

package/src/checks/automatic/nested-interactive-controls-absent.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -11,23 +13,48 @@
  *   a[href], button, input (not hidden), select, textarea; or an explicit
  *   ARIA widget role: button, link, checkbox, radio, switch, tab, textbox,
  *   combobox, listbox, menuitem, menuitemcheckbox, menuitemradio, option,
- *   slider, spinbutton, searchbox, treeitem).
+ *   slider, spinbutton, searchbox, treeitem). The container is applicable
+ *   regardless of whether it is itself focusable — focusability is only
+ *   used to decide whether a *descendant* nests an interactive control.
  * @expectation
- *   The element does not contain, as a descendant, another element from
- *   that same interactive-control set (e.g. a <button> wrapping a
- *   <select>, or a link containing a checkbox). Nested interactive
- *   controls are not reliably announced or operable via assistive
- *   technology — activating the outer control and the inner one become
- *   ambiguous, and some AT only exposes one of the two.
+ *   The element does not contain, as a descendant, another *operable*
+ *   interactive control (e.g. a <button> wrapping a <select>, or a link
+ *   containing a checkbox). Nested interactive controls are not reliably
+ *   announced or operable via assistive technology — activating the outer
+ *   control and the inner one become ambiguous, and some AT only exposes
+ *   one of the two.
  * @implementation-notes
- * - Matches a widely-used reference engine's nested-interactive. Reports on the outer
- *   (containing) control, not the nested descendant — this engine
- *   considers the container the fixable unit ("move the nested control
- *   outside this element").
- * - A container can be reported once even with multiple nested
- *   descendants (listed together); a deeply nested chain (A > B > C, all
- *   interactive) reports both A and B as separate occurrences, since each
- *   genuinely contains a nested interactive control.
+ * - A descendant counts as a nested interactive control only when it is both
+ *   (a) a native interactive element or an explicit ARIA widget role and
+ *   (b) operable: exposed to the accessibility tree and platform-focusable
+ *   (natively focusable, or focusable via tabindex), per
+ *   helpers.getFocusableInfo, which accounts for contenteditable, :disabled,
+ *   inert, and invalid/negative tabindex.
+ * - A widget-role child that its container drives rather than exposes as its
+ *   own focus target creates no operability ambiguity and does not count:
+ *   a role="option" inside a listbox/combobox, a role="tab" inside a tablist,
+ *   a role="treeitem" inside a tree, a role="menuitem" inside a menu, or a
+ *   role="radio" inside a radiogroup. Composites manage such children with one
+ *   of two focus models, and both are exempt: aria-activedescendant (the child
+ *   has no tabindex and is not focusable) and roving tabindex (the active
+ *   child carries tabindex="0" and the rest tabindex="-1"). Under roving
+ *   tabindex the owned child IS platform-focusable, so focusability alone
+ *   cannot be the discriminator; membership in the container's owned-child set
+ *   is what exempts it. A control that is itself focusable while nested in a
+ *   control it does NOT belong to still counts: a <button> inside an <a href>,
+ *   a focusable role="button" inside a link, an editable field inside a
+ *   control, or an orphan role="option" with no owning listbox/combobox.
+ * - A disabled native control (<button disabled>, <input disabled>) and an
+ *   inert descendant are not focusable, so they do not nest an interactive
+ *   control; a display:none or aria-hidden descendant is not exposed to AT
+ *   and is likewise out of scope. aria-disabled leaves an element focusable,
+ *   so it still counts.
+ * - Occurrences report the outer (containing) control, the fixable unit
+ *   ("move the nested control outside this element"), not the descendant.
+ * - Only the shallowest operable descendants are attributed to a container.
+ *   In a chain A > B > C where all three are operable, A is reported for B
+ *   and B for C; A is not reported for C, whose nesting belongs to its
+ *   nearest operable ancestor B.
  */
 
 const id = 'nested-interactive-controls-absent';
@@ -89,6 +116,137 @@ function runInPage(ctx) {
     '[role="treeitem"]'
   ].join(', ');
 
+  const isAccTreeEligible =
+    helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+  const getFocusableInfo =
+    helpers && typeof helpers.getFocusableInfo === 'function' ? helpers.getFocusableInfo : null;
+
+  function isEligible(node) {
+    if (!isAccTreeEligible) return true;
+    try {
+      const r = isAccTreeEligible(node, ctx);
+      return !!(r && r.eligible);
+    } catch {
+      return true;
+    }
+  }
+
+  function matchesInteractive(node) {
+    return !!(
+      node &&
+      node.nodeType === 1 &&
+      typeof node.matches === 'function' &&
+      node.matches(INTERACTIVE_SELECTOR)
+    );
+  }
+
+  // A composite widget owns children of a fixed role and drives their focus
+  // itself (via roving tabindex or aria-activedescendant). The roving-tabindex
+  // model gives the active child tabindex="0" and the rest tabindex="-1", so
+  // the owned children ARE platform-focusable even though the container, not
+  // the child, is the operable unit. Such a child is part of the composite,
+  // not a control nested inside another control, so it must not be reported
+  // regardless of its tabindex. The map is keyed by the child role and lists
+  // the container roles that legitimately own it.
+  const COMPOSITE_CHILD_CONTAINERS = {
+    option: ['listbox', 'combobox'],
+    tab: ['tablist'],
+    treeitem: ['tree'],
+    menuitem: ['menu', 'menubar'],
+    menuitemcheckbox: ['menu', 'menubar'],
+    menuitemradio: ['menu', 'menubar'],
+    radio: ['radiogroup']
+  };
+
+  function getExplicitRole(node) {
+    if (!node || node.nodeType !== 1 || typeof node.getAttribute !== 'function') return '';
+    const raw = node.getAttribute('role');
+    if (!raw) return '';
+    // role accepts a space-separated fallback list; the first token wins.
+    const first = raw.trim().split(/\s+/)[0];
+    return first ? first.toLowerCase() : '';
+  }
+
+  function parentElementOf(node) {
+    if (!node) return null;
+    if (node.parentElement) return node.parentElement;
+    const p = node.parentNode;
+    return p && p.nodeType === 1 ? p : null;
+  }
+
+  // True when `node` is an owned child of a composite widget: its role is a
+  // composite-child role and a matching container role is present on one of
+  // its ancestors. The roving tab stop (tabindex="0") such a container places
+  // on its active child does not make that child an independently nested
+  // control.
+  function isManagedCompositeChild(node) {
+    const role = getExplicitRole(node);
+    const containers = COMPOSITE_CHILD_CONTAINERS[role];
+    if (!containers) return false;
+    let p = parentElementOf(node);
+    while (p && p.nodeType === 1) {
+      if (containers.indexOf(getExplicitRole(p)) !== -1) return true;
+      p = parentElementOf(p);
+    }
+    return false;
+  }
+
+  // Operable = a native-interactive / ARIA-widget element that is exposed to
+  // the accessibility tree and platform-focusable. A widget-role element with
+  // no independent focus (e.g. a role="option" with no tabindex, driven by
+  // its container via roving tabindex or aria-activedescendant) is not
+  // operable and does not nest an interactive control. When no focus model is
+  // available, role membership alone qualifies. (Composite-owned children are
+  // handled earlier as attribution boundaries in collectNestedOperable, so
+  // they never reach here.)
+  function isOperableInteractive(node) {
+    if (!matchesInteractive(node)) return false;
+    if (!isEligible(node)) return false;
+    if (!getFocusableInfo) return true;
+    try {
+      const info = getFocusableInfo(node, ctx);
+      return !!(info && info.focusable);
+    } catch {
+      return true;
+    }
+  }
+
+  // Shallowest operable interactive descendants of `root`. Traversal stops at
+  // each counted node instead of descending into it, so a control nested
+  // inside another operable control is attributed to its nearest operable
+  // ancestor rather than to every enclosing container. Eligibility is applied
+  // per node during the walk, so hidden or aria-hidden subtrees drop out.
+  function collectNestedOperable(root) {
+    const out = [];
+    const top = root && root.children;
+    if (!top || !top.length) return out;
+    const stack = [];
+    for (let i = top.length - 1; i >= 0; i--) stack.push(top[i]);
+    while (stack.length) {
+      const node = stack.pop();
+      if (node && node.nodeType === 1) {
+        // A composite-owned child (option in a listbox/combobox, tab in a
+        // tablist, ...) is not a nested interactive control: its container
+        // owns it and drives its focus (roving tabindex or
+        // aria-activedescendant). Treat it as an attribution boundary — do not
+        // count it, and do not descend past it. Any control genuinely nested
+        // inside it is attributed to the child itself (examined as its own
+        // container in the main loop), keeping the report at the nearest
+        // interactive ancestor rather than bubbling up to the composite.
+        if (isManagedCompositeChild(node)) continue;
+        if (isOperableInteractive(node)) {
+          out.push(node);
+          continue; // do not descend into a counted control
+        }
+      }
+      const kids = node && node.children;
+      if (kids && kids.length) {
+        for (let i = kids.length - 1; i >= 0; i--) stack.push(kids[i]);
+      }
+    }
+    return out;
+  }
+
   const nodes = helpers.queryAllSmart
     ? helpers.queryAllSmart(INTERACTIVE_SELECTOR)
     : helpers.queryAll(INTERACTIVE_SELECTOR);
@@ -97,22 +255,16 @@ function runInPage(ctx) {
   let applicableCount = 0;
 
   for (const el of nodes) {
-    if (!el || !el.querySelectorAll) continue;
+    if (!el || el.nodeType !== 1) continue;
+    if (!isEligible(el)) continue;
 
     applicableCount += 1;
 
-    let nested;
-    try {
-      nested = Array.from(el.querySelectorAll(INTERACTIVE_SELECTOR));
-    } catch {
-      nested = [];
-    }
+    const nested = collectNestedOperable(el);
     if (!nested.length) continue;
 
     const nestedTags = nested.map((n) => (n && n.tagName ? n.tagName.toLowerCase() : 'unknown'));
-    const dedupedNestedTags = [
-      ...new Set(nested.map((n) => (n && n.tagName ? n.tagName.toLowerCase() : 'unknown')))
-    ];
+    const dedupedNestedTags = [...new Set(nestedTags)];
 
     const tag = el.tagName.toLowerCase();
     const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';

package/src/checks/automatic/object-text-alternative-present.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -7,9 +9,8 @@
  * @standard WCAG 2.2
  * @sc 1.1.1
  * @applicability
- *   Applies to <object> elements that are exposed to assistive technologies.
- *   Objects otherwise hidden from the accessibility tree remain applicable
- *   if they are tabbable or referenced by IDREF relationships (per engine eligibility checks).
+ *   Applies to <object> elements included in the accessibility tree.
+ *   Hidden objects are excluded whether or not they are focusable.
  *   role="presentation"/role="none" are excluded only when not focusable.
  * @expectation
  *   Each applicable <object> provides a text alternative via:
@@ -69,8 +70,15 @@ function runInPage(ctx) {
   const getEligibilityInfo =
     helpers && typeof helpers.getEligibilityInfo === 'function' ? helpers.getEligibilityInfo : null;
 
-  const isAccTreeEligible =
-    helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+  // ACT 8fc3b6 applies only to objects included in the accessibility tree, so a
+  // focusable object inside aria-hidden is out of scope; aria-hidden-focus
+  // reports that markup instead.
+  const isEligibleHelper =
+    helpers && typeof helpers.isIncludedInAccessibilityTree === 'function'
+      ? helpers.isIncludedInAccessibilityTree
+      : helpers && typeof helpers.isAccTreeEligible === 'function'
+        ? helpers.isAccTreeEligible
+        : null;
 
   const getFocusableInfo =
     helpers && typeof helpers.getFocusableInfo === 'function' ? helpers.getFocusableInfo : null;
@@ -146,14 +154,15 @@ function runInPage(ctx) {
   for (const el of objects) {
     if (!el || !el.getAttribute) continue;
 
-    if (isAccTreeEligible) {
+    if (isEligibleHelper) {
       const elig = (() => {
         try {
-          return isAccTreeEligible(el, ctx);
+          return isEligibleHelper(el, ctx);
         } catch {
           return { eligible: true, reasons: [] };
         }
       })();
+      if (elig === false) continue;
       if (elig && elig.eligible === false) continue;
     }
 

package/src/checks/automatic/option-name-present.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 const id = 'option-name-present';
@@ -81,9 +83,16 @@ function runInPage(ctx) {
     return '';
   }
 
+  // Naming rules apply only to elements included in the accessibility tree
+  // (ACT c487ae and siblings), which excludes focusable aria-hidden content.
+  // aria-hidden-focus (ACT 6cfa84) covers that markup instead.
   function isEligibleAcc(helpers, el, ctx) {
     const fn =
-      helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+      helpers && typeof helpers.isIncludedInAccessibilityTree === 'function'
+        ? helpers.isIncludedInAccessibilityTree
+        : helpers && typeof helpers.isAccTreeEligible === 'function'
+          ? helpers.isAccTreeEligible
+          : null;
     if (!fn) return true;
     try {
       const r = fn(el, ctx);

package/src/checks/automatic/page-title-present.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 const id = 'page-title-present';

package/src/checks/automatic/progressbar-name-present.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 const id = 'progressbar-name-present';
@@ -65,9 +67,16 @@ function runInPage(ctx) {
     return '';
   }
 
+  // Naming rules apply only to elements included in the accessibility tree
+  // (ACT c487ae and siblings), which excludes focusable aria-hidden content.
+  // aria-hidden-focus (ACT 6cfa84) covers that markup instead.
   function isEligibleAcc(helpers, el, ctx) {
     const fn =
-      helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+      helpers && typeof helpers.isIncludedInAccessibilityTree === 'function'
+        ? helpers.isIncludedInAccessibilityTree
+        : helpers && typeof helpers.isAccTreeEligible === 'function'
+          ? helpers.isAccTreeEligible
+          : null;
     if (!fn) return true;
     try {
       const r = fn(el, ctx);
@@ -96,16 +105,12 @@ function runInPage(ctx) {
     const title = getAttr(el, 'title');
     if (title) return { ok: true, method: 'title' };
 
-    // role="progressbar" is name-from-author-only per WAI-ARIA (verified
-    // against a widely-used reference engine's own aria-progressbar-name check: any:
-    // ['aria-label', 'aria-labelledby', title] — no content-based naming
-    // method at all). It must NOT fall back to subtree content: found on a
-    // real site, Instacart's <ul role="progressbar"> loading skeleton has
-    // no name of its own, but nested descendants carry their own
-    // aria-label="Loading Box" (for a completely different purpose) —
-    // falling back to subtree content picked that up and wrongly treated
-    // it as the progressbar's own name, when that reference engine correctly
-    // still flags it as unnamed.
+    // role="progressbar" is name-from-author-only per WAI-ARIA: aria-label,
+    // aria-labelledby, or title — no content-based naming method at all. It
+    // must NOT fall back to subtree content: e.g. a <ul role="progressbar">
+    // loading skeleton with no name of its own, whose nested descendants
+    // carry their own aria-label for a different purpose — falling back to
+    // subtree content would wrongly treat that as the progressbar's name.
     return { ok: false, method: 'none' };
   }
 

package/src/checks/automatic/role-img-alt-present.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -14,8 +16,7 @@
  *   Each applicable element with role="img" has an accessible text alternative:
  *    - aria-label with a non-empty value; OR
  *    - aria-labelledby referencing at least one existing element that contributes non-empty text; OR
- *    - a non-empty title attribute (last-resort accessible-name source per HTML-AAM,
- *      also accepted by a widely-used reference engine's equivalent role-img-alt rule).
+ *    - a non-empty title attribute (last-resort accessible-name source per HTML-AAM).
  */
 
 const id = 'role-img-text-alternative-present';
@@ -152,8 +153,7 @@ function runInPage(ctx) {
     const hasValidAriaLabel = hasAriaLabelAttr && ariaLabel.length > 0;
     const hasValidAriaLabelledbyAttr = hasAriaLabelledbyAttr && ariaLabelledby.length > 0;
 
-    // Last-resort naming mechanism per HTML-AAM (also accepted by
-    // a widely-used reference engine's role-img-alt): a non-empty title attribute.
+    // Last-resort naming mechanism per HTML-AAM: a non-empty title attribute.
     const titleRaw = (() => {
       try {
         return el.getAttribute('title');

package/src/checks/automatic/searchbox-name-present.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 const id = 'searchbox-name-present';
@@ -107,9 +109,16 @@ function runInPage(ctx) {
     return '';
   }
 
+  // Naming rules apply only to elements included in the accessibility tree
+  // (ACT c487ae and siblings), which excludes focusable aria-hidden content.
+  // aria-hidden-focus (ACT 6cfa84) covers that markup instead.
   function isEligibleAcc(helpers, el, ctx) {
     const fn =
-      helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+      helpers && typeof helpers.isIncludedInAccessibilityTree === 'function'
+        ? helpers.isIncludedInAccessibilityTree
+        : helpers && typeof helpers.isAccTreeEligible === 'function'
+          ? helpers.isAccTreeEligible
+          : null;
     if (!fn) return true;
     try {
       const r = fn(el, ctx);

package/src/checks/automatic/server-side-image-map-absent.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -16,9 +18,8 @@
  *   users. Client-side image maps (<map>/<area>, each with real href/alt)
  *   are the accessible alternative and are not flagged by this rule.
  * @implementation-notes
- * - Matches a widely-used reference engine's server-side-image-map: presence of ismap is itself
- *   the violation (there is no automatable way to verify a "usable
- *   alternative" exists elsewhere on the page).
+ * - Presence of ismap is itself the violation (there is no automatable way
+ *   to verify a "usable alternative" exists elsewhere on the page).
  */
 
 const id = 'server-side-image-map-absent';

package/src/checks/automatic/slider-name-present.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 const id = 'slider-name-present';
@@ -123,9 +125,16 @@ function runInPage(ctx) {
     return '';
   }
 
+  // Naming rules apply only to elements included in the accessibility tree
+  // (ACT c487ae and siblings), which excludes focusable aria-hidden content.
+  // aria-hidden-focus (ACT 6cfa84) covers that markup instead.
   function isEligibleAcc(helpers, el, ctx) {
     const fn =
-      helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+      helpers && typeof helpers.isIncludedInAccessibilityTree === 'function'
+        ? helpers.isIncludedInAccessibilityTree
+        : helpers && typeof helpers.isAccTreeEligible === 'function'
+          ? helpers.isAccTreeEligible
+          : null;
     if (!fn) return true;
     try {
       const r = fn(el, ctx);
@@ -139,7 +148,9 @@ function runInPage(ctx) {
   const occurrences = [];
   let applicableCount = 0;
 
-  const selector = 'input[type="range"], [role="slider"]';
+  // Native input[type=range] belongs to
+  // form-control-programmatic-label-present.
+  const selector = '[role="slider"]';
   const nodes = helpers.queryAllSmart
     ? helpers.queryAllSmart(selector)
     : helpers.queryAll(selector);

package/src/checks/automatic/spinbutton-name-present.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 const id = 'spinbutton-name-present';
@@ -107,9 +109,16 @@ function runInPage(ctx) {
     return '';
   }
 
+  // Naming rules apply only to elements included in the accessibility tree
+  // (ACT c487ae and siblings), which excludes focusable aria-hidden content.
+  // aria-hidden-focus (ACT 6cfa84) covers that markup instead.
   function isEligibleAcc(helpers, el, ctx) {
     const fn =
-      helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+      helpers && typeof helpers.isIncludedInAccessibilityTree === 'function'
+        ? helpers.isIncludedInAccessibilityTree
+        : helpers && typeof helpers.isAccTreeEligible === 'function'
+          ? helpers.isAccTreeEligible
+          : null;
     if (!fn) return true;
     try {
       const r = fn(el, ctx);

package/src/checks/automatic/summary-name-present.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 const id = 'summary-name-present';
@@ -81,9 +83,16 @@ function runInPage(ctx) {
     return '';
   }
 
+  // Naming rules apply only to elements included in the accessibility tree
+  // (ACT c487ae and siblings), which excludes focusable aria-hidden content.
+  // aria-hidden-focus (ACT 6cfa84) covers that markup instead.
   function isEligibleAcc(helpers, el, ctx) {
     const fn =
-      helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+      helpers && typeof helpers.isIncludedInAccessibilityTree === 'function'
+        ? helpers.isIncludedInAccessibilityTree
+        : helpers && typeof helpers.isAccTreeEligible === 'function'
+          ? helpers.isAccTreeEligible
+          : null;
     if (!fn) return true;
     try {
       const r = fn(el, ctx);

package/src/checks/automatic/svg-image-text-alternative-present.js

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