@surea11y/core 1.0.0

package/src/checks/manual/page-title-patterns-manual.js

@@ -0,0 +1,262 @@
+'use strict';
+
+const id = 'page-title-patterns';
+
+const meta = {
+  title: 'Page title patterns that may indicate low descriptiveness',
+  description:
+    'Flags page titles that are likely too generic or templated as review signals (WCAG 2.2 SC 2.4.2). ' +
+    'This rule is conservative and does not fail based on patterns alone.',
+  i18n: {
+    titleKey: 'pageTitlePatterns_title',
+    descriptionKey: 'pageTitlePatterns_description'
+  },
+  helpUrl: null,
+  tags: ['wcag2a', 'wcag242', 'titles', 'atomic', 'navigation', 'manual'],
+  wcagSc: ['2.4.2'],
+  normativeMappings: [
+    { standard: 'WCAG', version: '2.2', requirement: '2.4.2', title: 'Page Titled', conformanceLevel: 'A' }
+  ],
+  defaultSeverity: 'minor',
+  category: 'operable',
+  type: 'manual',
+  defaultConfidence: 'medium',
+  coverage: { facetsBySc: { '2.4.2': ['page-title-patterns'] } }
+};
+
+function runInPage(ctx) {
+  const { document, helpers, rule } = ctx;
+  const probes = ctx && ctx.inputs && ctx.inputs.probes && typeof ctx.inputs.probes === 'object'
+      ? ctx.inputs.probes
+      : null;
+
+  const pageTitlesProbe = probes && probes['crawl.pageTitles'] && typeof probes['crawl.pageTitles'] === 'object'
+      ? probes['crawl.pageTitles']
+      : null;
+
+  const occurrences = [];
+  let applicableCount = 1;
+
+  const titleEl = document.querySelector('head > title');
+  const rawTitle = document.title || '';
+  const titleText = rawTitle.replace(/\s+/g, ' ').trim();
+  const titleLc = titleText.toLowerCase();
+  // =========================
+  // Cross-page pattern analysis (preferred) if crawl.pageTitles probe is provided
+  // =========================
+  if (pageTitlesProbe && Array.isArray(pageTitlesProbe.pages)) {
+    const pages = pageTitlesProbe.pages.filter(p => p && typeof p === 'object');
+
+    // Require enough data to avoid noisy conclusions
+    const MIN_PAGES = 10;
+    const analyzable = pages
+        .map(p => ({
+          url: p.url ? String(p.url) : null,
+          title: typeof p.title === 'string' ? p.title.replace(/\s+/g, ' ').trim() : ''
+        }))
+        .filter(p => p.url && p.title);
+
+    if (analyzable.length >= MIN_PAGES) {
+      // Build normalized title groups (case-insensitive)
+      const groups = new Map(); // normTitle -> { title, urls: [] }
+      for (const p of analyzable) {
+        const norm = p.title.toLowerCase();
+        if (!groups.has(norm)) groups.set(norm, { title: p.title, urls: [] });
+        groups.get(norm).urls.push(p.url);
+      }
+
+      // Duplicate titles across distinct URLs is a strong "review" signal (not a guaranteed failure)
+      const dupGroups = Array.from(groups.values()).filter(g => g.urls.length >= 2);
+
+      // Boilerplate-ish: detect a long common suffix/prefix across most titles.
+      // Keep conservative: only flag if the common part is long and shared by many.
+      const titles = analyzable.map(p => p.title);
+      function commonPrefix(a, b) {
+        const n = Math.min(a.length, b.length);
+        let i = 0;
+        for (; i < n; i++) if (a[i] !== b[i]) break;
+        return a.slice(0, i);
+      }
+      function commonSuffix(a, b) {
+        const ra = a.split('').reverse().join('');
+        const rb = b.split('').reverse().join('');
+        return commonPrefix(ra, rb).split('').reverse().join('');
+      }
+
+      let sharedPrefix = titles[0] || '';
+      let sharedSuffix = titles[0] || '';
+      for (let i = 1; i < titles.length; i++) {
+        sharedPrefix = commonPrefix(sharedPrefix, titles[i]);
+        sharedSuffix = commonSuffix(sharedSuffix, titles[i]);
+        if (sharedPrefix.length === 0 && sharedSuffix.length === 0) break;
+      }
+
+      const prefixLen = sharedPrefix.trim().length;
+      const suffixLen = sharedSuffix.trim().length;
+
+      const hasStrongTemplateSignal =
+          (prefixLen >= 12 || suffixLen >= 12) &&
+          (prefixLen >= 12 ? sharedPrefix.trim().length : 0) + (suffixLen >= 12 ? sharedSuffix.trim().length : 0) >= 12;
+
+      // If any cross-page signal exists, emit cantTell occurrence(s)
+      if (dupGroups.length || hasStrongTemplateSignal) {
+        const reasonCode = dupGroups.length
+            ? 'duplicateTitlesAcrossPages'
+            : 'templatedTitlesAcrossPages';
+
+        // Deterministic example title for i18n params (lexicographic, case-insensitive)
+        const exampleTitle = dupGroups.length
+            ? dupGroups
+            .map(g => String(g.title || '').replace(/\s+/g, ' ').trim())
+            .filter(Boolean)
+            .sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' }))[0] || ''
+            : '';
+
+        const summaryKey = dupGroups.length
+            ? 'pageTitlePatterns_summary_cantTell_duplicateAcrossPages'
+            : 'pageTitlePatterns_summary_cantTell_templatedAcrossPages';
+
+        const i18nParams = dupGroups.length
+            ? {
+              reasonCode,
+              pagesAnalyzed: analyzable.length,
+              duplicateGroups: dupGroups.length,
+              exampleTitle
+            }
+            : {
+              reasonCode,
+              pagesAnalyzed: analyzable.length
+            };
+
+        const occBase = {
+          selector: 'head > title',
+          html: '',
+          summary: 'The set of page titles may not be descriptive enough to distinguish pages by topic or purpose.',
+          hint: 'Ensure each page title is sufficiently descriptive and helps users distinguish pages (avoid identical or overly templated titles across many pages).',
+          i18n: {
+            summaryKey,
+            hintKey: 'pageTitlePatterns_hint_cantTell',
+            params: i18nParams
+          },
+          data: {
+            details: {
+              reasonCode,
+              metrics: {
+                pagesAnalyzed: analyzable.length,
+                duplicateGroups: dupGroups.length,
+                largestDuplicateGroupSize: dupGroups.length ? Math.max(...dupGroups.map(g => g.urls.length)) : 0,
+                sharedPrefix: prefixLen >= 12 ? sharedPrefix.trim() : '',
+                sharedSuffix: suffixLen >= 12 ? sharedSuffix.trim() : ''
+              },
+              refs: {
+                exampleDuplicateTitles: dupGroups.slice(0, 3).map(g => ({
+                  title: g.title,
+                  urls: g.urls.slice(0, 5)
+                }))
+              }
+            },
+            visibilityFilter: { targetSet: 'acc', accEligible: null, reasons: [] }
+          }
+        };
+
+        if (titleEl && helpers && typeof helpers.reportOccurrence === 'function') {
+          occurrences.push(helpers.reportOccurrence(titleEl, occBase));
+        } else {
+          // No node available: keep deterministic fallback snippet (no helper calls).
+          occurrences.push({
+            ...occBase,
+            html: titleEl && titleEl.outerHTML ? String(titleEl.outerHTML).slice(0, 2000) : '<title>(unknown)</title>'
+          });
+        }
+
+        // Cross-page analysis is authoritative when present; do not also run single-page heuristics.
+        return { ruleId: rule.ruleId, outcome: 'cantTell', severity: rule.defaultSeverity || 'minor', occurrences };
+      }
+
+      // If we had enough pages and found no review signal, there is nothing
+      // to flag for manual review.
+      return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+    }
+
+    // Not enough analyzable pages -> notApplicable for cross-page patterns, fall back to single-page logic.
+  }
+
+  // If there's no title (or empty), defer to the hard-fail rule.
+  if (!titleEl || titleText.length === 0) {
+    return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+  }
+
+  const GENERIC_TITLES = new Set([
+    'home',
+    'homepage',
+    'welcome',
+    'untitled',
+    'page',
+    'document'
+  ]);
+
+  // Conservative signals:
+  // - very short title (likely non-descriptive)
+  // - title is one of a small set of generic titles
+  const isVeryShort = titleText.length > 0 && titleText.length < 8;
+  const isGeneric = GENERIC_TITLES.has(titleLc);
+
+  // Template-like: "Brand | Home" or "Home - Brand" where the page-specific part is a generic token.
+  const templateLike = /\b(home|homepage|welcome)\b\s*(\||-|—|:)\s*.+/i.test(titleText) ||
+                       /.+\s*(\||-|—|:)\s*\b(home|homepage|welcome)\b/i.test(titleText);
+
+  if (isGeneric || isVeryShort || templateLike) {
+    const reasonCode = isGeneric
+      ? 'genericTitle'
+      : (isVeryShort ? 'veryShortTitle' : 'templateLikeTitle');
+
+    const summaryKey =
+        reasonCode === 'genericTitle'
+            ? 'pageTitlePatterns_summary_cantTell_generic'
+            : (reasonCode === 'veryShortTitle'
+                ? 'pageTitlePatterns_summary_cantTell_veryShort'
+                : 'pageTitlePatterns_summary_cantTell_templateLike');
+    const occBase = {
+      selector: 'head > title',
+      html: '',
+      summary:
+          'The page title may not be descriptive enough to identify the page topic or purpose.',
+      hint:
+          'Use a more specific title that identifies the page topic or purpose (for example, include the section name or task).',
+      i18n: {
+        summaryKey,
+        hintKey: 'pageTitlePatterns_hint_cantTell',
+        params: {}
+      },
+      data: {
+        details: {
+          reasonCode,
+          titleText
+        },
+        visibilityFilter: { targetSet: 'acc', accEligible: null, reasons: [] }
+      }
+    };
+
+    if (titleEl && helpers && typeof helpers.reportOccurrence === 'function') {
+      occurrences.push(helpers.reportOccurrence(titleEl, occBase));
+    } else {
+      occurrences.push({
+        ...occBase,
+        html: titleEl && titleEl.outerHTML ? String(titleEl.outerHTML).slice(0, 2000) : '<title>(unknown)</title>'
+      });
+    }
+  }
+
+  if (applicableCount === 0) {
+    return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+  }
+
+  if (occurrences.length) {
+    // Patterns are review signals: cantTell rather than fail.
+    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/presentation-role-conflict-manual.js

@@ -0,0 +1,159 @@
+'use strict';
+
+/**
+ * @check presentation-role-conflict
+ * @atomic true
+ * @summary role="presentation"/"none" must not be combined with a global ARIA naming attribute or focusability
+ * @standard Best Practices (a widely-used reference engine's classification; no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
+ * @applicability
+ *   Applies to elements with an explicit role="presentation" or
+ *   role="none", OR an <img alt=""> (empty alt gives an <img> an implicit
+ *   presentation role per HTML-AAM, even with no explicit role attribute
+ *   at all — verified against a widely-used reference engine's own selector
+ *   for this exact check, `img[alt=''], [role="none"], [role="presentation"]`).
+ * @expectation
+ *   The element does not also carry a WAI-ARIA *global* state/property
+ *   (aria-label, aria-hidden, aria-describedby, aria-live, aria-current,
+ *   ... — the full global-attribute set, not just the naming ones), AND
+ *   is not focusable. Per the WAI-ARIA spec's Presentational Roles
+ *   Conflict Resolution section, a presentational role is "restored" to
+ *   the element's implicit semantic role when either condition holds —
+ *   the presentation/none role silently stops working, contradicting the
+ *   author's evident intent to hide the element from the accessibility
+ *   tree.
+ * @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.
+ * - The conflicting-attribute set matches a widely-used reference engine's
+ *   own `none: ['is-element-focusable', 'has-global-aria-attribute']` condition
+ *   exactly — `has-global-aria-attribute` checks against the full list of
+ *   ARIA attributes marked `global: true` in that engine's own standards data
+ *   (confirmed by reading `standards.ariaAttrs` directly at runtime, not
+ *   guessed), which is much broader than the 3-attribute naming-only list
+ *   this rule originally checked (added 2026-07-20, then widened
+ *   2026-07-20 after a real page — Slack's homepage has
+ *   `<img alt="" aria-hidden="">`, both gaps at once: the img[alt=''] case
+ *   wasn't in the applicability selector at all, and aria-hidden wasn't in
+ *   the conflicting-attribute set even if it had been).
+ * - Deliberately NOT replicating that reference engine's
+ *   `hasImplicitChromiumRoleMatches` applicability gate, which (per direct
+ *   probing of the reference engine's runtime) makes its own check
+ *   inapplicable to role="presentation" on elements with no
+ *   native implicit role to suppress in the first place (e.g.
+ *   `<div role="presentation" aria-hidden="true">` — a <div> has no native
+ *   role, so there's nothing for the presentational role to "conflict"
+ *   with per that engine's own scope decision). Replicating that would require a
+ *   full native-implicit-role table and isn't evidenced by any real false
+ *   positive in this corpus yet — surea11y stays broader/more cautious
+ *   here rather than narrower, which is the safer direction to diverge in.
+ * - Focusability is computed via helpers.getFocusableInfo (native +
+ *   tabindex), same helper aria-hidden-focus already relies on — a
+ *   `:disabled` or otherwise non-focusable element is not flagged.
+ */
+
+const id = 'presentation-role-conflict';
+
+const meta = {
+  title: 'Presentational role must not conflict with a global ARIA attribute or focusability',
+  description: 'Checks that role="presentation"/"none" (including an <img alt=""> implicit presentation role) is not combined with a global ARIA attribute (aria-label, aria-hidden, aria-describedby, ...) or focusability (tabindex/native).',
+  i18n: {
+    titleKey: 'presentationRoleConflict_title',
+    descriptionKey: 'presentationRoleConflict_description'
+  },
+  helpUrl: null,
+  tags: ['best-practice', 'aria', 'structure', 'atomic', 'manual'],
+  wcagSc: [],
+  normativeMappings: [],
+  defaultSeverity: 'minor',
+  category: 'robust',
+  type: 'manual',
+  defaultConfidence: 'medium',
+  coverage: {}
+};
+
+function runInPage(ctx) {
+  const { document, root, helpers, rule } = ctx;
+  const safeRoot = root || document;
+
+  // The full set of ARIA attributes marked `global: true` per the WAI-ARIA
+  // spec (confirmed against a widely-used reference engine's own
+  // `standards.ariaAttrs` data at runtime, 2026-07-20) — any of these present on a presentational
+  // element restores its implicit role, not just the naming ones.
+  const CONFLICTING_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'
+  ];
+
+  const getFocusableInfo = helpers && typeof helpers.getFocusableInfo === 'function' ? helpers.getFocusableInfo : null;
+
+  const nodes = helpers.queryAllSmart
+      ? helpers.queryAllSmart('[role="presentation"], [role="none"], img[alt=""]', safeRoot)
+      : helpers.queryAll('[role="presentation"], [role="none"], img[alt=""]', safeRoot);
+
+  const occurrences = [];
+  let applicableCount = 0;
+
+  for (const el of nodes) {
+    if (!el || !el.getAttribute) continue;
+
+    applicableCount += 1;
+
+    // Presence, not value truthiness: the WAI-ARIA role-conflict-resolution
+    // rule triggers on a global ARIA attribute being SPECIFIED at all, even
+    // with an empty value — found on a real site, Slack's homepage has
+    // <img alt="" aria-hidden="">, where aria-hidden="" (empty string) is
+    // still a specified attribute. A truthy-value check would have missed
+    // this even after aria-hidden was added to CONFLICTING_ATTRS above.
+    const present = CONFLICTING_ATTRS.filter((attr) => (el.hasAttribute ? el.hasAttribute(attr) : el.getAttribute(attr) != null));
+
+    let isFocusable = false;
+    if (getFocusableInfo) {
+      try {
+        const fi = getFocusableInfo(el, ctx);
+        isFocusable = !!(fi && fi.focusable);
+      } catch {
+        isFocusable = false;
+      }
+    }
+
+    if (!present.length && !isFocusable) continue;
+
+    const parts = present.slice();
+    if (isFocusable) parts.push('focusable');
+
+    // No explicit role attribute means this matched via the img[alt=""]
+    // implicit-presentation case.
+    const role = String(el.getAttribute('role') || '').trim().toLowerCase() || 'presentation';
+    const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
+    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : (el.outerHTML || '');
+
+    occurrences.push({
+      selector: stableSelector,
+      html,
+      summary: `This role="${role}" element also has a conflicting condition (${parts.join(', ')}), which restores its implicit role and cancels the presentational intent.`,
+      hint: 'Remove the conflicting naming attribute(s) and/or focusability (tabindex/native) if the element should stay presentational, or remove role="presentation"/"none" if it should be exposed to assistive technology.',
+      i18n: {
+        summaryKey: 'presentationRoleConflict_summary_cantTell',
+        hintKey: 'presentationRoleConflict_hint_cantTell',
+        params: { role, attrs: parts.join(', ') }
+      },
+      data: {
+        details: { reasonCode: 'PRESENTATION_ROLE_CONFLICT', role, conflictingAttrs: present, focusable: isFocusable }
+      }
+    });
+  }
+
+  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/region-manual.js

@@ -0,0 +1,183 @@
+'use strict';
+
+/**
+ * @check region
+ * @atomic true
+ * @summary Page content should be contained within a landmark region
+ * @standard Best Practices (a widely-used reference engine's classification; no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
+ * @applicability
+ *   Applies to direct children of <body> that carry visible text content
+ *   and are not themselves a landmark.
+ * @expectation
+ *   Every top-level piece of page content lives inside a landmark region
+ *   (main, navigation, banner, contentinfo, complementary, region, form,
+ *   search), so assistive technology users navigating by landmark do not
+ *   miss content that was never placed inside one.
+ * @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 and the landmark-
+ *   detection model.
+ * - Deliberately scoped to DIRECT children of <body> only (not a full
+ *   recursive scan of every text node on the page) — a widely-used
+ *   reference engine's own region rule is known to be noisy in practice when applied
+ *   unconditionally; checking only the top level keeps false positives
+ *   low while still catching the common case (a page section authored
+ *   entirely outside any landmark).
+ */
+
+const id = 'region';
+
+const meta = {
+  title: 'Page content should be inside a landmark region',
+  description: 'Checks that direct children of <body> with visible text content are contained within a landmark region.',
+  i18n: {
+    titleKey: 'region_title',
+    descriptionKey: 'region_description'
+  },
+  helpUrl: null,
+  tags: ['best-practice', 'landmarks', 'structure', 'atomic', 'manual'],
+  wcagSc: [],
+  normativeMappings: [],
+  defaultSeverity: 'minor',
+  category: 'operable',
+  type: 'manual',
+  defaultConfidence: 'medium',
+  coverage: {}
+};
+
+function runInPage(ctx) {
+  const { document, helpers, rule } = ctx;
+
+  const body = document && document.body ? document.body : null;
+  if (!body) {
+    return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+  }
+
+  function normalizeWs(s) {
+    return String(s || '').replace(/\s+/g, ' ').trim();
+  }
+
+  // Delegates to the shared helpers.getLandmarkNameInfo (aria-label -> aria-labelledby, via the
+  // target's own accessible name, not raw textContent -> title attribute fallback) rather than a
+  // local copy -- see that function's header comment in src/core/dom-helpers.js for the real bug
+  // (missing title fallback) this replaced across all 7 landmark rule files that had their own
+  // copy of this logic.
+  function getAccessibleLandmarkName(el) {
+    try {
+      if (helpers && typeof helpers.getLandmarkNameInfo === 'function') {
+        const info = helpers.getLandmarkNameInfo(el, ctx);
+        if (info && info.present && info.value) return normalizeWs(info.value);
+      }
+    } catch {}
+    return '';
+  }
+
+  function getExplicitRoleToken(el) {
+    const raw = normalizeWs(el.getAttribute && el.getAttribute('role'));
+    if (!raw) return '';
+    return raw.split(/\s+/)[0].toLowerCase();
+  }
+
+  const SECTIONING_ANCESTORS = new Set(['article', 'aside', 'main', 'nav', 'section']);
+
+  function isSuppressedBySectioningAncestor(el) {
+    let p = el.parentElement;
+    while (p) {
+      const tag = p.tagName ? p.tagName.toLowerCase() : '';
+      if (SECTIONING_ANCESTORS.has(tag)) return true;
+      p = p.parentElement;
+    }
+    return false;
+  }
+
+  function getImplicitLandmarkRole(el) {
+    const tag = el.tagName ? el.tagName.toLowerCase() : '';
+    if (tag === 'header') return isSuppressedBySectioningAncestor(el) ? '' : 'banner';
+    if (tag === 'footer') return isSuppressedBySectioningAncestor(el) ? '' : 'contentinfo';
+    if (tag === 'main') return 'main';
+    if (tag === 'nav') return 'navigation';
+    if (tag === 'aside') return isSuppressedBySectioningAncestor(el) ? '' : 'complementary';
+    if (tag === 'section') return getAccessibleLandmarkName(el) ? 'region' : '';
+    if (tag === 'form') return getAccessibleLandmarkName(el) ? 'form' : '';
+    return '';
+  }
+
+  const LANDMARK_ROLES = new Set(['banner', 'contentinfo', 'main', 'navigation', 'complementary', 'region', 'form', 'search']);
+
+  function isLandmark(el) {
+    if (!el || !el.getAttribute) return false;
+    const explicit = getExplicitRoleToken(el);
+    if (explicit) return LANDMARK_ROLES.has(explicit);
+    return !!getImplicitLandmarkRole(el);
+  }
+
+  const SKIP_TAGS = new Set(['script', 'style', 'template', 'noscript', 'link', 'meta', 'title']);
+
+  function isIneligible(el) {
+    if (el.getAttribute && el.getAttribute('aria-hidden') === 'true') return true;
+    if (el.hasAttribute && el.hasAttribute('hidden')) return true;
+    return false;
+  }
+
+  function getConservativeSubtreeText(container) {
+    const SHOW_TEXT = 4;
+    try {
+      const walker = document.createTreeWalker(container, SHOW_TEXT, null);
+      const parts = [];
+      let n = walker.nextNode();
+      while (n) {
+        const raw = normalizeWs(n.nodeValue || '');
+        if (raw) parts.push(raw);
+        n = walker.nextNode();
+      }
+      return normalizeWs(parts.join(' '));
+    } catch {
+      return normalizeWs(container.textContent);
+    }
+  }
+
+  const occurrences = [];
+  let applicableCount = 0;
+
+  for (const el of body.children || []) {
+    if (!el || !el.tagName) continue;
+    const tag = el.tagName.toLowerCase();
+    if (SKIP_TAGS.has(tag)) continue;
+    if (isIneligible(el)) continue;
+    if (isLandmark(el)) continue;
+
+    const text = getConservativeSubtreeText(el);
+    if (!text) continue;
+
+    applicableCount += 1;
+
+    const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
+    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : (el.outerHTML || '');
+
+    occurrences.push({
+      selector: stableSelector,
+      html,
+      summary: 'This content is not contained within a landmark region.',
+      hint: 'Move this content inside a landmark region (main, nav, aside, a labeled section, etc.).',
+      i18n: {
+        summaryKey: 'region_summary_cantTell',
+        hintKey: 'region_hint_cantTell',
+        params: { element: tag }
+      },
+      data: {
+        details: { reasonCode: 'CONTENT_OUTSIDE_LANDMARK', element: tag }
+      }
+    });
+  }
+
+  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 };