@surea11y/core 1.5.0 → 1.7.0

package/src/checks/automatic/table-headers-attr-valid.js

@@ -9,11 +9,18 @@
  * @standard WCAG 2.2
  * @sc 1.3.1
  * @applicability
- *   Applies to <td>/<th> elements that carry a non-empty headers attribute.
+ *   Applies to <td>/<th> elements that carry a non-empty headers attribute,
+ *   within a <table> whose semantic role is still table/grid/treegrid --
+ *   an explicit role of anything else (role="presentation"/"none", but
+ *   also role="heading" or any other real role) replaces the native table
+ *   semantics, leaving no table for headers to describe. Matches ACT
+ *   a25f45's applicability.
  * @expectation
  *   Every id token in the headers attribute resolves to an element that:
- *   (a) exists, (b) is a <th> element, (c) is inside the same <table> as
- *   the referencing cell, and (d) is not the cell itself.
+ *   (a) exists, (b) is a cell (<td> or <th>) of the same <table> as the
+ *   referencing cell, and (c) is not the cell itself. A <td> serving as a
+ *   header via role="columnheader"/"rowheader" is a valid target, same as
+ *   a plain <th> -- ACT a25f45 does not require the native tag.
  * @implementation-notes
  * - One occurrence per offending cell (not per bad token), listing every
  *   invalid reference.
@@ -27,7 +34,7 @@ const id = 'table-headers-attr-valid';
 const meta = {
   title: 'Table cell "headers" attribute must reference valid header cells',
   description:
-    'Checks that each id in a <td>/<th> headers attribute resolves to a <th> element within the same table (not missing, not a non-th element, not itself).',
+    'Checks that each id in a <td>/<th> headers attribute resolves to a cell (<td> or <th>) within the same table (not missing, not a non-cell element, not itself).',
   i18n: {
     titleKey: 'tableHeadersAttrValid_title',
     descriptionKey: 'tableHeadersAttrValid_description'
@@ -54,6 +61,23 @@ const meta = {
 function runInPage(ctx) {
   const { document, helpers, rule } = ctx;
 
+  const ariaHelpers = helpers && helpers.aria ? helpers.aria : null;
+
+  // The role attribute holds a fallback list; the first token naming a real
+  // role wins, and unknown tokens are skipped over.
+  function getExplicitRole(el) {
+    const raw = el && el.getAttribute ? el.getAttribute('role') : null;
+    if (!raw) return '';
+    const tokens = String(raw).trim().toLowerCase().split(/\s+/);
+    for (const token of tokens) {
+      if (!token) continue;
+      if (token === 'presentation' || token === 'none') return token;
+      const known = ariaHelpers ? ariaHelpers.isValidConcreteRole(token) : true;
+      if (known) return token;
+    }
+    return '';
+  }
+
   const nodes = helpers.queryAllSmart
     ? helpers.queryAllSmart('td[headers], th[headers]')
     : helpers.queryAll('td[headers], th[headers]');
@@ -69,9 +93,19 @@ function runInPage(ctx) {
     const ids = raw.split(/\s+/).filter(Boolean);
     if (!ids.length) continue;
 
+    const table = el.closest ? el.closest('table') : null;
+
+    // An explicit role on the <table> replaces its native table role. Only
+    // the three roles that still describe a table keep the cell's headers
+    // attribute meaningful; anything else (presentation/none, heading, ...)
+    // takes the whole table out of scope. Unknown tokens name no role, so
+    // the native one stands.
+    const tableRole = table ? getExplicitRole(table) : '';
+    if (tableRole && tableRole !== 'table' && tableRole !== 'grid' && tableRole !== 'treegrid')
+      continue;
+
     applicableCount += 1;
 
-    const table = el.closest ? el.closest('table') : null;
     const invalid = [];
 
     for (const headerId of ids) {
@@ -90,8 +124,9 @@ function runInPage(ctx) {
         invalid.push({ id: headerId, reason: 'self-reference' });
         continue;
       }
-      if (!ref.tagName || ref.tagName.toLowerCase() !== 'th') {
-        invalid.push({ id: headerId, reason: 'not-a-th' });
+      const refTag = ref.tagName ? ref.tagName.toLowerCase() : '';
+      if (refTag !== 'th' && refTag !== 'td') {
+        invalid.push({ id: headerId, reason: 'not-a-cell' });
         continue;
       }
       if (table && (!ref.closest || ref.closest('table') !== table)) {
@@ -108,7 +143,7 @@ function runInPage(ctx) {
     occurrences.push(
       helpers.reportOccurrence(el, {
         summary: 'This cell’s headers attribute references one or more invalid header cells.',
-        hint: 'Update the headers attribute so every id refers to a <th> element within the same table.',
+        hint: 'Update the headers attribute so every id refers to a cell (<td> or <th>) within the same table.',
         i18n: {
           summaryKey: 'tableHeadersAttrValid_summary_fail',
           hintKey: 'tableHeadersAttrValid_hint_fail',

package/src/checks/automatic/table-th-has-data-cells.js

@@ -12,26 +12,29 @@
  *   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.
+ *   explicit role other than rowheader/columnheader. Also applies to the
+ *   ARIA-only equivalent: an element with role="grid"/"treegrid" (no
+ *   native <table> involved) that contains at least one in-scope
+ *   columnheader/rowheader-role element.
  * @expectation
  *   The table also contains at least one <td> somewhere in it.
  * @implementation-notes
- * - DELIBERATELY SCOPED (see aria-helpers.js file header for the same
+ * - SCOPED (see aria-helpers.js file header for the same
  *   conservative-scope rationale used throughout this engine): this rule
  *   does NOT implement the full HTML5 header-association algorithm
  *   (resolving which specific data cells a given <th scope="row"|"col">
  *   describes, accounting for colspan/rowspan and default-scope
  *   inference). That algorithm is one of the more error-prone parts of
  *   the HTML spec to reimplement correctly, and a wrong positional match
- *   would risk a false `fail` — unacceptable for this engine's fail-
+ *   would risk a false `fail`, unacceptable for this engine's fail-
  *   integrity bar.
  * - Instead, this rule only catches the single unambiguous case: a table
  *   that has <th> elements but ZERO <td> elements anywhere. In that case
- *   every <th> in the table trivially describes no data cell — no
+ *   every <th> in the table trivially describes no data cell, no
  *   positional analysis is needed to know that. A table that has at
  *   least one <td> somewhere is not evaluated further by this rule, even
  *   if some particular <th> in it doesn't actually describe any cell
- *   (false negative, not a false positive — acceptable under this
+ *   (false negative, not a false positive, acceptable under this
  *   engine's philosophy).
  * - Applicability IS gated, because the zero-<td> case above turns any
  *   over-broad scope straight into a false fail: a layout table marked
@@ -174,6 +177,59 @@ function runInPage(ctx) {
     }
   }
 
+  // ARIA-only equivalent: a role="grid"/"treegrid" container with no
+  // backing <table> at all. Same trivial "zero data cells anywhere" check,
+  // just keyed off ARIA roles instead of native tags -- a genuine
+  // columnheader/rowheader with zero gridcell/cell-role elements anywhere
+  // in the container is exactly as unambiguous as a <th>-only <table>.
+  const grids = helpers.queryAllSmart
+    ? helpers.queryAllSmart('[role="grid"], [role="treegrid"]')
+    : helpers.queryAll('[role="grid"], [role="treegrid"]');
+
+  for (const grid of grids) {
+    if (!grid || !grid.querySelectorAll) continue;
+    if (grid.tagName && grid.tagName.toLowerCase() === 'table') continue; // already handled above
+    if (!isIncludedInTree(grid)) continue;
+
+    let headerNodes;
+    try {
+      headerNodes = grid.querySelectorAll('[role="columnheader"], [role="rowheader"]');
+    } catch {
+      headerNodes = [];
+    }
+    const headers = Array.from(headerNodes).filter(isHeaderCellInScope);
+    if (!headers.length) continue;
+
+    applicableCount += 1;
+
+    let hasDataCell;
+    try {
+      hasDataCell = grid.querySelectorAll('[role="gridcell"], [role="cell"]').length > 0;
+    } catch {
+      hasDataCell = false;
+    }
+    if (hasDataCell) continue;
+
+    for (const th of headers) {
+      if (!th) continue;
+
+      occurrences.push(
+        helpers.reportOccurrence(th, {
+          summary: 'This table has header cells but no data cells for them to describe.',
+          hint: 'Add data cells (<td>) to the table, or remove the header cells if the table has no data.',
+          i18n: {
+            summaryKey: 'tableThHasDataCells_summary_fail',
+            hintKey: 'tableThHasDataCells_hint_fail',
+            params: {}
+          },
+          data: {
+            details: { reasonCode: 'TABLE_TH_NO_DATA_CELLS' }
+          }
+        })
+      );
+    }
+  }
+
   if (applicableCount === 0) {
     return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
   }

package/src/checks/automatic/target-size-minimum.js

@@ -8,6 +8,24 @@
  * @summary Pointer-operable targets should be at least 24×24 CSS px (or meet an exception)
  * @standard WCAG 2.2
  * @sc 2.5.8
+ * @applicability
+ *   Applies to <button>, <summary>, <a href>, <area href>, <input>,
+ *   <select>, <textarea> and elements with role="button"/"link" that are
+ *   pointer-reachable: rendered, not suppressed by pointer-events:none, and
+ *   with a measurable box of non-zero size. Accessibility-tree exclusion isn't
+ *   a filter here: an aria-hidden control is still a target a pointer can hit.
+ *   <area> is matched but never actually evaluated, for the reason given below.
+ * @expectation
+ *   Each target is at least 24 by 24 CSS pixels, or meets one of the SC
+ *   2.5.8 exceptions this rule can establish from geometry: spacing (a
+ *   24px-diameter circle centred on the target reaches no unrelated target),
+ *   the inline exception for a link inside a run of text, or user-agent
+ *   sizing (an unstyled native checkbox or radio, detected by appearance not
+ *   having been reset to none). An undersized target too close to a
+ *   neighbour fails. Where an exception may apply but geometry cannot
+ *   confirm it (two inline links in one run of text, or a target inside an
+ *   SVG, canvas or image map that may be essential), the result is cantTell
+ *   rather than a guess.
  *
  * Notes (engine intent):
  * - This rule is DOM-based and measures pointer hit regions available to sighted pointer users.
@@ -19,42 +37,43 @@
  * - Spacing: a 24px-diameter circle centered on an undersized target must not
  *   intersect another (unrelated) target's box or another undersized
  *   target's own circle. Two passes: a fast center-distance check (exact for
- *   undersized-vs-undersized; a reasonable proxy otherwise) and a 16-point
+ *   undersized-vs-undersized, a reasonable proxy otherwise) and a 16-point
  *   perimeter sample via elementFromPoint as a more precise fallback for
  *   cases the distance check under-detects (e.g. a small target adjacent to
  *   a large, elongated neighbor). Ancestor/descendant relationships between
- *   the target and the "other" element are never treated as a conflict —
- *   see isRelated — since a nested-interactive shape (a small control inside
- *   its own wrapping link/button) is one visual region, not two independent
- *   targets; that pattern is nested-interactive-controls-absent's
- *   concern, not a spacing one.
+ *   the target and the "other" element are never treated as a conflict (see
+ *   isRelated): a nested-interactive shape, a small control inside its own
+ *   wrapping link/button, is one visual region, not two independent targets.
+ *   That pattern is nested-interactive-controls-absent's concern, not a
+ *   spacing one.
  * - Inline: a link inside a text-block container passes outright
  *   (isInlineTextExceptionTarget). An inline link whose only spacing conflict
  *   is another inline link in the same run is reported as cantTell
- *   (isInlineLinkTarget) — the inline exception may cover it, but geometry
- *   can't confirm that.
+ *   (isInlineLinkTarget), since the inline exception may cover it but
+ *   geometry can't confirm that.
  * - User Agent Control: an unstyled native checkbox/radio, detected via
- *   `appearance` not being reset to `none` (see isUserAgentSizedControl) —
- *   scoped narrowly to checkbox/radio specifically, not every form control,
+ *   `appearance` not being reset to `none` (see isUserAgentSizedControl).
+ *   Scoped narrowly to checkbox/radio specifically, not every form control,
  *   since those are the only types with unambiguous native rendering.
  * - Essential/Equivalent: only a narrow, high-confidence subset is asserted
- *   (SVG/canvas/map-embedded controls) — see isPlausiblyEssentialOrEquivalent;
+ *   (SVG/canvas/map-embedded controls, see isPlausiblyEssentialOrEquivalent);
  *   anything else defers to cantTell rather than guessing "essential" from a
  *   layout container.
  *
- * Known, deliberately unimplemented gap: `<area>` (image-map hotspot)
+ * Known gap, left unimplemented on purpose: `<area>` (image-map hotspot)
  * elements are not evaluated at all. `area[href]` is in CANDIDATE_SELECTOR
- * for forward-compatibility, but it's currently a no-op: `<area>` has no
+ * for forward-compatibility, but it's currently a no-op. `<area>` has no
  * CSS box of its own (`display: none` by the HTML spec's default UA
- * stylesheet — verified, not a jsdom quirk), so `getBoundingClientRect()`
- * always reports zero geometry and `isPointerReachable`'s existing
- * `display:none` check rejects it before any size/exception logic runs. A
- * real `<area>` hit-region is computed by the browser from its `shape`/
- * `coords` attributes against the associated `<img>`'s *rendered* size —
- * an entirely different measurement path than every other candidate here.
- * Implementing that properly (parsing `coords`, resolving the owning
- * `<img>` via its `usemap`, accounting for the image's CSS-scaled render
- * size) is a separate, larger feature, not attempted in this pass.
+ * stylesheet, confirmed against the spec rather than a jsdom quirk), so
+ * `getBoundingClientRect()` always reports zero geometry and
+ * `isPointerReachable`'s existing `display:none` check rejects it before any
+ * size/exception logic runs. A real `<area>` hit-region is computed by the
+ * browser from its `shape`/`coords` attributes against the associated
+ * `<img>`'s *rendered* size, an entirely different measurement path than
+ * every other candidate here. Implementing that properly (parsing `coords`,
+ * resolving the owning `<img>` via its `usemap`, accounting for the image's
+ * CSS-scaled render size) is a separate, larger feature, not attempted in
+ * this pass.
  *
  * This is an automatic, deterministic approximation intended to be:
  * - strict on clear failures,
@@ -64,7 +83,8 @@
 const id = 'target-size-minimum';
 
 const meta = {
-  title: 'Pointer targets meet minimum size (AA)',
+  title:
+    'Pointer targets must be at least 24x24px large, or leave sufficient distance to other targets',
   description:
     'Checks that pointer-operable targets have an effective hit region of at least 24 by 24 CSS pixels, or meet an allowed exception (e.g. sufficient spacing).',
   i18n: {
@@ -273,14 +293,29 @@ function runInPage(ctx) {
     }
   }
 
+  // Per-run memoization: getComputedStyle is a real, non-trivial cost in an
+  // actual browser (unlike jsdom, which no-ops it), and hasSpacingConflict
+  // below calls getStyle on the SAME candidate element repeatedly -- once
+  // per undersized target it's compared against, via
+  // isInlineTextExceptionTarget/isInlineLinkTarget -- so with U undersized
+  // targets and N total candidates this was an uncached O(U * N)
+  // getComputedStyle call count. The DOM is read-only for the rest of this
+  // rule's run (no writes between reads), so caching per element here is
+  // safe -- style cannot change mid-run.
+  const __styleCache = new WeakMap();
   function getStyle(el) {
+    if (__styleCache.has(el)) return __styleCache.get(el);
+    let cs;
     try {
-      return document && document.defaultView && document.defaultView.getComputedStyle
-        ? document.defaultView.getComputedStyle(el)
-        : null;
+      cs =
+        document && document.defaultView && document.defaultView.getComputedStyle
+          ? document.defaultView.getComputedStyle(el)
+          : null;
     } catch {
-      return null;
+      cs = null;
     }
+    __styleCache.set(el, cs);
+    return cs;
   }
 
   function isPointerReachable(el) {
@@ -354,11 +389,11 @@ function runInPage(ctx) {
   // element, or either one is an ancestor of the other. A nested-interactive
   // pattern (e.g. a small <button> inside a wrapping <a href>, or vice
   // versa) is a single visual/interactive region, not two independently
-  // placed targets — the spacing exception's "does the circle intersect
+  // placed targets. The spacing exception's "does the circle intersect
   // ANOTHER target" language is about separate targets, not an element and
   // its own container. (Nested interactive controls are their own,
-  // separately-flagged anti-pattern — nested-interactive-controls-
-  // absent — not a target-size spacing concern.)
+  // separately-flagged anti-pattern, nested-interactive-controls-absent,
+  // not a target-size spacing concern.)
   function isRelated(a, b) {
     try {
       if (!a || !b) return false;
@@ -411,14 +446,54 @@ function runInPage(ctx) {
 
   const undersized = items.filter((it) => it.rect.width < MIN || it.rect.height < MIN);
 
+  // Spatial grid over ALL items, cell size = MIN (24px), so hasSpacingConflict's
+  // proximity check below doesn't have to compare every undersized target
+  // against every other item -- an O(items^2) cost that dominates real-browser
+  // (not jsdom -- see this rule's own perf note further down) runtime on a
+  // page with many small targets. A point can only be within MIN of another
+  // point that shares its grid cell or one of the 8 adjacent cells: cell size
+  // equals the search radius, so two points in cells 2+ apart on either axis
+  // are, on that axis alone, already >= MIN apart. Restricting the candidate
+  // set to that 3x3 neighborhood is therefore never a false negative -- the
+  // exact same dist() < MIN check still runs on every candidate it returns,
+  // just skipping candidates that are geometrically guaranteed too far away.
+  // This changes performance only, never which targets conflict.
+  const grid = new Map(); // "cx,cy" -> item[]
+  function cellKeyFor(cx, cy) {
+    return cx + ',' + cy;
+  }
+  for (const it of items) {
+    const cx = Math.floor(it.center.cx / MIN);
+    const cy = Math.floor(it.center.cy / MIN);
+    const key = cellKeyFor(cx, cy);
+    let bucket = grid.get(key);
+    if (!bucket) {
+      bucket = [];
+      grid.set(key, bucket);
+    }
+    bucket.push(it);
+  }
+  function nearbyItems(center) {
+    const cx = Math.floor(center.cx / MIN);
+    const cy = Math.floor(center.cy / MIN);
+    const out = [];
+    for (let dx = -1; dx <= 1; dx++) {
+      for (let dy = -1; dy <= 1; dy++) {
+        const bucket = grid.get(cellKeyFor(cx + dx, cy + dy));
+        if (bucket) for (const it of bucket) out.push(it);
+      }
+    }
+    return out;
+  }
+
   // --- spacing/occlusion evaluation ---
   function hasSpacingConflict(target) {
     // 0) Pure geometry: deterministic center-distance check against ANY
     // nearby target, not just other undersized ones. Per WCAG 2.5.8, the
-    // spacing exception depends on proximity to any adjacent target — an
+    // spacing exception depends on proximity to any adjacent target, so an
     // undersized target sitting flush against an adequately-sized one still
     // fails the exception, which an undersized-only comparison would miss.
-    for (const other of items) {
+    for (const other of nearbyItems(target.center)) {
       if (!other || !other.el || isRelated(target.el, other.el)) continue;
 
       // Ignore inline-text exception targets when evaluating spacing conflicts.
@@ -439,8 +514,8 @@ function runInPage(ctx) {
     // as a confident conflict. Perimeter sampling is an approximation
     // (rounded corners, border-radius, and sub-pixel geometry can shift a
     // sample point in or out of a neighboring element), so a result that
-    // merely reaches HIT_THRESHOLD is not asserted as a deterministic
-    // fail — see the ambiguous band below.
+    // merely reaches HIT_THRESHOLD is not asserted as a deterministic fail.
+    // See the ambiguous band below.
     const CONFIDENT_THRESHOLD = 5;
     let hitCount = 0;
     let firstConflictEl = null;
@@ -486,20 +561,20 @@ function runInPage(ctx) {
 
   // WCAG 2.5.8 "User Agent Control" exception: the target's size requirement
   // does not apply at all when its size is determined by the user agent and
-  // not modified by the author — the canonical example being an unstyled
-  // native checkbox/radio (browsers render these well under 24px by
-  // default, and that's not the author's choice). Scoped narrowly to
-  // input[type=checkbox]/[type=radio] specifically (the only form-control
-  // types with a universally-recognized, unambiguous native rendering) —
-  // deliberately not extended to select/range/color/file, whose "default"
-  // sizing varies enough across browsers/OSes that a wrong exemption there
-  // risks masking a real author-introduced undersized target.
+  // not modified by the author. The canonical example is an unstyled native
+  // checkbox/radio (browsers render these well under 24px by default, and
+  // that's not the author's choice). Scoped narrowly to
+  // input[type=checkbox]/[type=radio] specifically, the only form-control
+  // types with a universally-recognized, unambiguous native rendering, and
+  // not extended to select/range/color/file, whose "default" sizing varies
+  // enough across browsers/OSes that a wrong exemption there risks masking a
+  // real author-introduced undersized target.
   //
   // Detection signal: `appearance` (or the legacy `-webkit-appearance`)
   // computed as `none` is the near-universal first step of custom
-  // checkbox/radio styling across every CSS framework/design system —
-  // if the author hasn't reset it, the browser is still rendering its own
-  // default control chrome, so the size is genuinely UA-determined.
+  // checkbox/radio styling across every CSS framework/design system. If the
+  // author hasn't reset it, the browser is still rendering its own default
+  // control chrome, so the size is UA-determined rather than authored.
   function isUserAgentSizedControl(el) {
     try {
       if (!el || el.nodeType !== 1) return false;
@@ -545,8 +620,8 @@ function runInPage(ctx) {
       // Image map targets are often constrained by the underlying image.
       // Currently unreachable in practice: <area> never becomes a
       // measurable candidate at all (see the file header's "Known,
-      // deliberately unimplemented gap" note) — kept for forward
-      // compatibility if that gap is closed later.
+      // unimplemented gap" note). Kept for forward compatibility if that
+      // gap is closed later.
       if (tag === 'area') return true;
 
       // Graphics / spatial interaction regions are commonly essential by design.
@@ -570,7 +645,7 @@ function runInPage(ctx) {
 
     // User Agent Control exception: size isn't the author's choice, so the
     // size requirement (and therefore any spacing conflict stemming from
-    // it) doesn't apply at all — skip straight to pass, no need to even
+    // it) doesn't apply at all. Skip straight to pass, no need to even
     // evaluate spacing.
     if (isUserAgentSizedControl(it.el)) {
       continue;
@@ -579,12 +654,10 @@ function runInPage(ctx) {
     const info = hasSpacingConflict(it);
 
     if (!info.conflict && info.confident === false) {
-      // Ambiguous perimeter-sampling result near the decision threshold —
-      // previously recorded only as a page-level boolean with no per-target
-      // occurrence at all, so this specific target was unrecoverable from
-      // the result once any other target on the page had a confident
-      // fail (see helpers.resolveTieredOutcome's header comment). Now
-      // reported as its own cantTell-tier occurrence instead.
+      // Ambiguous perimeter-sampling result near the decision threshold: report
+      // it as its own cantTell-tier occurrence for this target so it isn't lost
+      // once any other target on the page has a confident fail (see
+      // helpers.resolveTieredOutcome's header comment).
       cantTellOccurrences.push(
         helpers.reportOccurrence(it.el, {
           occurrenceOutcome: 'cantTell',
@@ -596,6 +669,14 @@ function runInPage(ctx) {
             hintKey: 'targetSizeMinimum_hint_cantTell_ambiguousSpacing',
             params: {}
           },
+          uncertainty: {
+            code: 'not-computable',
+            needed: 'A reliable measurement of the spacing between this target and its neighbour.',
+            evidence: {
+              measured: { width: it.rect.width, height: it.rect.height },
+              conflictHitCount: info.hitCount
+            }
+          },
           data: {
             details: {
               measured: { width: it.rect.width, height: it.rect.height },
@@ -612,19 +693,27 @@ function runInPage(ctx) {
     if (info.conflict) {
       if (isPlausiblyEssentialOrEquivalent(it.el)) {
         // Confident spacing conflict, but the target may be exempt as part
-        // of an essential graphic/image-map region — same "previously
-        // unrecoverable" gap as above, now reported instead of dropped.
+        // of an essential graphic/image-map region, so report it as
+        // cantTell rather than dropping it.
         cantTellOccurrences.push(
           helpers.reportOccurrence(it.el, {
             occurrenceOutcome: 'cantTell',
             summary:
               'Target is too small and too close to another target, but may be exempt as part of an essential graphic or image-map region.',
-            hint: 'Verify whether this target’s size is genuinely essential to its function (e.g. part of an SVG/canvas/image map); if not, increase target size or spacing.',
+            hint: 'Verify whether this target’s size is essential to its function (e.g. part of an SVG/canvas/image map); if not, increase target size or spacing.',
             i18n: {
               summaryKey: 'targetSizeMinimum_summary_cantTell_plausiblyEssential',
               hintKey: 'targetSizeMinimum_hint_cantTell_plausiblyEssential',
               params: {}
             },
+            uncertainty: {
+              code: 'judgement-required',
+              needed: 'Whether this target’s size is essential, which WCAG exempts.',
+              evidence: {
+                measured: { width: it.rect.width, height: it.rect.height },
+                conflictHitCount: info.hitCount
+              }
+            },
             data: {
               details: {
                 measured: { width: it.rect.width, height: it.rect.height },
@@ -653,6 +742,14 @@ function runInPage(ctx) {
               hintKey: 'targetSizeMinimum_hint_cantTell_inlineLinkRun',
               params: {}
             },
+            uncertainty: {
+              code: 'judgement-required',
+              needed: 'Whether this target is a link in a sentence, which WCAG exempts.',
+              evidence: {
+                measured: { width: it.rect.width, height: it.rect.height },
+                conflictHitCount: info.hitCount
+              }
+            },
             data: {
               details: {
                 measured: { width: it.rect.width, height: it.rect.height },
@@ -691,7 +788,7 @@ function runInPage(ctx) {
 
   // See helpers.resolveTieredOutcome's own header comment (src/core/dom-helpers.js):
   // a fail-tier finding never silently discards cantTell-tier findings from
-  // the same run — both are returned together when the outcome is 'fail'.
+  // the same run. Both are returned together when the outcome is 'fail'.
   const resolved = helpers.resolveTieredOutcome(
     failOccurrences,
     cantTellOccurrences,

package/src/checks/automatic/td-has-header.js

@@ -11,7 +11,7 @@
  * @applicability
  *   `<table>` elements with at least 4 rows and at least 4 columns
  *   (a "large" table, where implicit row/column header association is
- *   genuinely useful — small tables are usually self-evident), and with
+ *   useful; small tables are usually self-evident), and with
  *   NO `colspan`/`rowspan` anywhere in the table.
  * @expectation
  *   Every `<td>` has an associated header, via one of:
@@ -22,14 +22,14 @@
  *       earlier row, OR
  *     - an implicit row header: some `<th>` earlier in the same row.
  * @implementation-notes
- * - Closes the gap `table-th-has-data-cells` deliberately deferred (see
+ * - Closes the gap `table-th-has-data-cells` deferred (see
  *   that rule's own implementation notes): this is the fuller positional
- *   header-association algorithm, but still intentionally scoped —
+ *   header-association algorithm, but still intentionally scoped,
  *   tables with any `colspan`/`rowspan` are skipped entirely (marked
  *   `notApplicable`) rather than risk a wrong column-index computation
  *   producing a false `fail`.
  * - The `headers`-attribute branch does not itself validate that the
- *   referenced ids exist or point at `<th>` elements — that's already
+ *   referenced ids exist or point at `<th>` elements, that's already
  *   `table-headers-attr-valid`'s job.
  */
 
@@ -38,7 +38,7 @@ const id = 'td-has-header';
 const meta = {
   title: 'Data cells in large tables must have an associated header',
   description:
-    'Checks that every <td> in a large, simple (no colspan/rowspan) table has an associated header — via a headers attribute, an implicit column <th> above it, or an implicit row <th> to its left.',
+    'Checks that every <td> in a large, simple (no colspan/rowspan) table has an associated header, via a headers attribute, an implicit column <th> above it, or an implicit row <th> to its left.',
   i18n: {
     titleKey: 'tdHasHeader_title',
     descriptionKey: 'tdHasHeader_description'
@@ -118,27 +118,28 @@ function runInPage(ctx) {
       return !!(cell && cell.tagName && cell.tagName.toLowerCase() === 'th' && isEligible(cell));
     }
 
-    function hasColumnHeaderAbove(r, c) {
-      for (let ri = 0; ri < r; ri++) {
-        const cell = rowCells[ri] && rowCells[ri][c];
-        if (isHeaderCell(cell)) return true;
-      }
-      return false;
-    }
-
-    function hasRowHeaderBefore(r, c) {
-      const cells = rowCells[r] || [];
-      for (let ci = 0; ci < c; ci++) {
-        if (isHeaderCell(cells[ci])) return true;
-      }
-      return false;
-    }
+    // "Was there a <th> above this cell's column" and "was there a <th>
+    // earlier in this cell's row" are both prefix questions over a scan
+    // already in progress (rows top to bottom, cells left to right within a
+    // row), so each is tracked incrementally instead of rescanning the
+    // rows/columns already passed for every cell: colHasHeaderAbove[c]
+    // carries forward across rows, rowHasHeaderBefore resets at the start
+    // of each row. One pass over every cell, not one rescan per cell.
+    const colHasHeaderAbove = new Array(maxCols).fill(false);
 
     for (let r = 0; r < rowCells.length; r++) {
       const cells = rowCells[r];
+      let rowHasHeaderBefore = false;
+
       for (let c = 0; c < cells.length; c++) {
         const cell = cells[c];
-        if (!cell || isHeaderCell(cell)) continue;
+        if (!cell) continue;
+
+        if (isHeaderCell(cell)) {
+          colHasHeaderAbove[c] = true;
+          rowHasHeaderBefore = true;
+          continue;
+        }
 
         // An aria-hidden data cell isn't exposed to AT either, so it has
         // no need for an accessible header association.
@@ -147,8 +148,8 @@ function runInPage(ctx) {
         const headersAttr = trim(cell.getAttribute('headers'));
         if (headersAttr) continue;
 
-        if (hasColumnHeaderAbove(r, c)) continue;
-        if (hasRowHeaderBefore(r, c)) continue;
+        if (colHasHeaderAbove[c]) continue;
+        if (rowHasHeaderBefore) continue;
 
         occurrences.push(
           helpers.reportOccurrence(cell, {