@surea11y/core 1.4.0 → 1.4.1

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

@@ -13,22 +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
- * - 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';
@@ -92,6 +118,8 @@ function runInPage(ctx) {
 
   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;
@@ -103,6 +131,122 @@ function runInPage(ctx) {
     }
   }
 
+  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);
@@ -111,30 +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;
 
-    // The nested search uses the raw native querySelectorAll (not
-    // helpers.queryAllSmart), so it isn't subject to that helper's
-    // default hidden-content policy at all -- not even hard CSS-based
-    // hiding, let alone aria-hidden. A nested descendant that is never
-    // actually rendered or exposed to AT (display:none, aria-hidden,
-    // etc.) creates no real ambiguity for ANY user, since it isn't there
-    // to be confused with the outer control.
-    let nested;
-    try {
-      nested = Array.from(el.querySelectorAll(INTERACTIVE_SELECTOR)).filter(isEligible);
-    } 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

@@ -9,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:
@@ -71,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;
@@ -148,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

@@ -83,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/progressbar-name-present.js

@@ -67,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);

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

@@ -109,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/slider-name-present.js

@@ -125,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);
@@ -141,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

@@ -109,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

@@ -83,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/tab-name-present.js

@@ -83,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/table-th-has-data-cells.js

@@ -9,7 +9,10 @@
  * @standard WCAG 2.2
  * @sc 1.3.1
  * @applicability
- *   Applies to <table> elements that contain at least one <th>.
+ *   Applies to <table> elements that keep their table semantics and are included
+ *   in the accessibility tree, and that contain at least one <th> which is
+ *   visible, included in the accessibility tree, and not overridden by an
+ *   explicit role other than rowheader/columnheader.
  * @expectation
  *   The table also contains at least one <td> somewhere in it.
  * @implementation-notes
@@ -30,9 +33,10 @@
  *   if some particular <th> in it doesn't actually describe any cell
  *   (false negative, not a false positive — acceptable under this
  *   engine's philosophy).
- * - Not rule-gated on isAccTreeEligible: this remains a static-markup
- *   property, while engine-level hidden-subtree filtering still applies
- *   unless engineOptions.includeHiddenElements is true.
+ * - Applicability IS gated, because the zero-<td> case above turns any
+ *   over-broad scope straight into a false fail: a layout table marked
+ *   role="presentation" with a stray <th> and no <td> was being failed,
+ *   as were tables whose only header was hidden or carried role="cell".
  */
 
 const id = 'table-th-has-data-cells';
@@ -72,16 +76,73 @@ function runInPage(ctx) {
   const occurrences = [];
   let applicableCount = 0;
 
+  function explicitRole(el) {
+    try {
+      return String((el && el.getAttribute && el.getAttribute('role')) || '')
+        .trim()
+        .toLowerCase()
+        .split(/\s+/)[0];
+    } catch {
+      return '';
+    }
+  }
+
+  function isIncludedInTree(el) {
+    const fn =
+      helpers && typeof helpers.isIncludedInAccessibilityTree === 'function'
+        ? helpers.isIncludedInAccessibilityTree
+        : null;
+    if (!fn) return true;
+    try {
+      const r = fn(el, ctx);
+      return typeof r === 'boolean' ? r : !!(r && r.eligible);
+    } catch {
+      return true;
+    }
+  }
+
+  // role="presentation"/"none" removes the table role, and with it every
+  // header cell the role would have implied. A table is not focusable, so
+  // presentational role conflict resolution does not restore it.
+  function hasTableSemantics(table) {
+    const role = explicitRole(table);
+    if (role === 'presentation' || role === 'none') return false;
+    if (role && role !== 'table' && role !== 'grid' && role !== 'treegrid') return false;
+    return isIncludedInTree(table);
+  }
+
+  // A <th> only carries a rowheader/columnheader role while nothing overrides
+  // it, and a hidden header describes nothing to a screen reader either way.
+  function isHeaderCellInScope(th) {
+    if (!th) return false;
+    const role = explicitRole(th);
+    if (role && role !== 'rowheader' && role !== 'columnheader') return false;
+    if (helpers.isDomVisibleEligible) {
+      try {
+        if (!helpers.isDomVisibleEligible(th, ctx, { targetSet: 'dom' }).eligible) return false;
+      } catch {
+        // fall through to the tree check
+      }
+    }
+    return isIncludedInTree(th);
+  }
+
   for (const table of tables) {
     if (!table || !table.querySelectorAll) continue;
 
+    // A table stripped of its semantics has no header cells to describe
+    // anything, so nothing in it is in scope.
+    if (!hasTableSemantics(table)) continue;
+
     let ths;
     try {
       ths = table.querySelectorAll('th');
     } catch {
       ths = [];
     }
-    if (!ths.length) continue;
+
+    const headers = Array.from(ths).filter(isHeaderCellInScope);
+    if (!headers.length) continue;
 
     applicableCount += 1;
 
@@ -93,7 +154,7 @@ function runInPage(ctx) {
     }
     if (hasDataCell) continue;
 
-    for (const th of ths) {
+    for (const th of headers) {
       if (!th) continue;
       const stableSelector = helpers.buildSelector ? helpers.buildSelector(th) : 'html';
       const html = helpers.getOuterHtmlSnippet

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

@@ -109,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/tooltip-name-present.js

@@ -83,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/treeitem-name-present.js

@@ -83,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/valid-lang.js

@@ -58,7 +58,13 @@ const meta = {
 function runInPage(ctx) {
   const { helpers, rule } = ctx;
 
+  // Shape alone accepts unregistered tags such as "eng" and "em-US", so the
+  // primary subtag is checked against the IANA registry via the shared helper.
   const BCP47_RE = /^[a-zA-Z]{2,3}(-[a-zA-Z0-9]{2,8})*$/;
+  const isValidTag =
+    typeof helpers.isValidLanguageTag === 'function'
+      ? helpers.isValidLanguageTag
+      : (v) => BCP47_RE.test(String(v || ''));
 
   const nodes = helpers.queryAllSmart
     ? helpers.queryAllSmart('[lang]')
@@ -71,12 +77,19 @@ function runInPage(ctx) {
     if (!el || !el.getAttribute) continue;
     if (el.tagName && el.tagName.toLowerCase() === 'html') continue;
 
-    const raw = String(el.getAttribute('lang') || '').trim();
-    if (!raw) continue;
+    const rawAttr = el.getAttribute('lang');
+    if (rawAttr === null || rawAttr === '') continue; // ACT de46e4: empty is out of scope
+
+    // The rule applies only where text actually inherits the language, so an
+    // element with no text, or whose text reaches no one, has nothing to
+    // declare a language for.
+    if (!String(el.textContent || '').trim()) continue;
 
     applicableCount += 1;
 
-    if (BCP47_RE.test(raw)) continue;
+    // A whitespace-only value is in scope and has no primary language tag.
+    const raw = String(rawAttr).trim();
+    if (isValidTag(raw)) continue;
 
     const tag = el.tagName.toLowerCase();
     const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';