@surea11y/core 1.4.0 → 1.5.0

package/src/checks/automatic/css-orientation-lock.js

@@ -156,7 +156,7 @@ function runInPage(ctx) {
     for (const r of rules) {
       if (!r) continue;
       if (r.type === CSS_STYLE_RULE && isLockingRotation(r.style)) {
-        findings.push({ mediaText, selectorText: trim(r.selectorText) || '(unknown selector)' });
+        findings.push({ mediaText, selectorText: trim(r.selectorText) });
       }
     }
   }
@@ -196,28 +196,28 @@ function runInPage(ctx) {
   }
 
   const target = document.documentElement || document.body || null;
-  const stableSelector = helpers.buildSelector && target ? helpers.buildSelector(target) : 'html';
-  const html =
-    helpers.getOuterHtmlSnippet && target ? helpers.getOuterHtmlSnippet(target) : '<html>';
-
-  const occurrences = findings.map((f) => ({
-    selector: stableSelector,
-    html,
-    summary: `A "${f.mediaText}" media query rotates "${f.selectorText}", locking the page to one orientation.`,
-    hint: 'Remove the rotate() transform from the orientation media query; let the page respond naturally to device orientation instead of forcing a visual rotation.',
-    i18n: {
-      summaryKey: 'cssOrientationLock_summary_fail',
-      hintKey: 'cssOrientationLock_hint_fail',
-      params: { mediaText: f.mediaText, selectorText: f.selectorText }
-    },
-    data: {
-      details: {
-        reasonCode: 'ORIENTATION_MEDIA_ROTATE_TRANSFORM',
-        mediaText: f.mediaText,
-        selectorText: f.selectorText
+  const occurrences = findings.map((f) =>
+    helpers.reportOccurrence(target, {
+      summary: f.selectorText
+        ? `A "${f.mediaText}" media query rotates "${f.selectorText}", locking the page to one orientation.`
+        : `A "${f.mediaText}" media query rotates an element with no readable selector, locking the page to one orientation.`,
+      hint: 'Remove the rotate() transform from the orientation media query; let the page respond naturally to device orientation instead of forcing a visual rotation.',
+      i18n: {
+        summaryKey: f.selectorText
+          ? 'cssOrientationLock_summary_fail'
+          : 'cssOrientationLock_summary_fail_unknownSelector',
+        hintKey: 'cssOrientationLock_hint_fail',
+        params: { mediaText: f.mediaText, selectorText: f.selectorText }
+      },
+      data: {
+        details: {
+          reasonCode: 'ORIENTATION_MEDIA_ROTATE_TRANSFORM',
+          mediaText: f.mediaText,
+          selectorText: f.selectorText
+        }
       }
-    }
-  }));
+    })
+  );
 
   return {
     ruleId: rule.ruleId,

package/src/checks/automatic/definition-list-children-valid.js

@@ -121,9 +121,6 @@ function runInPage(ctx) {
         : null;
     if (!reasonCode) continue;
 
-    const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
-    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : el.outerHTML || '';
-
     const summary = invalidTags.length
       ? 'This description list contains a direct or wrapped child that is not part of a dt/dd group.'
       : 'This description list has no <dt>/<dd> term-definition group.';
@@ -131,24 +128,24 @@ function runInPage(ctx) {
       ? 'Only use <dt>/<dd> (optionally wrapped in one <div>), <script>, <template>, or <style> inside <dl>.'
       : 'Add at least one <dt>/<dd> pair inside this <dl>.';
 
-    occurrences.push({
-      selector: stableSelector,
-      html,
-      summary,
-      hint,
-      i18n: {
-        summaryKey: invalidTags.length
-          ? 'definitionListChildrenValid_summary_fail_invalidChild'
-          : 'definitionListChildrenValid_summary_fail_noDtDd',
-        hintKey: invalidTags.length
-          ? 'definitionListChildrenValid_hint_fail_invalidChild'
-          : 'definitionListChildrenValid_hint_fail_noDtDd',
-        params: { invalidChildren: dedupedInvalidTags.join(', ') }
-      },
-      data: {
-        details: { reasonCode, invalidChildren: invalidTags }
-      }
-    });
+    occurrences.push(
+      helpers.reportOccurrence(el, {
+        summary,
+        hint,
+        i18n: {
+          summaryKey: invalidTags.length
+            ? 'definitionListChildrenValid_summary_fail_invalidChild'
+            : 'definitionListChildrenValid_summary_fail_noDtDd',
+          hintKey: invalidTags.length
+            ? 'definitionListChildrenValid_hint_fail_invalidChild'
+            : 'definitionListChildrenValid_hint_fail_noDtDd',
+          params: { invalidChildren: dedupedInvalidTags.join(', ') }
+        },
+        data: {
+          details: { reasonCode, invalidChildren: invalidTags }
+        }
+      })
+    );
   }
 
   if (applicableCount === 0) {

package/src/checks/automatic/deprecated-elements-not-used.js

@@ -72,23 +72,21 @@ function runInPage(ctx) {
     applicableCount += 1;
 
     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 element’s content cannot be paused, stopped, or hidden by the user.',
-      hint: 'Remove this element; use static content, or an animation with a user-facing pause/stop control, instead.',
-      i18n: {
-        summaryKey: 'deprecatedElements_summary_fail',
-        hintKey: 'deprecatedElements_hint_fail',
-        params: { element: tag }
-      },
-      data: {
-        details: { reasonCode: 'DEPRECATED_NON_STOPPABLE_ELEMENT', element: tag }
-      }
-    });
+    occurrences.push(
+      helpers.reportOccurrence(el, {
+        summary: 'This element’s content cannot be paused, stopped, or hidden by the user.',
+        hint: 'Remove this element; use static content, or an animation with a user-facing pause/stop control, instead.',
+        i18n: {
+          summaryKey: 'deprecatedElements_summary_fail',
+          hintKey: 'deprecatedElements_hint_fail',
+          params: { element: tag }
+        },
+        data: {
+          details: { reasonCode: 'DEPRECATED_NON_STOPPABLE_ELEMENT', element: tag }
+        }
+      })
+    );
   }
 
   if (applicableCount === 0) {

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

@@ -74,9 +74,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);
@@ -133,24 +140,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 dialog has no accessible name.',
-      hint: 'Provide aria-labelledby (preferred) or aria-label so assistive technologies can announce the dialog.',
-      i18n: {
-        summaryKey: 'dialogNamePresent_summary_fail',
-        hintKey: 'dialogNamePresent_hint_fail',
-        params: { role }
-      },
-      data: {
-        details: { reasonCode: 'name_missing', controlType: role, methodTried: res.method },
-        visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] }
-      }
-    });
+
+    occurrences.push(
+      helpers.reportOccurrence(el, {
+        summary: 'This dialog has no accessible name.',
+        hint: 'Provide aria-labelledby (preferred) or aria-label so assistive technologies can announce the dialog.',
+        i18n: {
+          summaryKey: 'dialogNamePresent_summary_fail',
+          hintKey: 'dialogNamePresent_hint_fail',
+          params: { role }
+        },
+        data: {
+          details: { reasonCode: 'name_missing', controlType: role, methodTried: res.method },
+          visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] }
+        }
+      })
+    );
   }
 
   if (applicableCount === 0) {

package/src/checks/automatic/dlitem-parent-valid.js

@@ -80,23 +80,21 @@ function runInPage(ctx) {
     if (valid) continue;
 
     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 description-list item is not contained by a <dl>.',
-      hint: 'Place this <dt>/<dd> inside a <dl>, directly or wrapped in a single <div>.',
-      i18n: {
-        summaryKey: 'dlitemParentValid_summary_fail',
-        hintKey: 'dlitemParentValid_hint_fail',
-        params: { element: tag, parentElement: parentTag }
-      },
-      data: {
-        details: { reasonCode: 'DLITEM_INVALID_PARENT', element: tag, parentElement: parentTag }
-      }
-    });
+
+    occurrences.push(
+      helpers.reportOccurrence(el, {
+        summary: 'This description-list item is not contained by a <dl>.',
+        hint: 'Place this <dt>/<dd> inside a <dl>, directly or wrapped in a single <div>.',
+        i18n: {
+          summaryKey: 'dlitemParentValid_summary_fail',
+          hintKey: 'dlitemParentValid_hint_fail',
+          params: { element: tag, parentElement: parentTag }
+        },
+        data: {
+          details: { reasonCode: 'DLITEM_INVALID_PARENT', element: tag, parentElement: parentTag }
+        }
+      })
+    );
   }
 
   if (applicableCount === 0) {

package/src/checks/automatic/duplicate-id-aria.js

@@ -15,15 +15,16 @@
  *   attribute (i.e. at least one ARIA ID reference exists to resolve).
  * @expectation
  *   For every id value referenced by one of those attributes, exactly one
- *   element in the document carries that id. A duplicated id referenced by
- *   ARIA is ambiguous: assistive technologies cannot reliably determine
- *   which element the reference resolves to (typically the first, silently
- *   dropping the others).
+ *   element in the document carries that id. A duplicate does not break the
+ *   reference: it resolves to the first element in tree order, so the name is
+ *   still computed. Whether that element is the intended target depends on
+ *   author intent, which markup does not carry, so the outcome is cantTell.
  * @implementation-notes
  * - Scoped deliberately to ids referenced by ARIA, not the broader/
  *   deprecated page-wide duplicate-id check (see ROADMAP.md's "Skip" list).
  * - Document-wide by design: id uniqueness and ARIA id references are a
- *   whole-document property, not scoped to a sub-root.
+ *   whole-document property, not scoped to a sub-root. Reported occurrences are
+ *   limited to the scanned scope.
  */
 
 const id = 'duplicate-id-aria';
@@ -95,51 +96,58 @@ function runInPage(ctx) {
     }
   }
 
-  const occurrences = [];
+  // Detection is document-wide; occurrences are limited to the scanned scope.
+  let inScope = null;
+  if (helpers && typeof helpers.queryAllSmart === 'function') {
+    try {
+      const scoped = helpers.queryAllSmart('[id]');
+      inScope = new Set(Array.isArray(scoped) ? scoped : Array.from(scoped || []));
+    } catch {
+      inScope = null;
+    }
+  }
+
+  const cantTellOccurrences = [];
 
   for (const refId of referencedIds) {
     const els = idMap.get(refId) || [];
     if (els.length <= 1) continue;
 
     for (const el of els) {
-      const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
-      const html = helpers.getOuterHtmlSnippet
-        ? helpers.getOuterHtmlSnippet(el)
-        : el.outerHTML || '';
-
-      occurrences.push({
-        selector: stableSelector,
-        html,
-        summary: 'This id is referenced by an ARIA attribute but is used by more than one element.',
-        hint: 'Make ids referenced by ARIA attributes unique within the document.',
-        i18n: {
-          summaryKey: 'duplicateIdAria_summary_fail',
-          hintKey: 'duplicateIdAria_hint_fail',
-          params: { id: refId, duplicateCount: String(els.length) }
-        },
-        data: {
-          details: {
-            reasonCode: 'DUPLICATE_ID_ARIA_REFERENCED',
-            id: refId,
-            duplicateCount: els.length
+      if (inScope && !inScope.has(el)) continue;
+
+      cantTellOccurrences.push(
+        helpers.reportOccurrence(el, {
+          summary:
+            'This id is referenced by an ARIA attribute but is used by more than one element; the reference resolves to the first.',
+          hint: 'Confirm the first element carrying this id is the intended target, or make the id unique.',
+          i18n: {
+            summaryKey: 'duplicateIdAria_summary_cantTell',
+            hintKey: 'duplicateIdAria_hint_cantTell',
+            params: { id: refId, duplicateCount: String(els.length) }
+          },
+          data: {
+            details: {
+              reasonCode: 'DUPLICATE_ID_ARIA_REFERENCED',
+              id: refId,
+              duplicateCount: els.length
+            }
           }
-        }
-      });
+        })
+      );
     }
   }
 
   if (referencedIds.size === 0) {
     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: 'pass', severity: 'minor', occurrences: [] };
+
+  const resolved = helpers.resolveTieredOutcome(
+    [],
+    cantTellOccurrences,
+    rule.defaultSeverity || 'serious'
+  );
+  return { ruleId: rule.ruleId, ...resolved };
 }
 
 module.exports = { id, meta, runInPage };

package/src/checks/automatic/form-control-programmatic-label-present.js

@@ -73,8 +73,15 @@ const meta = {
 function runInPage(ctx) {
   const { helpers, rule } = ctx;
 
-  const isAccTreeEligible =
-    helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+  // ACT e086e5 applies only to controls included in the accessibility tree, so
+  // a focusable control 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 getEligibilityInfo =
     helpers && typeof helpers.getEligibilityInfo === 'function' ? helpers.getEligibilityInfo : null;
 
@@ -85,6 +92,41 @@ function runInPage(ctx) {
 
   const trim = (v) => (v == null ? '' : String(v)).trim();
 
+  // Roles with their own *-name-present rule; a control carrying one
+  // explicitly is skipped here so it is reported once.
+  const ROLE_OWNED_ELSEWHERE = [
+    'alertdialog',
+    'button',
+    'checkbox',
+    'combobox',
+    'dialog',
+    'grid',
+    'link',
+    'listbox',
+    'menu',
+    'menubar',
+    'menuitem',
+    'menuitemcheckbox',
+    'menuitemradio',
+    'meter',
+    'option',
+    'progressbar',
+    'radio',
+    'radiogroup',
+    'scrollbar',
+    'searchbox',
+    'slider',
+    'spinbutton',
+    'switch',
+    'tab',
+    'tablist',
+    'textbox',
+    'toolbar',
+    'tooltip',
+    'tree',
+    'treeitem'
+  ];
+
   const metrics = {
     applicableCount: 0,
     passCount: 0,
@@ -108,9 +150,9 @@ function runInPage(ctx) {
   }
 
   function isEligibleAcc(el) {
-    if (!isAccTreeEligible) return true;
+    if (!isEligibleHelper) return true;
     try {
-      const r = isAccTreeEligible(el, ctx);
+      const r = isEligibleHelper(el, ctx);
       if (typeof r === 'boolean') return r;
       return !!(r && r.eligible);
     } catch {
@@ -193,6 +235,8 @@ function runInPage(ctx) {
       role = '';
     }
 
+    if (role && ROLE_OWNED_ELSEWHERE.indexOf(role) !== -1) continue;
+
     if (role === 'presentation' || role === 'none') {
       const fi = getFocusableInfo
         ? (() => {

package/src/checks/automatic/form-control-single-label.js

@@ -12,20 +12,29 @@
  *   Applies to labelable form controls (input, excluding
  *   hidden/submit/reset/button/image; select; textarea).
  * @expectation
- *   At most one <label> is associated with the control — either by
- *   wrapping it, or by a <label for="..."> pointing to its id
- *   (deduplicated: a label that both wraps the control and
- *   self-references it via for counts once). Multiple associated labels
- *   are ambiguous: many screen readers only announce one of them, and it
- *   is not deterministic which.
+ *   At most one <label> that can contribute to the control's accessible name
+ *   is associated with it — by wrapping it, or by a <label for="..."> on its
+ *   id (a label that both wraps and self-references via for counts once).
+ *   Graded by whether the surplus labels actually compete for the name:
+ *   - PASS when an override (aria-labelledby / aria-label) supersedes every
+ *     native <label>: the labels then contribute nothing to the name, so
+ *     they cannot be ambiguous. A visible-label-vs-name mismatch is SC 2.5.3
+ *     Label in Name's concern, not this rule's.
+ *   - FAIL when two or more non-empty labels compete and there is no
+ *     override: screen readers announce a non-deterministic subset.
+ *   - CANTTELL when one non-empty label is joined by empty label
+ *     association(s) and there is no override: the name usually resolves to
+ *     the real label, but handling of the empty association is not
+ *     guaranteed across user agents.
+ *   All-empty associations with no override are a missing-name case (the
+ *   sibling rule below), not an ambiguity, so this rule stays silent.
  * @implementation-notes
  * - Distinct, atomic decision from form-control-programmatic-label-present
- *   (that rule checks a label exists at all; this one checks there is at
- *   most one).
- * - A label that isn't accessibility-tree-eligible (display:none,
- *   aria-hidden, etc.) is excluded before counting: it can't contribute to
- *   the control's accessible name, so it can't create the ambiguity this
- *   rule exists to catch.
+ *   (that rule checks a label exists at all; this one checks at most one
+ *   matters). Whether a label contributes a name is decided by the shared
+ *   helpers.labelContributesAccessibleName, so the two rules agree.
+ * - Accessibility-tree-ineligible labels (display:none, aria-hidden, etc.)
+ *   are excluded before counting: they can't contribute to the name.
  */
 
 const id = 'form-control-single-label';
@@ -62,6 +71,12 @@ function runInPage(ctx) {
 
   const isAccTreeEligible =
     helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+  const getAriaNameInfo =
+    helpers && typeof helpers.getAriaNameInfo === 'function' ? helpers.getAriaNameInfo : null;
+  const labelContributesName =
+    helpers && typeof helpers.labelContributesAccessibleName === 'function'
+      ? helpers.labelContributesAccessibleName
+      : null;
 
   const selector =
     'input:not([type="hidden"]):not([type="submit"]):not([type="reset"]):not([type="button"]):not([type="image"]),select,textarea';
@@ -82,7 +97,8 @@ function runInPage(ctx) {
     labelsByFor.get(forValue).push(lab);
   }
 
-  const occurrences = [];
+  const failOccurrences = [];
+  const cantTellOccurrences = [];
   let applicableCount = 0;
 
   for (const el of nodes) {
@@ -111,42 +127,92 @@ function runInPage(ctx) {
 
     if (eligibleLabels.size <= 1) continue;
 
+    // An override (aria-labelledby / aria-label) supersedes every native
+    // <label>, so the labels contribute nothing to the accessible name and
+    // cannot compete.
+    const override = getAriaNameInfo ? getAriaNameInfo(el, ctx) : null;
+    if (override && override.present && override.value) continue;
+
+    // Without an override the labels feed the name; only labels with their
+    // own text compete for it.
+    const contributing = labelContributesName
+      ? [...eligibleLabels].filter((lab) => labelContributesName(lab))
+      : [...eligibleLabels];
+
     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 form control is associated with more than one <label>.',
-      hint: 'Keep only one <label> per form control (either wrapping it or referencing it via for/id).',
-      i18n: {
-        summaryKey: 'formControlSingleLabel_summary_fail',
-        hintKey: 'formControlSingleLabel_hint_fail',
-        params: { element: tag, labelCount: String(eligibleLabels.size) }
-      },
-      data: {
-        details: {
-          reasonCode: 'FORM_FIELD_MULTIPLE_LABELS',
-          element: tag,
-          labelCount: eligibleLabels.size
-        }
-      }
-    });
+
+    if (contributing.length >= 2) {
+      failOccurrences.push(
+        helpers.reportOccurrence(el, {
+          summary: 'This form control is associated with more than one <label>.',
+          hint: 'Keep only one <label> per form control (either wrapping it or referencing it via for/id).',
+          occurrenceOutcome: 'fail',
+          i18n: {
+            summaryKey: 'formControlSingleLabel_summary_fail',
+            hintKey: 'formControlSingleLabel_hint_fail',
+            params: { element: tag, labelCount: String(contributing.length) }
+          },
+          data: {
+            details: {
+              reasonCode: 'FORM_FIELD_MULTIPLE_LABELS',
+              element: tag,
+              labelCount: contributing.length
+            }
+          }
+        })
+      );
+    } else if (contributing.length === 1) {
+      cantTellOccurrences.push(
+        helpers.reportOccurrence(el, {
+          summary:
+            'This form control has one labelling <label> plus an extra empty <label> association.',
+          hint: 'Remove the redundant empty <label> so exactly one <label> is associated with the control.',
+          occurrenceOutcome: 'cantTell',
+          i18n: {
+            summaryKey: 'formControlSingleLabel_summary_cantTell',
+            hintKey: 'formControlSingleLabel_hint_cantTell',
+            params: { element: tag, labelCount: String(eligibleLabels.size) }
+          },
+          data: {
+            details: {
+              reasonCode: 'FORM_FIELD_EXTRA_EMPTY_LABEL',
+              element: tag,
+              labelCount: eligibleLabels.size,
+              contributingLabelCount: contributing.length
+            }
+          }
+        })
+      );
+    }
+    // contributing.length === 0: no label carries text, so nothing competes
+    // for the name. A control left unnamed is form-control-programmatic-
+    // label-present's concern.
   }
 
   if (applicableCount === 0) {
     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: 'pass', severity: 'minor', occurrences: [] };
+
+  const resolved = helpers.resolveTieredOutcome
+    ? helpers.resolveTieredOutcome(
+        failOccurrences,
+        cantTellOccurrences,
+        rule.defaultSeverity || 'moderate'
+      )
+    : failOccurrences.length
+      ? {
+          outcome: 'fail',
+          severity: rule.defaultSeverity || 'moderate',
+          occurrences: failOccurrences
+        }
+      : cantTellOccurrences.length
+        ? {
+            outcome: 'cantTell',
+            severity: rule.defaultSeverity || 'moderate',
+            occurrences: cantTellOccurrences
+          }
+        : { outcome: 'pass', severity: 'minor', occurrences: [] };
+  return { ruleId: rule.ruleId, ...resolved };
 }
 
 module.exports = { id, meta, runInPage };