@surea11y/core 1.4.0 → 1.5.0

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

@@ -9,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';
@@ -89,43 +91,60 @@ 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);
       }
     }
 
     if (!reasons.length) continue;
 
-    const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
-    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : el.outerHTML || '';
-
-    occurrences.push({
-      selector: stableSelector,
-      html,
-      summary: 'This viewport meta tag restricts the user’s ability to zoom.',
-      hint: 'Remove user-scalable=no and any maximum-scale below 2 from the viewport meta content.',
-      i18n: {
-        summaryKey: 'metaViewportZoomEnabled_summary_fail',
-        hintKey: 'metaViewportZoomEnabled_hint_fail',
-        params: { reasons: reasons.join(', ') }
-      },
-      data: {
-        details: { reasonCode: 'VIEWPORT_ZOOM_RESTRICTED', reasons }
-      }
-    });
+    occurrences.push(
+      helpers.reportOccurrence(el, {
+        summary: 'This viewport meta tag restricts the user’s ability to zoom.',
+        hint: 'Remove user-scalable=no and any maximum-scale below 2 from the viewport meta content.',
+        i18n: {
+          summaryKey: 'metaViewportZoomEnabled_summary_fail',
+          hintKey: 'metaViewportZoomEnabled_hint_fail',
+          params: { reasons: reasons.join(', ') }
+        },
+        data: {
+          details: { reasonCode: 'VIEWPORT_ZOOM_RESTRICTED', reasons }
+        }
+      })
+    );
   }
 
   if (applicableCount === 0) {

package/src/checks/automatic/meter-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);
@@ -126,24 +133,22 @@ function runInPage(ctx) {
           }
         })()
       : null;
-    const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
-    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : el.outerHTML || '';
-
-    occurrences.push({
-      selector: stableSelector,
-      html,
-      summary: 'This meter has no accessible name.',
-      hint: "Provide aria-label, aria-labelledby, or a title attribute — visible text content is not exposed as this meter's accessible name.",
-      i18n: {
-        summaryKey: 'meterNamePresent_summary_fail',
-        hintKey: 'meterNamePresent_hint_fail',
-        params: {}
-      },
-      data: {
-        details: { reasonCode: 'name_missing', controlType: 'meter', methodTried: res.method },
-        visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] }
-      }
-    });
+
+    occurrences.push(
+      helpers.reportOccurrence(el, {
+        summary: 'This meter has no accessible name.',
+        hint: "Provide aria-label, aria-labelledby, or a title attribute — visible text content is not exposed as this meter's accessible name.",
+        i18n: {
+          summaryKey: 'meterNamePresent_summary_fail',
+          hintKey: 'meterNamePresent_hint_fail',
+          params: {}
+        },
+        data: {
+          details: { reasonCode: 'name_missing', controlType: 'meter', methodTried: res.method },
+          visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] }
+        }
+      })
+    );
   }
 
   if (applicableCount === 0) {

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,53 +255,37 @@ 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';
-    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : el.outerHTML || '';
-
-    occurrences.push({
-      selector: stableSelector,
-      html,
-      summary: 'This interactive control contains one or more other interactive controls.',
-      hint: 'Move the nested interactive control(s) outside this element; nested interactive controls are not reliably operable via assistive technology.',
-      i18n: {
-        summaryKey: 'nestedInteractiveControlsAbsent_summary_fail',
-        hintKey: 'nestedInteractiveControlsAbsent_hint_fail',
-        params: { element: tag, nestedElements: dedupedNestedTags.join(', ') }
-      },
-      data: {
-        details: {
-          reasonCode: 'NESTED_INTERACTIVE_CONTROL',
-          element: tag,
-          nestedElements: nestedTags
+
+    occurrences.push(
+      helpers.reportOccurrence(el, {
+        summary: 'This interactive control contains one or more other interactive controls.',
+        hint: 'Move the nested interactive control(s) outside this element; nested interactive controls are not reliably operable via assistive technology.',
+        i18n: {
+          summaryKey: 'nestedInteractiveControlsAbsent_summary_fail',
+          hintKey: 'nestedInteractiveControlsAbsent_hint_fail',
+          params: { element: tag, nestedElements: dedupedNestedTags.join(', ') }
+        },
+        data: {
+          details: {
+            reasonCode: 'NESTED_INTERACTIVE_CONTROL',
+            element: tag,
+            nestedElements: nestedTags
+          }
         }
-      }
-    });
+      })
+    );
   }
 
   if (applicableCount === 0) {

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);
@@ -138,24 +145,22 @@ function runInPage(ctx) {
           }
         })()
       : null;
-    const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
-    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : el.outerHTML || '';
-
-    occurrences.push({
-      selector: stableSelector,
-      html,
-      summary: 'This element has no accessible name.',
-      hint: 'Provide aria-label or aria-labelledby (preferred), or provide visible text that is not hidden from assistive technologies.',
-      i18n: {
-        summaryKey: 'optionNamePresent_summary_fail',
-        hintKey: 'optionNamePresent_hint_fail',
-        params: { controlType: 'option' }
-      },
-      data: {
-        details: { reasonCode: 'name_missing', controlType: 'option', methodTried: res.method },
-        visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] }
-      }
-    });
+
+    occurrences.push(
+      helpers.reportOccurrence(el, {
+        summary: 'This element has no accessible name.',
+        hint: 'Provide aria-label or aria-labelledby (preferred), or provide visible text that is not hidden from assistive technologies.',
+        i18n: {
+          summaryKey: 'optionNamePresent_summary_fail',
+          hintKey: 'optionNamePresent_hint_fail',
+          params: { controlType: 'option' }
+        },
+        data: {
+          details: { reasonCode: 'name_missing', controlType: 'option', methodTried: res.method },
+          visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] }
+        }
+      })
+    );
   }
 
   if (applicableCount === 0) {

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);
@@ -128,28 +135,26 @@ function runInPage(ctx) {
           }
         })()
       : null;
-    const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
-    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : el.outerHTML || '';
-
-    occurrences.push({
-      selector: stableSelector,
-      html,
-      summary: 'This progress bar has no accessible name.',
-      hint: "Provide aria-label, aria-labelledby, or a title attribute — visible text content is not exposed as this progress bar's accessible name.",
-      i18n: {
-        summaryKey: 'progressbarNamePresent_summary_fail',
-        hintKey: 'progressbarNamePresent_hint_fail',
-        params: {}
-      },
-      data: {
-        details: {
-          reasonCode: 'name_missing',
-          controlType: 'progressbar',
-          methodTried: res.method
+
+    occurrences.push(
+      helpers.reportOccurrence(el, {
+        summary: 'This progress bar has no accessible name.',
+        hint: "Provide aria-label, aria-labelledby, or a title attribute — visible text content is not exposed as this progress bar's accessible name.",
+        i18n: {
+          summaryKey: 'progressbarNamePresent_summary_fail',
+          hintKey: 'progressbarNamePresent_hint_fail',
+          params: {}
         },
-        visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] }
-      }
-    });
+        data: {
+          details: {
+            reasonCode: 'name_missing',
+            controlType: 'progressbar',
+            methodTried: res.method
+          },
+          visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] }
+        }
+      })
+    );
   }
 
   if (applicableCount === 0) {