@surea11y/core 1.2.0 → 1.4.0

package/src/checks/automatic/aria-prohibited-children.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -20,86 +22,54 @@
  *   owned set. Nothing else is a structurally valid direct child of a
  *   composite/container role.
  * @implementation-notes
- * - A distinct atomic decision from aria-required-children (see
- *   that rule): "does at least one required child exist" vs "is every
- *   owned child one of the allowed roles." A widely-used reference engine
- *   bundles both under one check (`aria-required-children`); this repo's
- *   "one rule = one normative decision" principle splits them, matching
- *   the established pattern elsewhere of surea11y rules mapping
- *   many-to-one against a single check in that reference engine.
- * - The "allowed owned roles" set is exactly REQUIRED_OWNED_ROLES — not
- *   a separately authored, broader list. Verified directly against a
- *   widely-used reference engine's own ariaRequiredChildren/getOwnedRoles
- *   algorithm: an owned element is only considered allowed if its role is
- *   literally in the container's required set; that engine does not
- *   define a superset "allowed but not required" list for this purpose.
- *   Found and verified via a real page (Red Cross's homepage: a
- *   <nav role="region"> nested inside a <ul role="menubar"> through a
- *   role="none" <li> wrapper — a real violation that reference engine
- *   caught that aria-required-children's own scope (documented
- *   there as "can only under-report, never over-report") does not).
- * - Widened 2026-07-21 to also flag a ROLELESS descendant that has any
- *   global WAI-ARIA attribute or is focusable, matching a widely-used
- *   reference engine's own `getOwnedRoles` exactly (verified directly
- *   against its source: `hasGlobalAriaOrFocusable =
- *   !!globalAriaAttr || _isFocusable(vNode)` — such a descendant is
- *   pushed as an owned entry with `role: null`, which can never match a
- *   container's required-owned-roles set, so it's always "unallowed").
- *   Previously left out as riskier to replicate — re-evaluated given
- *   direct access to that engine's exact algorithm (not a guess) plus this
- *   engine's own already-existing, shared `helpers.getFocusableInfo` for
- *   the focusability half. Both signals (global-attribute presence,
- *   focusability) are static, declarative markup facts with no live-DOM/
- *   hydration risk, unlike e.g. `aria-checked-state-mismatch`'s DOM-
- *   property comparison.
- * - Fixed 2026-07-30: a roleless-but-focusable descendant's message and
- *   `data.details.attr` used to always claim "carries tabindex" even when
- *   the element had no tabindex attribute at all and was only focusable
- *   natively (e.g. an <a href> link). `helpers.getFocusableInfo`'s
- *   `mechanism` field ('tabindex' | 'native' | ...) is now used to tell
- *   the two apart, with a distinct `nativeFocusable` attr/message for the
- *   native case. Found via a real Angular app: a routerLink <a> inside a
- *   role="list" was reported as "carries tabindex" though the rendered
- *   markup had no such attribute.
- * - Recursion stops at the first non-transparent role boundary, same as
- *   that reference engine: a nested container with its own real role (e.g. a
- *   <div role="listbox"> inside a menubar) is evaluated as ITS OWN
- *   owned-role entry against the outer container (and, separately, gets
- *   its own applicability pass as a container in the same rule run) —
- *   its descendants are never misattributed to the outer container.
- * - Fixed 2026-07-31: child-role resolution used `ariaHelpers.getExplicitRole`
- *   (explicit role="" attribute only), unlike aria-required-children's
- *   descendant matching which uses `ariaHelpers.getContainmentRole` (explicit
+ * - A distinct atomic decision from aria-required-children (see that
+ *   rule): "does at least one required child exist" vs "is every owned
+ *   child one of the allowed roles" — split per this repo's "one rule =
+ *   one normative decision" principle.
+ * - The "allowed owned roles" set is exactly REQUIRED_OWNED_ROLES, not a
+ *   separately authored, broader list: an owned element is allowed only if
+ *   its role is literally in the container's required set.
+ * - A ROLELESS descendant that has any global WAI-ARIA attribute or is
+ *   focusable is also flagged: it's treated as an owned entry with
+ *   `role: null`, which can never match a container's required-owned-roles
+ *   set, so it's always "unallowed". Both signals
+ *   (global-attribute presence, focusability via the shared
+ *   `helpers.getFocusableInfo`) are static, declarative markup facts with
+ *   no live-DOM/hydration risk, unlike e.g.
+ *   `aria-checked-state-mismatch`'s DOM-property comparison.
+ *   `helpers.getFocusableInfo`'s `mechanism` field ('tabindex' | 'native' |
+ *   ...) distinguishes an explicit `tabindex` attribute from native
+ *   focusability (e.g. an `<a href>`), so the reported `data.details.attr`
+ *   and message correctly say `nativeFocusable` rather than claiming a
+ *   tabindex attribute that isn't actually present in the markup.
+ * - Recursion stops at the first non-transparent role boundary: a nested
+ *   container with its own real role
+ *   (e.g. a `<div role="listbox">` inside a menubar) is evaluated as its
+ *   own owned-role entry against the outer container (and, separately,
+ *   gets its own applicability pass as a container in the same rule run)
+ *   — its descendants are never misattributed to the outer container.
+ * - Child-role resolution uses `ariaHelpers.getContainmentRole` (explicit
  *   role, falling back to the native-tag map — li/tr/td/th/tbody/ul/ol/
- *   table/select/input[type=radio] — see that helper's own header comment).
- *   A bare `<li>` with no role="" attribute — the common CSS-reset
- *   workaround `<ul role="list"><li>...</li></ul>` that getContainmentRole
- *   exists specifically to handle — was therefore read as roleless here,
- *   making it structurally transparent: the walk recursed straight through
- *   the listitem boundary into its subtree and could report a focusable
- *   descendant several levels down as a disallowed owned child of the list,
- *   instead of stopping at the (implicit) listitem the way
- *   aria-required-children already does. Switched to getContainmentRole so
- *   both rules resolve an owned child's role identically. This is a general
- *   fix, not list/listitem-specific: it applies to every container role in
- *   REQUIRED_OWNED_ROLES whose native-tag counterpart the child map covers
- *   (e.g. a bare `<tr>`/`<td>` under a role="table"/"grid"/"row" container
- *   with no explicit role="" was subject to the same flattening bug). Found
- *   via a real Angular Material-style component library: an `<a routerlink>`
- *   several DOM levels inside a bare `<li>` under `<ul role="list">` was
- *   reported as an unallowed owned child of the list.
- * - Gated on isAccTreeEligible for the container itself, matching the fix
- *   applied to aria-required-children (see that rule's header): the
- *   original "not gated" note here just cited that rule's reasoning
- *   without re-deriving it, and that reasoning turned out not to hold —
- *   a closed dialog/flyout menu populated on open is a real false-positive
- *   shape. In this rule specifically the descendant-level eligibility gate
- *   already made the container-level gate redundant for correctness (an
- *   ineligible container has no eligible descendants either, so `owned`
- *   ends up empty and nothing fails) — but skipping the container up front
- *   reports `notApplicable` instead of a vacuous `pass`, which is the more
- *   accurate outcome for a container that isn't currently exposed at all,
- *   and avoids walking a subtree whose result is already known.
+ *   table/select/input[type=radio]), the same resolution
+ *   aria-required-children's descendant matching uses — not
+ *   `getExplicitRole`, which only sees an explicit role="" attribute. A
+ *   bare `<li>` with no role="" (the common CSS-reset workaround
+ *   `<ul role="list"><li>...</li></ul>`) must still resolve to the
+ *   implicit listitem role so the walk stops at that boundary instead of
+ *   recursing straight through it into the listitem's own subtree; the
+ *   same applies to every container role in REQUIRED_OWNED_ROLES whose
+ *   native-tag counterpart the child map covers (e.g. a bare
+ *   `<tr>`/`<td>` under a role="table"/"grid"/"row" container).
+ * - Gated on isAccTreeEligible for the container itself, matching
+ *   aria-required-children: a closed dialog/flyout menu populated on open
+ *   is a real false-positive shape otherwise. The descendant-level
+ *   eligibility gate alone would make the container-level gate redundant
+ *   for correctness (an ineligible container has no eligible descendants
+ *   either, so `owned` ends up empty and nothing fails), but skipping the
+ *   container up front reports `notApplicable` instead of a vacuous
+ *   `pass` — the more accurate outcome for a container that isn't
+ *   currently exposed at all — and avoids walking a subtree whose result
+ *   is already known.
  * - No aria-busy exemption here (unlike aria-required-children): the
  *   WAI-ARIA spec's aria-busy escape hatch is specifically about a
  *   container missing its required owned elements while loading, not
@@ -111,7 +81,8 @@ const id = 'aria-prohibited-children';
 
 const meta = {
   title: 'Container roles must not own a child with a disallowed role',
-  description: 'Checks that every accessible-tree-owned child of a container role (list, listbox, menu, menubar, radiogroup, rowgroup, table, grid, treegrid, tablist, tree, row) has one of that role\'s allowed owned roles — the same set as its required owned roles.',
+  description:
+    "Checks that every accessible-tree-owned child of a container role (list, listbox, menu, menubar, radiogroup, rowgroup, table, grid, treegrid, tablist, tree, row) has one of that role's allowed owned roles — the same set as its required owned roles.",
   i18n: {
     titleKey: 'ariaProhibitedChildren_title',
     descriptionKey: 'ariaProhibitedChildren_description'
@@ -120,7 +91,13 @@ const meta = {
   tags: ['wcag2a', 'wcag412', 'aria', 'structure', 'atomic', 'automatic'],
   wcagSc: ['4.1.2'],
   normativeMappings: [
-    { standard: 'WCAG', version: '2.2', requirement: '4.1.2', title: 'Name, Role, Value', conformanceLevel: 'A' }
+    {
+      standard: 'WCAG',
+      version: '2.2',
+      requirement: '4.1.2',
+      title: 'Name, Role, Value',
+      conformanceLevel: 'A'
+    }
   ],
   defaultSeverity: 'moderate',
   category: 'robust',
@@ -130,7 +107,7 @@ const meta = {
 };
 
 function runInPage(ctx) {
-  const { document, helpers, rule } = ctx;
+  const { helpers, rule } = ctx;
 
   const ariaHelpers = helpers && helpers.aria ? helpers.aria : null;
   if (!ariaHelpers) {
@@ -138,7 +115,8 @@ function runInPage(ctx) {
   }
 
   function isEligibleAcc(el) {
-    const fn = helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+    const fn =
+      helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
     if (!fn) return true;
     try {
       const r = fn(el, ctx);
@@ -153,14 +131,32 @@ function runInPage(ctx) {
   // aria-allowed-attr.js's GLOBAL_ATTRS — duplicated, not imported, since
   // runInPage must be self-contained per scripts/build-core.js). A
   // roleless descendant carrying any of these is a real accessible-tree
-  // node a widely-used reference engine's getOwnedRoles also flags, not a transparent wrapper.
+  // node, not a transparent wrapper.
   const GLOBAL_ARIA_ATTRS = [
-    'aria-atomic', 'aria-braillelabel', 'aria-brailleroledescription', 'aria-busy',
-    'aria-controls', 'aria-current', 'aria-describedby', 'aria-description',
-    'aria-details', 'aria-disabled', 'aria-dropeffect', 'aria-errormessage',
-    'aria-flowto', 'aria-grabbed', 'aria-haspopup', 'aria-hidden', 'aria-invalid',
-    'aria-keyshortcuts', 'aria-label', 'aria-labelledby', 'aria-live', 'aria-owns',
-    'aria-relevant', 'aria-roledescription'
+    'aria-atomic',
+    'aria-braillelabel',
+    'aria-brailleroledescription',
+    'aria-busy',
+    'aria-controls',
+    'aria-current',
+    'aria-describedby',
+    'aria-description',
+    'aria-details',
+    'aria-disabled',
+    'aria-dropeffect',
+    'aria-errormessage',
+    'aria-flowto',
+    'aria-grabbed',
+    'aria-haspopup',
+    'aria-hidden',
+    'aria-invalid',
+    'aria-keyshortcuts',
+    'aria-label',
+    'aria-labelledby',
+    'aria-live',
+    'aria-owns',
+    'aria-relevant',
+    'aria-roledescription'
   ];
 
   function getGlobalAriaAttr(el) {
@@ -179,13 +175,12 @@ function runInPage(ctx) {
   // non-transparent role boundary otherwise — see header comment. A
   // roleless descendant is ALSO a non-transparent boundary (an owned
   // entry with role: null, which can never satisfy a required-role set)
-  // when it carries a global aria-* attribute or is focusable — matches
-  // a widely-used reference engine's own getOwnedRoles exactly (see header comment).
-  // kidRole comes from getContainmentRole, not getExplicitRole (see header
-  // comment's 2026-07-31 fix): "roleless" here means neither an explicit
-  // role="" NOR one of the native containment tags (li, tr, td, ...), so a
-  // bare <li>/<tr>/... is a real listitem/row boundary, not a transparent
-  // wrapper the walk should pass through.
+  // when it carries a global aria-* attribute or is focusable.
+  // kidRole comes from getContainmentRole, not getExplicitRole: "roleless"
+  // here means neither an explicit role="" NOR one of the native
+  // containment tags (li, tr, td, ...), so a bare <li>/<tr>/... is a real
+  // listitem/row boundary, not a transparent wrapper the walk should pass
+  // through.
   function collectOwnedRoles(el, requiredSet, out, depth) {
     if (depth > MAX_DEPTH) return;
     const kids = el.children ? Array.prototype.slice.call(el.children) : [];
@@ -195,13 +190,17 @@ function runInPage(ctx) {
 
       const kidRole = ariaHelpers.getContainmentRole(kid);
       const isPresentational = kidRole === 'presentation' || kidRole === 'none';
-      const isTransparentGroup = (kidRole === 'group' || kidRole === 'rowgroup') && requiredSet.has(kidRole);
+      const isTransparentGroup =
+        (kidRole === 'group' || kidRole === 'rowgroup') && requiredSet.has(kidRole);
 
       if (!kidRole && !isPresentational) {
         const globalAttr = getGlobalAriaAttr(kid);
-        let mechanism = 'none';
+        let mechanism;
         try {
-          const fi = helpers && typeof helpers.getFocusableInfo === 'function' ? helpers.getFocusableInfo(kid, ctx) : null;
+          const fi =
+            helpers && typeof helpers.getFocusableInfo === 'function'
+              ? helpers.getFocusableInfo(kid, ctx)
+              : null;
           mechanism = (fi && fi.focusable && fi.mechanism) || 'none';
         } catch {
           mechanism = 'none';
@@ -230,7 +229,9 @@ function runInPage(ctx) {
     }
   }
 
-  const nodes = helpers.queryAllSmart ? helpers.queryAllSmart('[role]') : helpers.queryAll('[role]');
+  const nodes = helpers.queryAllSmart
+    ? helpers.queryAllSmart('[role]')
+    : helpers.queryAll('[role]');
 
   const occurrences = [];
   let applicableCount = 0;
@@ -256,7 +257,9 @@ function runInPage(ctx) {
       if (entry.role && requiredSet.has(entry.role)) continue;
 
       const stableSelector = helpers.buildSelector ? helpers.buildSelector(entry.el) : 'html';
-      const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(entry.el) : (entry.el.outerHTML || '');
+      const html = helpers.getOuterHtmlSnippet
+        ? helpers.getOuterHtmlSnippet(entry.el)
+        : entry.el.outerHTML || '';
       const containerSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
 
       const isRoleless = !entry.role;
@@ -313,7 +316,12 @@ function runInPage(ctx) {
     return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
   }
   if (occurrences.length) {
-    return { ruleId: rule.ruleId, outcome: 'fail', severity: rule.defaultSeverity || 'moderate', occurrences };
+    return {
+      ruleId: rule.ruleId,
+      outcome: 'fail',
+      severity: rule.defaultSeverity || 'moderate',
+      occurrences
+    };
   }
   return { ruleId: rule.ruleId, outcome: 'pass', severity: 'minor', occurrences: [] };
 }

package/src/checks/automatic/aria-required-attr.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -18,13 +20,10 @@
  * - Deliberately scoped to REQUIRED_PROPS_BY_ROLE in src/core/aria-helpers.js,
  *   which only lists a required property when the spec is unambiguous and
  *   context-independent — see that file's header for the rationale.
- * - Widened 2026-07-21 to add `meter` (`aria-valuenow`), verified against
- *   a widely-used reference engine's own `requiredAttrs` table. Deliberately
- *   did NOT add two other entries from that same table: `progressbar`'s
- *   `aria-valuenow` (a legitimately indeterminate progressbar omits it —
- *   that engine itself excludes progressbar from its own table for this reason)
- *   and `combobox`'s `aria-controls` (confirmed via MDN's combobox role
- *   page to be conditional — only required once the popup is actually
+ * - `meter`'s `aria-valuenow` is required. Deliberately NOT required:
+ *   `progressbar`'s `aria-valuenow` (a legitimately indeterminate
+ *   progressbar omits it) and `combobox`'s `aria-controls` (conditional per
+ *   MDN's combobox role page — only required once the popup is actually
  *   displayed, not unconditionally). See src/core/aria-helpers.js's
  *   REQUIRED_PROPS_BY_ROLE comment for the full reasoning.
  * - Gated on isAccTreeEligible for the element itself: unlike a syntax-
@@ -50,7 +49,8 @@ const id = 'aria-required-attr';
 
 const meta = {
   title: 'Roles with a required ARIA state/property must carry it',
-  description: 'Checks that elements with an explicit role carry every unambiguous, context-independent required aria-* state/property for that role (e.g. role="checkbox" must have aria-checked).',
+  description:
+    'Checks that elements with an explicit role carry every unambiguous, context-independent required aria-* state/property for that role (e.g. role="checkbox" must have aria-checked).',
   i18n: {
     titleKey: 'ariaRequiredAttr_title',
     descriptionKey: 'ariaRequiredAttr_description'
@@ -59,7 +59,13 @@ const meta = {
   tags: ['wcag2a', 'wcag412', 'aria', 'structure', 'atomic', 'automatic'],
   wcagSc: ['4.1.2'],
   normativeMappings: [
-    { standard: 'WCAG', version: '2.2', requirement: '4.1.2', title: 'Name, Role, Value', conformanceLevel: 'A' }
+    {
+      standard: 'WCAG',
+      version: '2.2',
+      requirement: '4.1.2',
+      title: 'Name, Role, Value',
+      conformanceLevel: 'A'
+    }
   ],
   defaultSeverity: 'serious',
   category: 'robust',
@@ -69,7 +75,7 @@ const meta = {
 };
 
 function runInPage(ctx) {
-  const { document, helpers, rule } = ctx;
+  const { helpers, rule } = ctx;
 
   const ariaHelpers = helpers && helpers.aria ? helpers.aria : null;
   if (!ariaHelpers) {
@@ -77,7 +83,8 @@ function runInPage(ctx) {
   }
 
   function isEligibleAcc(el) {
-    const fn = helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+    const fn =
+      helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
     if (!fn) return true;
     try {
       const r = fn(el, ctx);
@@ -93,7 +100,9 @@ function runInPage(ctx) {
     return v != null && String(v).trim().toLowerCase() === 'true';
   }
 
-  const nodes = helpers.queryAllSmart ? helpers.queryAllSmart('[role]') : helpers.queryAll('[role]');
+  const nodes = helpers.queryAllSmart
+    ? helpers.queryAllSmart('[role]')
+    : helpers.queryAll('[role]');
 
   const occurrences = [];
   let applicableCount = 0;
@@ -121,7 +130,7 @@ function runInPage(ctx) {
     if (!missing.length) continue;
 
     const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
-    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : (el.outerHTML || '');
+    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : el.outerHTML || '';
 
     for (const attr of missing) {
       occurrences.push({
@@ -145,9 +154,14 @@ function runInPage(ctx) {
     return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
   }
   if (occurrences.length) {
-    return { ruleId: rule.ruleId, outcome: 'fail', severity: rule.defaultSeverity || 'serious', occurrences };
+    return {
+      ruleId: rule.ruleId,
+      outcome: 'fail',
+      severity: rule.defaultSeverity || 'serious',
+      occurrences
+    };
   }
   return { ruleId: rule.ruleId, outcome: 'pass', severity: 'minor', occurrences: [] };
 }
 
-module.exports = { id, meta, runInPage };
+module.exports = { id, meta, runInPage };

package/src/checks/automatic/aria-required-children.js

@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: MPL-2.0 */
+
 'use strict';
 
 /**
@@ -42,9 +44,7 @@
  *   widget is missing required owned elements due to script execution or
  *   loading, authors MUST mark a containing element with aria-busy equal
  *   to true." A container carrying aria-busy="true" is skipped the same
- *   way — only the exact string "true" counts (absent/"false" do not),
- *   matching a widely-used reference engine's own aria-required-children
- *   behavior.
+ *   way — only the exact string "true" counts (absent/"false" do not).
  * - Descendant search tries a fast native querySelectorAll(CANDIDATE_
  *   SELECTOR) first (covers the light-DOM-only common case with no added
  *   cost); only when that finds nothing AND the container has a <slot>
@@ -53,15 +53,15 @@
  *   querySelectorAll only sees a <slot>'s unrendered fallback content, never
  *   what's actually distributed into it. Deliberately scoped to slot
  *   expansion only, not a general "also descend into any nested custom
- *   element's own shadow root" walk — no confirmed real-world case needs
- *   that yet.
+ *   element's own shadow root" walk — no known case needs that yet.
  */
 
 const id = 'aria-required-children';
 
 const meta = {
   title: 'Container roles must own at least one required child role',
-  description: 'Checks that container roles with a documented "required owned elements" entry (list, listbox, menu, radiogroup, table, grid, tablist, tree, row, ...) contain at least one descendant or aria-owns-referenced element with an acceptable owned role.',
+  description:
+    'Checks that container roles with a documented "required owned elements" entry (list, listbox, menu, radiogroup, table, grid, tablist, tree, row, ...) contain at least one descendant or aria-owns-referenced element with an acceptable owned role.',
   i18n: {
     titleKey: 'ariaRequiredChildren_title',
     descriptionKey: 'ariaRequiredChildren_description'
@@ -70,7 +70,13 @@ const meta = {
   tags: ['wcag2a', 'wcag412', 'aria', 'structure', 'atomic', 'automatic'],
   wcagSc: ['4.1.2'],
   normativeMappings: [
-    { standard: 'WCAG', version: '2.2', requirement: '4.1.2', title: 'Name, Role, Value', conformanceLevel: 'A' }
+    {
+      standard: 'WCAG',
+      version: '2.2',
+      requirement: '4.1.2',
+      title: 'Name, Role, Value',
+      conformanceLevel: 'A'
+    }
   ],
   defaultSeverity: 'moderate',
   category: 'robust',
@@ -80,7 +86,7 @@ const meta = {
 };
 
 function runInPage(ctx) {
-  const { document, helpers, rule } = ctx;
+  const { helpers, rule } = ctx;
 
   const ariaHelpers = helpers && helpers.aria ? helpers.aria : null;
   if (!ariaHelpers) {
@@ -88,7 +94,8 @@ function runInPage(ctx) {
   }
 
   function isEligibleAcc(el) {
-    const fn = helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+    const fn =
+      helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
     if (!fn) return true;
     try {
       const r = fn(el, ctx);
@@ -109,9 +116,12 @@ function runInPage(ctx) {
   // (kept in sync with aria-helpers.js NATIVE_CONTAINMENT_ROLE_BY_ELEMENT).
   // Declared inside runInPage — see scripts/build-core.js header
   // ("runInPage MUST be self-contained").
-  const CANDIDATE_SELECTOR = '[role], li, option, tr, td, th, thead, tbody, tfoot, ul, ol, table, select, input[type="radio"]';
+  const CANDIDATE_SELECTOR =
+    '[role], li, option, tr, td, th, thead, tbody, tfoot, ul, ol, table, select, input[type="radio"]';
 
-  const nodes = helpers.queryAllSmart ? helpers.queryAllSmart('[role]') : helpers.queryAll('[role]');
+  const nodes = helpers.queryAllSmart
+    ? helpers.queryAllSmart('[role]')
+    : helpers.queryAll('[role]');
 
   const occurrences = [];
   let applicableCount = 0;
@@ -122,25 +132,26 @@ function runInPage(ctx) {
   // <slot></slot>, with the actual role="listitem" elements living in the
   // light DOM and projected in) would never find them there — same class
   // of bug as aria-required-parent's ancestor search, just in the opposite
-  // (descendant) direction. Found via Adobe Spectrum Web Components'
-  // sp-sidenav-item: its shadow root's role="list" div owns its listitems
-  // only through slot projection.
+  // (descendant) direction.
   //
   // Deliberately scoped to slot expansion only — does NOT separately
   // descend into an unrelated nested custom element's own shadow root
   // (e.g. a <my-widget> child with no <slot> involvement at all). That's a
   // qualitatively different question (does an arbitrary component's own
   // internal structure count as this container's "owned children"?) with
-  // no confirmed real-world case driving it yet; slot projection is the
-  // shape actually observed.
+  // no known case driving it yet; slot projection is the shape that
+  // actually comes up.
   function collectComposedDescendants(node, out, seen, limit) {
     if (!node || !node.children) return;
     for (const child of Array.from(node.children)) {
       if (out.length >= limit) return;
       if (seen.has(child)) continue;
 
-      if ((child.tagName || '').toLowerCase() === 'slot' && typeof child.assignedElements === 'function') {
-        let assigned = [];
+      if (
+        (child.tagName || '').toLowerCase() === 'slot' &&
+        typeof child.assignedElements === 'function'
+      ) {
+        let assigned;
         try {
           assigned = child.assignedElements({ flatten: true }) || [];
         } catch {
@@ -184,7 +195,7 @@ function runInPage(ctx) {
     // selector, exactly as before this fix — covers the overwhelming
     // majority of containers (no shadow DOM involved at all) with zero
     // added cost.
-    let descendants = [];
+    let descendants;
     try {
       descendants = el.querySelectorAll(CANDIDATE_SELECTOR);
     } catch {
@@ -202,7 +213,7 @@ function runInPage(ctx) {
     // <slot> somewhere in the subtree to expand — bounds the extra cost to
     // exactly the containers that could possibly need it.
     if (!found) {
-      let hasSlot = false;
+      let hasSlot;
       try {
         hasSlot = !!el.querySelector('slot');
       } catch {
@@ -243,7 +254,7 @@ function runInPage(ctx) {
     if (found) continue;
 
     const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
-    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : (el.outerHTML || '');
+    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : el.outerHTML || '';
 
     occurrences.push({
       selector: stableSelector,
@@ -256,7 +267,11 @@ function runInPage(ctx) {
         params: { role, requiredRoles: requiredOwned.join(', ') }
       },
       data: {
-        details: { reasonCode: 'ARIA_REQUIRED_CHILD_MISSING', role, requiredOwnedRoles: requiredOwned }
+        details: {
+          reasonCode: 'ARIA_REQUIRED_CHILD_MISSING',
+          role,
+          requiredOwnedRoles: requiredOwned
+        }
       }
     });
   }
@@ -265,9 +280,14 @@ function runInPage(ctx) {
     return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
   }
   if (occurrences.length) {
-    return { ruleId: rule.ruleId, outcome: 'fail', severity: rule.defaultSeverity || 'moderate', occurrences };
+    return {
+      ruleId: rule.ruleId,
+      outcome: 'fail',
+      severity: rule.defaultSeverity || 'moderate',
+      occurrences
+    };
   }
   return { ruleId: rule.ruleId, outcome: 'pass', severity: 'minor', occurrences: [] };
 }
 
-module.exports = { id, meta, runInPage };
+module.exports = { id, meta, runInPage };