@surea11y/core 1.0.0

package/src/checks/manual/media-transcript-present-manual.js

@@ -0,0 +1,373 @@
+'use strict';
+
+/**
+ * @check media-alternative-transcript-evidence
+ * @atomic
+ * @summary Detects time-based media elements (<audio>/<video>) where a transcript / text alternative
+ *          is not strongly evidenced in-page. Designed for WCAG 2.2 SC 1.2.1 (A).
+ * @standard WCAG
+ * @sc 1.2.1
+ * @applicability Any eligible <audio> or <video> element in the composed DOM.
+ * @expectation If a strong transcript/text-alternative signal is present (e.g., aria-describedby binding to
+ *              a visible transcript block, or a nearby clearly labeled Transcript section/link), no occurrence is reported.
+ *              Otherwise, the rule reports cantTell (insufficient evidence) for that media element.
+ */
+
+const id = 'media-alternative-transcript-evidence';
+
+const meta = {
+  title: 'Time-based media: transcript / media alternative evidence',
+  description:
+    'Finds <audio>/<video> elements where a transcript or other text alternative is not strongly evidenced in-page. ' +
+    'This rule is conservative and returns cantTell when evidence is missing or unverified.',
+  i18n: {
+    titleKey: 'mediaTranscriptPresent_title',
+    descriptionKey: 'mediaTranscriptPresent_description'
+  },
+  helpUrl: null,
+  tags: ['wcag2a', 'wcag121', 'timebasedmedia', 'media', 'atomic', 'manual'],
+  wcagSc: ['1.2.1'],
+  normativeMappings: [
+    {
+      standard: 'WCAG',
+      version: '2.2',
+      requirement: '1.2.1',
+      title: 'Audio-only and Video-only (Prerecorded)',
+      conformanceLevel: 'A'
+    }
+  ],
+  defaultSeverity: 'moderate',
+  category: 'perceivable',
+  type: 'manual',
+  defaultConfidence: 'low',
+  coverage: { facetsBySc: { '1.2.1': ['transcript-evidence'] } }
+};
+
+function runInPage(ctx) {
+  const { document, root, helpers, rule } = ctx;
+  const safeRoot = root || document;
+
+  // Conservative keyword set (deterministic). Includes common EN/FR terms.
+  // Keep this list strict to avoid false positives.
+  const TRANSCRIPT_TOKENS = [
+    'transcript',
+    'transcription',
+    'texte intégral',
+    'compte rendu',
+    'verbatim'
+  ];
+
+  // Minimum transcript body length to be considered "substantial" when used as evidence.
+  // (Avoids treating short summaries as transcripts.)
+  const MIN_TRANSCRIPT_CHARS = 200;
+
+  // If aria-describedby contains no transcript token, require a larger body to consider it evidence.
+  const MIN_DESCRIBEDBY_CHARS_WITHOUT_TOKEN = 400;
+
+  function normText(s) {
+    if (!s) return '';
+    return String(s).replace(/\s+/g, ' ').trim().toLowerCase();
+  }
+
+  function containsTranscriptToken(s) {
+    const t = normText(s);
+    if (!t) return false;
+    for (const tok of TRANSCRIPT_TOKENS) {
+      if (t.includes(tok)) return true;
+    }
+    return false;
+  }
+
+  function textLen(s) {
+    const t = normText(s);
+    return t ? t.length : 0;
+  }
+
+  function getNodeText(el) {
+    try {
+      if (!el) return '';
+      return el.textContent || '';
+    } catch (e) {
+      return '';
+    }
+  }
+
+  function isElement(el) {
+    return !!(el && el.nodeType === 1);
+  }
+
+  const __eligCache = new WeakMap();
+
+  function getEligibility(node) {
+    if (!node || node.nodeType !== 1) return { eligible: true, reasons: [], targetSet: 'acc', accEligible: null };
+    const cached = __eligCache.get(node);
+    if (cached) return cached;
+
+    let info = null;
+    try {
+      info = (helpers && typeof helpers.getEligibilityInfo === 'function')
+          ? helpers.getEligibilityInfo(node, ctx, { targetSet: 'acc' })
+          : null;
+    } catch {
+      info = null;
+    }
+
+    const norm = (info && typeof info === 'object')
+        ? info
+        : { eligible: true, reasons: [], targetSet: 'acc', accEligible: null };
+
+    __eligCache.set(node, norm);
+    return norm;
+  }
+
+  function isEligible(node) {
+    const info = getEligibility(node);
+    return !!(info && info.eligible);
+  }
+
+  function safeSelector(node) {
+    return helpers.buildSelector ? helpers.buildSelector(node) : 'html';
+  }
+
+  // Evidence object includes strength, so the rule can treat "unverified external link" as insufficient proof.
+  function evidenceNone() {
+    return {
+      strength: 'none', // none | weak | strong
+      method: 'none',
+      transcriptNodeSelector: null,
+      transcriptLinkHref: null,
+      notes: []
+    };
+  }
+
+  function nodeRef(el) {
+    try {
+      if (!el || el.nodeType !== 1) return null;
+      const elementId = el.getAttribute && el.getAttribute('id');
+      if (elementId) return { type: 'id', value: String(elementId) };
+      const tag = (el.tagName || '').toLowerCase();
+      return { type: 'tag', value: tag };
+    } catch {
+      return null;
+    }
+  }
+
+  const __evidenceCache = new WeakMap();
+
+  // Walk a small neighborhood around the media element to find transcript cues.
+  // Bounded for determinism and performance.
+  function findTranscriptEvidence(mediaEl) {
+    const evidence = evidenceNone();
+
+    // 1) aria-describedby strong binding
+    const descInfo = helpers.getAccessibleDescriptionInfo
+      ? helpers.getAccessibleDescriptionInfo(mediaEl, ctx)
+      : null;
+
+    if (descInfo && descInfo.mechanism === 'aria-describedby') {
+      const descText = descInfo.value || '';
+      const hasToken = containsTranscriptToken(descText);
+      const len = textLen(descText);
+
+      // Strong signal if the described text clearly indicates transcript, or is very substantial.
+      if (hasToken || len >= MIN_DESCRIBEDBY_CHARS_WITHOUT_TOKEN) {
+        evidence.strength = 'strong';
+        evidence.method = 'aria-describedby';
+        evidence.notes.push('media has aria-describedby with explicit or substantial transcript text');
+        return evidence;
+      }
+    }
+
+    // 2) In-container transcript heading + substantial visible text
+    const parent = mediaEl.parentElement;
+    if (isElement(parent) && isEligible(parent)) {
+      const headings = parent.querySelectorAll('h1,h2,h3,h4,h5,h6');
+      for (const h of headings) {
+        if (!isEligible(h)) continue;
+        const hText = getNodeText(h);
+        if (!containsTranscriptToken(hText)) continue;
+
+        // Look at a small set of following siblings for substantial text (and ensure visibility).
+        let sib = h.nextElementSibling;
+        let steps = 0;
+        while (isElement(sib) && steps < 4) {
+          if (isEligible(sib)) {
+            const sibText = getNodeText(sib);
+            if (textLen(sibText) >= MIN_TRANSCRIPT_CHARS) {
+              evidence.strength = 'strong';
+              evidence.method = 'adjacent-heading';
+              evidence.transcriptNodeSelector = nodeRef(h);
+              evidence.notes.push('found transcript heading with substantial visible adjacent text');
+              return evidence;
+            }
+          }
+          sib = sib.nextElementSibling;
+          steps += 1;
+        }
+      }
+    }
+
+    // 3) Nearby explicit transcript link
+    // - Same-document anchors can be verified (strong).
+    // - Cross-document links are unverified (weak).
+    if (isElement(parent) && isEligible(parent)) {
+      const links = parent.querySelectorAll('a[href]');
+      for (const a of links) {
+        if (!isEligible(a)) continue;
+
+        const nameInfo = helpers.getAccessibleNameInfo ? helpers.getAccessibleNameInfo(a, ctx) : null;
+        const linkName = nameInfo && nameInfo.value ? nameInfo.value : getNodeText(a);
+        if (!containsTranscriptToken(linkName)) continue;
+
+        const href = a.getAttribute('href') || '';
+        evidence.transcriptLinkHref = href;
+        evidence.transcriptNodeSelector = nodeRef(a);
+
+        // 3a) Same-document anchor: resolve and verify target content has transcript heading + substance.
+        if (href.startsWith('#')) {
+          const targetId = href.slice(1);
+          const target = targetId
+            ? (safeRoot.getElementById ? safeRoot.getElementById(targetId) : document.getElementById(targetId))
+            : null;
+
+          if (isElement(target) && isEligible(target)) {
+            // Find a transcript heading in the target, and ensure there is substantial text in the target subtree.
+            const targetHeadings = target.querySelectorAll('h1,h2,h3,h4,h5,h6');
+            let hasTranscriptHeading = false;
+            for (const th of targetHeadings) {
+              if (!isEligible(th)) continue;
+              if (containsTranscriptToken(getNodeText(th))) {
+                hasTranscriptHeading = true;
+                break;
+              }
+            }
+            const targetText = getNodeText(target);
+
+            if (hasTranscriptHeading && textLen(targetText) >= MIN_TRANSCRIPT_CHARS) {
+              evidence.strength = 'strong';
+              evidence.method = 'anchor-target';
+              evidence.notes.push('resolved transcript link to an on-page section with transcript heading and substantial text');
+              return evidence;
+            }
+          }
+
+          // If anchor cannot be verified, treat as weak (still better than nothing, but not proof).
+          evidence.strength = 'weak';
+          evidence.method = 'anchor-unverified';
+          evidence.notes.push('transcript link found but anchor target could not be verified as a transcript section');
+          return evidence;
+        }
+
+        // 3b) External or cross-document link: do not treat as proof without crawling.
+        evidence.strength = 'weak';
+        evidence.method = 'external-link';
+        evidence.notes.push('transcript link found but cannot verify content without crawling');
+        return evidence;
+      }
+    }
+
+    return evidence;
+  }
+
+  const occurrences = [];
+  let applicableCount = 0;
+
+  const nodes = helpers.queryAllSmart
+    ? helpers.queryAllSmart('audio,video')
+    : helpers.queryAll('audio,video');
+
+  for (const el of nodes) {
+    const eligInfo = getEligibility(el);
+    if (!eligInfo || !eligInfo.eligible) continue;
+
+    applicableCount += 1;
+
+    // Evidence must be computed and cached per media element: two sibling
+    // <audio>/<video> elements under the same container do not necessarily
+    // share the same transcript evidence (e.g. one has a strong
+    // aria-describedby binding, the other has none). Keying this cache by
+    // the shared container instead of the element itself previously caused
+    // an undocumented sibling to silently inherit another element's
+    // evidence classification.
+    let evidence = __evidenceCache.get(el);
+    if (!evidence) {
+      evidence = findTranscriptEvidence(el);
+      __evidenceCache.set(el, evidence);
+    }
+
+    const mediaTag = (el.tagName || '').toLowerCase();
+
+    if (evidence.strength === 'none') {
+      const baseOccurrence = {
+        summary:
+            'A transcript or other text alternative for this time-based media is not strongly evidenced on the page.',
+        hint:
+            'Provide a clearly identified transcript or other text alternative for audio-only/video-only prerecorded media (for example, a “Transcript” section or link).',
+        i18n: {
+          summaryKey: 'mediaTranscriptPresent_summary_cantTell_missing',
+          hintKey: 'mediaTranscriptPresent_hint_cantTell_missing',
+          params: { element: mediaTag }
+        },
+        data: {
+          details: {
+            reasonCode: 'transcriptNotDetected',
+            mediaTag,
+            evidence
+          },
+          visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] }
+        }
+      };
+
+      if (helpers && typeof helpers.reportOccurrence === 'function') {
+        occurrences.push(helpers.reportOccurrence(el, baseOccurrence));
+      } else {
+        occurrences.push({ selector: '', html: '', ...baseOccurrence });
+      }
+      continue;
+    }
+
+    if (evidence.strength === 'weak') {
+
+      const baseOccurrence = {
+        summary:
+            'A transcript or other text alternative may be available for this time-based media, but it could not be verified from the page content.',
+        hint:
+            'Ensure a clearly identified transcript or other text alternative is available and programmatically or visibly associated with the media on the page.',
+        i18n: {
+          summaryKey: 'mediaTranscriptPresent_summary_cantTell_unverified',
+          hintKey: 'mediaTranscriptPresent_hint_cantTell_unverified',
+          params: { element: mediaTag }
+        },
+        data: {
+          details: {
+            reasonCode: 'transcriptEvidenceUnverified',
+            mediaTag,
+            evidence
+          },
+          visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] }
+        }
+      };
+
+      if (helpers && typeof helpers.reportOccurrence === 'function') {
+        occurrences.push(helpers.reportOccurrence(el, baseOccurrence));
+      } else {
+        occurrences.push({ selector: '', html: '', ...baseOccurrence });
+      }
+    }
+  }
+
+  if (applicableCount === 0) {
+    return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+  }
+
+  if (occurrences.length) {
+    return { ruleId: rule.ruleId, outcome: 'cantTell', severity: rule.defaultSeverity || 'minor', occurrences };
+  }
+
+  // Manual rules may only emit cantTell/notApplicable (never pass/fail).
+  // Strong evidence was found for all applicable media elements, so there
+  // is nothing to flag for review.
+  return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+}
+
+module.exports = { id, meta, runInPage };

package/src/checks/manual/meta-viewport-large-manual.js

@@ -0,0 +1,119 @@
+'use strict';
+
+/**
+ * @check meta-viewport-large
+ * @atomic true
+ * @summary Viewport meta tag should allow zooming up to 500% (AAA-level)
+ * @standard Best Practices (a widely-used reference engine's classification; no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
+ * @applicability
+ *   Applies to <meta name="viewport"> elements that carry a non-empty
+ *   content attribute.
+ * @expectation
+ *   The content attribute does not set user-scalable to "no"/"0", and
+ *   does not set maximum-scale below 5 (500%). This is the AAA-level,
+ *   stricter counterpart of meta-viewport-zoom-enabled (which
+ *   enforces the AA 200% minimum as a hard, WCAG-normative fail); this
+ *   rule is advisory best-practice guidance toward the higher AAA bar.
+ * @implementation-notes
+ * - Not WCAG-normative — authored as an advisory, cantTell-capped
+ *   `type: 'manual'` rule; see landmark-banner-is-top-level's
+ *   header comment for the shared rationale/precedent.
+ * - Distinct, atomic decision from meta-viewport-zoom-enabled
+ *   (that rule is the hard-fail 200% floor; this one is the softer 500%
+ *   best-practice ceiling target).
+ */
+
+const id = 'meta-viewport-large';
+
+const meta = {
+  title: 'Viewport meta tag should allow zooming up to 500%',
+  description: 'Checks that <meta name="viewport"> does not set user-scalable=no or maximum-scale below 5 (500%).',
+  i18n: {
+    titleKey: 'metaViewportLarge_title',
+    descriptionKey: 'metaViewportLarge_description'
+  },
+  helpUrl: null,
+  tags: ['best-practice', 'structure', 'atomic', 'manual'],
+  wcagSc: [],
+  normativeMappings: [],
+  defaultSeverity: 'minor',
+  category: 'perceivable',
+  type: 'manual',
+  defaultConfidence: 'medium',
+  coverage: {}
+};
+
+function runInPage(ctx) {
+  const { document, helpers, rule } = ctx;
+
+  function parseContent(raw) {
+    const out = {};
+    for (const pair of String(raw || '').split(/[,;]/)) {
+      const eq = pair.indexOf('=');
+      if (eq === -1) continue;
+      const key = pair.slice(0, eq).trim().toLowerCase();
+      const value = pair.slice(eq + 1).trim().toLowerCase();
+      if (key) out[key] = value;
+    }
+    return out;
+  }
+
+  const nodes = document.querySelectorAll ? document.querySelectorAll('meta[name="viewport" i]') : [];
+
+  const occurrences = [];
+  let applicableCount = 0;
+
+  for (const el of nodes) {
+    if (!el || !el.getAttribute) continue;
+    const raw = String(el.getAttribute('content') || '').trim();
+    if (!raw) continue;
+
+    applicableCount += 1;
+
+    const parsed = parseContent(raw);
+    const reasons = [];
+
+    const userScalable = parsed['user-scalable'];
+    if (userScalable === 'no' || userScalable === '0') {
+      reasons.push('user-scalable=' + userScalable);
+    }
+
+    const maxScaleRaw = parsed['maximum-scale'];
+    if (maxScaleRaw !== undefined) {
+      const maxScale = parseFloat(maxScaleRaw);
+      if (!Number.isNaN(maxScale) && maxScale < 5) {
+        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 zoom below the 500% best-practice target.',
+      hint: 'Remove user-scalable=no and raise maximum-scale to at least 5 (500%) if possible.',
+      i18n: {
+        summaryKey: 'metaViewportLarge_summary_cantTell',
+        hintKey: 'metaViewportLarge_hint_cantTell',
+        params: { reasons: reasons.join(', ') }
+      },
+      data: {
+        details: { reasonCode: 'VIEWPORT_ZOOM_BELOW_500', reasons }
+      }
+    });
+  }
+
+  if (applicableCount === 0) {
+    return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+  }
+  if (occurrences.length) {
+    return { ruleId: rule.ruleId, outcome: 'cantTell', severity: rule.defaultSeverity || 'minor', occurrences };
+  }
+  return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+}
+
+module.exports = { id, meta, runInPage };

package/src/checks/manual/mouse-only-event-handlers-manual.js

@@ -0,0 +1,134 @@
+'use strict';
+
+/**
+ * @check mouse-only-event-handlers
+ * @atomic true
+ * @summary Pointer-only inline event handlers should have a keyboard-reachable equivalent
+ * @standard WCAG 2.2
+ * @sc 2.1.1
+ * @applicability
+ *   Elements carrying at least one inline pointer-only event-handler
+ *   attribute (`onmouseover`, `onmouseout`, `onmousedown`, `onmouseup`,
+ *   `ondblclick`, `onmousemove`, `onmouseenter`, `onmouseleave`) with a
+ *   non-empty value, that are also eligible/reachable (not
+ *   hidden/`aria-hidden`/`display:none`).
+ * @expectation
+ *   The element also carries at least one keyboard-reachable inline
+ *   handler: `onkeydown`, `onkeyup`, `onkeypress` (the direct keyboard-
+ *   event equivalents), or `onfocus`/`onblur` (the standard substitute
+ *   for hover-triggered behavior — focus/blur are the keyboard-
+ *   navigable analog to mouseover/mouseout, per WCAG technique G90).
+ *   Otherwise the element's mouse-driven behavior (a hover tooltip, a
+ *   custom dropdown, a drag interaction) has no way to be triggered by a
+ *   keyboard-only user.
+ * @implementation-notes
+ * - Authored as `type: 'manual'` (cantTell-capped, never fail), not
+ *   `automatic`: this can only see inline `on*="..."` HTML attributes —
+ *   a keyboard handler attached elsewhere via `addEventListener` (the
+ *   norm in most modern frameworks) is invisible to a static markup
+ *   scan and would make a `fail` a false positive. Surfaced by a diff
+ *   against a legacy ruleset's WCAG2AA rules (see ROADMAP.md's Tier 4
+ *   research notes) — this is a real, well-known WCAG 2.1.1 anti-pattern
+ *   (technique G90/F54) that nothing else in this rule set checks.
+ * - Deliberately does NOT treat `onclick` as a keyboard-equivalent
+ *   excuse: whether `onclick` is keyboard-reachable depends on the
+ *   element's separate focusability (native interactive tag or
+ *   `tabindex`), which this rule does not attempt to cross-check — and
+ *   for the specific hover-triggered handlers this rule targets
+ *   (`onmouseover`/`onmouseout`/etc.), `onclick` isn't actually an
+ *   equivalent interaction model regardless of focusability (hover and
+ *   click are different gestures with different semantics).
+ * - Only inline HTML attribute handlers are detectable; JS-attached
+ *   listeners (`addEventListener('mouseover', ...)`) are invisible to a
+ *   static DOM scan — a documented limitation, not an oversight.
+ */
+
+const id = 'mouse-only-event-handlers';
+
+const meta = {
+  title: 'Pointer-only inline event handlers should have a keyboard-reachable equivalent',
+  description:
+    'Flags elements with an inline pointer-only event handler (onmouseover, onmouseout, onmousedown, onmouseup, ondblclick, onmousemove, onmouseenter, onmouseleave) and no keyboard-reachable equivalent (onkeydown/onkeyup/onkeypress/onfocus/onblur), for manual review.',
+  i18n: {
+    titleKey: 'mouseOnlyEventHandlers_title',
+    descriptionKey: 'mouseOnlyEventHandlers_description'
+  },
+  helpUrl: null,
+  tags: ['wcag2a', 'wcag211', 'structure', 'atomic', 'manual'],
+  wcagSc: ['2.1.1'],
+  normativeMappings: [
+    { standard: 'WCAG', version: '2.2', requirement: '2.1.1', title: 'Keyboard', conformanceLevel: 'A' }
+  ],
+  defaultSeverity: 'moderate',
+  category: 'operable',
+  type: 'manual',
+  defaultConfidence: 'low',
+  coverage: { facetsBySc: { '2.1.1': ['mouse-only-event-handlers-evidence'] } }
+};
+
+function runInPage(ctx) {
+  const { document, root, helpers, rule } = ctx;
+  const safeRoot = root || document;
+
+  const MOUSE_ONLY_ATTRS = [
+    'onmouseover', 'onmouseout', 'onmousedown', 'onmouseup',
+    'ondblclick', 'onmousemove', 'onmouseenter', 'onmouseleave'
+  ];
+  const KEYBOARD_EQUIV_ATTRS = ['onkeydown', 'onkeyup', 'onkeypress', 'onfocus', 'onblur'];
+
+  function trim(v) { return (v == null ? '' : String(v)).trim(); }
+
+  const selector = MOUSE_ONLY_ATTRS.map((a) => `[${a}]`).join(', ');
+  const nodes = helpers.queryAllSmart ? helpers.queryAllSmart(selector, safeRoot) : helpers.queryAll(selector, safeRoot);
+
+  const occurrences = [];
+  let applicableCount = 0;
+
+  for (const el of nodes) {
+    if (!el || !el.getAttribute) continue;
+
+    const presentMouseAttrs = MOUSE_ONLY_ATTRS.filter((a) => trim(el.getAttribute(a)));
+    if (!presentMouseAttrs.length) continue;
+
+    const eligResult = helpers.isAccTreeEligible ? helpers.isAccTreeEligible(el, ctx) : true;
+    const eligible = typeof eligResult === 'boolean' ? eligResult : !!(eligResult && eligResult.eligible);
+    if (!eligible) continue;
+
+    applicableCount += 1;
+
+    const hasKeyboardEquiv = KEYBOARD_EQUIV_ATTRS.some((a) => trim(el.getAttribute(a)));
+    if (hasKeyboardEquiv) continue;
+
+    const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
+    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : (el.outerHTML || '');
+    const eligInfo = helpers.getEligibilityInfo ? helpers.getEligibilityInfo(el, ctx, { targetSet: 'acc' }) : null;
+
+    occurrences.push({
+      selector: stableSelector,
+      html,
+      summary: `This element has ${presentMouseAttrs.join(', ')} but no keyboard-reachable equivalent handler.`,
+      hint: 'Add onkeydown/onkeyup/onkeypress (or onfocus/onblur for hover-triggered behavior) so this functionality is also reachable by keyboard.',
+      i18n: {
+        summaryKey: 'mouseOnlyEventHandlers_summary_cantTell',
+        hintKey: 'mouseOnlyEventHandlers_hint_cantTell',
+        params: { attrs: presentMouseAttrs.join(', ') }
+      },
+      data: {
+        details: { reasonCode: 'MOUSE_ONLY_HANDLER_NO_KEYBOARD_EQUIVALENT', mouseAttrs: presentMouseAttrs },
+        visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] }
+      }
+    });
+  }
+
+  if (applicableCount === 0) {
+    return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+  }
+
+  if (occurrences.length) {
+    return { ruleId: rule.ruleId, outcome: 'cantTell', severity: rule.defaultSeverity || 'moderate', occurrences };
+  }
+
+  return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+}
+
+module.exports = { id, meta, runInPage };