@surea11y/core 1.0.0

package/src/checks/manual/landmark-no-duplicate-banner-manual.js

@@ -0,0 +1,177 @@
+'use strict';
+
+/**
+ * @check landmark-no-duplicate-banner
+ * @atomic true
+ * @summary A page must not have more than one banner landmark
+ * @standard Best Practices (a widely-used reference engine's classification; no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
+ * @applicability
+ *   Applies whenever the page contains at least one banner landmark
+ *   (explicit role="banner", or an implicit, non-nested <header> — see
+ *   landmark-banner-is-top-level's implementation notes for the
+ *   shared landmark-detection model).
+ * @expectation
+ *   At most one banner landmark exists on the page. Per WAI-ARIA
+ *   Authoring Practices, the banner landmark represents site-oriented
+ *   content that identifies the page as a whole — having more than one
+ *   is ambiguous for assistive technology users navigating by landmark.
+ * @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.
+ * - Flags every banner instance (not just the "extra" ones) when more
+ *   than one exists, since which instance is "correct" is ambiguous.
+ * - Only landmarks actually exposed to assistive technology can collide —
+ *   matches a widely-used reference engine's own `page-no-duplicate` check (confirmed by reading
+ *   its source directly: `query_selector_all_filter_default(..., elm =>
+ *   _isVisibleToScreenReaders(elm))`). Without this, a responsive layout
+ *   rendering both a visible and a CSS-hidden duplicate `<header>` (found
+ *   on a real site — Trello's homepage, a desktop/mobile header pair) was
+ *   wrongly flagged as a duplicate landmark; the hidden copy is never
+ *   actually reachable by AT.
+ */
+
+const id = 'landmark-no-duplicate-banner';
+
+const meta = {
+  title: 'Page must not have more than one banner landmark',
+  description: 'Checks that at most one banner landmark (role="banner" or a non-nested <header>) exists on the page.',
+  i18n: {
+    titleKey: 'landmarkNoDuplicateBanner_title',
+    descriptionKey: 'landmarkNoDuplicateBanner_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;
+
+  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 getLandmarkRole(el) {
+    if (!el || !el.getAttribute) return '';
+    const explicit = getExplicitRoleToken(el);
+    if (explicit) return LANDMARK_ROLES.has(explicit) ? explicit : '';
+    return getImplicitLandmarkRole(el);
+  }
+
+  // queryAllSmart (shadow-DOM-aware) instead of plain document.querySelectorAll -- see
+  // landmark-unique-manual.js's header comment for the real page (Airtable, 2026-07-23)
+  // that surfaced this gap: a third-party shadow-DOM-hosted widget's own landmark is
+  // invisible to a light-DOM-only query.
+  let nodes = [];
+  try {
+    nodes = helpers && typeof helpers.queryAllSmart === 'function'
+      ? helpers.queryAllSmart('header, footer, main, nav, aside, section, form, [role]')
+      : document.querySelectorAll('header, footer, main, nav, aside, section, form, [role]');
+  } catch {
+    nodes = [];
+  }
+
+  const isAccTreeEligible = helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+
+  function isExposedToAt(el) {
+    if (!isAccTreeEligible) return true;
+    try {
+      const r = isAccTreeEligible(el, ctx);
+      if (typeof r === 'boolean') return r;
+      return !!(r && r.eligible);
+    } catch {
+      return true;
+    }
+  }
+
+  const banners = [];
+  const seen = new Set();
+  for (const el of nodes) {
+    if (!el || seen.has(el)) continue;
+    seen.add(el);
+    if (!isExposedToAt(el)) continue;
+    if (getLandmarkRole(el) === 'banner') banners.push(el);
+  }
+
+  if (banners.length <= 1) {
+    return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+  }
+
+  const occurrences = banners.map((el) => {
+    const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
+    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : (el.outerHTML || '');
+
+    return {
+      selector: stableSelector,
+      html,
+      summary: 'This page has more than one banner landmark.',
+      hint: 'Keep only one banner landmark (header/role="banner") per page.',
+      i18n: {
+        summaryKey: 'landmarkNoDuplicateBanner_summary_cantTell',
+        hintKey: 'landmarkNoDuplicateBanner_hint_cantTell',
+        params: { count: String(banners.length) }
+      },
+      data: {
+        details: { reasonCode: 'LANDMARK_DUPLICATE_BANNER', count: banners.length }
+      }
+    };
+  });
+
+  return { ruleId: rule.ruleId, outcome: 'cantTell', severity: rule.defaultSeverity || 'minor', occurrences };
+}
+
+module.exports = { id, meta, runInPage };

package/src/checks/manual/landmark-no-duplicate-contentinfo-manual.js

@@ -0,0 +1,169 @@
+'use strict';
+
+/**
+ * @check landmark-no-duplicate-contentinfo
+ * @atomic true
+ * @summary A page must not have more than one contentinfo landmark
+ * @standard Best Practices (a widely-used reference engine's classification; no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
+ * @applicability
+ *   Applies whenever the page contains at least one contentinfo landmark
+ *   (explicit role="contentinfo", or an implicit, non-nested <footer>).
+ * @expectation
+ *   At most one contentinfo landmark exists on the page — mirrors
+ *   landmark-no-duplicate-banner's rationale for contentinfo.
+ * @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.
+ * - Only landmarks actually exposed to assistive technology can collide —
+ *   matches a widely-used reference engine's own `page-no-duplicate` check (confirmed by reading
+ *   its source directly: `query_selector_all_filter_default(..., elm =>
+ *   _isVisibleToScreenReaders(elm))`) — same fix applied to the sibling
+ *   banner/main rules after finding real hidden-duplicate false positives
+ *   on Trello and Zoom.
+ */
+
+const id = 'landmark-no-duplicate-contentinfo';
+
+const meta = {
+  title: 'Page must not have more than one contentinfo landmark',
+  description: 'Checks that at most one contentinfo landmark (role="contentinfo" or a non-nested <footer>) exists on the page.',
+  i18n: {
+    titleKey: 'landmarkNoDuplicateContentinfo_title',
+    descriptionKey: 'landmarkNoDuplicateContentinfo_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;
+
+  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 getLandmarkRole(el) {
+    if (!el || !el.getAttribute) return '';
+    const explicit = getExplicitRoleToken(el);
+    if (explicit) return LANDMARK_ROLES.has(explicit) ? explicit : '';
+    return getImplicitLandmarkRole(el);
+  }
+
+  // queryAllSmart (shadow-DOM-aware) instead of plain document.querySelectorAll -- see
+  // landmark-unique-manual.js's header comment for the real page (Airtable, 2026-07-23)
+  // that surfaced this gap: a third-party shadow-DOM-hosted widget's own landmark is
+  // invisible to a light-DOM-only query.
+  let nodes = [];
+  try {
+    nodes = helpers && typeof helpers.queryAllSmart === 'function'
+      ? helpers.queryAllSmart('header, footer, main, nav, aside, section, form, [role]')
+      : document.querySelectorAll('header, footer, main, nav, aside, section, form, [role]');
+  } catch {
+    nodes = [];
+  }
+
+  const isAccTreeEligible = helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+
+  function isExposedToAt(el) {
+    if (!isAccTreeEligible) return true;
+    try {
+      const r = isAccTreeEligible(el, ctx);
+      if (typeof r === 'boolean') return r;
+      return !!(r && r.eligible);
+    } catch {
+      return true;
+    }
+  }
+
+  const contentinfos = [];
+  const seen = new Set();
+  for (const el of nodes) {
+    if (!el || seen.has(el)) continue;
+    seen.add(el);
+    if (!isExposedToAt(el)) continue;
+    if (getLandmarkRole(el) === 'contentinfo') contentinfos.push(el);
+  }
+
+  if (contentinfos.length <= 1) {
+    return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+  }
+
+  const occurrences = contentinfos.map((el) => {
+    const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
+    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : (el.outerHTML || '');
+
+    return {
+      selector: stableSelector,
+      html,
+      summary: 'This page has more than one contentinfo landmark.',
+      hint: 'Keep only one contentinfo landmark (footer/role="contentinfo") per page.',
+      i18n: {
+        summaryKey: 'landmarkNoDuplicateContentinfo_summary_cantTell',
+        hintKey: 'landmarkNoDuplicateContentinfo_hint_cantTell',
+        params: { count: String(contentinfos.length) }
+      },
+      data: {
+        details: { reasonCode: 'LANDMARK_DUPLICATE_CONTENTINFO', count: contentinfos.length }
+      }
+    };
+  });
+
+  return { ruleId: rule.ruleId, outcome: 'cantTell', severity: rule.defaultSeverity || 'minor', occurrences };
+}
+
+module.exports = { id, meta, runInPage };

package/src/checks/manual/landmark-no-duplicate-main-manual.js

@@ -0,0 +1,132 @@
+'use strict';
+
+/**
+ * @check landmark-no-duplicate-main
+ * @atomic true
+ * @summary A page must not have more than one main landmark
+ * @standard Best Practices (a widely-used reference engine's classification; no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
+ * @applicability
+ *   Applies whenever the page contains at least one main landmark
+ *   (explicit role="main", or an implicit <main>).
+ * @expectation
+ *   At most one main landmark exists on the page. Distinct, atomic
+ *   decision from landmark-one-main (that rule flags zero
+ *   mains too; this one only flags more than one) — matches a widely-used
+ *   reference engine shipping both as separate rules with some overlap by design.
+ * @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.
+ * - Only landmarks actually exposed to assistive technology can collide —
+ *   matches a widely-used reference engine's own `page-no-duplicate` check (confirmed by reading
+ *   its source directly: `query_selector_all_filter_default(..., elm =>
+ *   _isVisibleToScreenReaders(elm))`). Without this, a responsive layout
+ *   rendering both a visible and a CSS-hidden duplicate `<main>` (found on
+ *   a real site — Zoom's homepage) was wrongly flagged as a duplicate
+ *   landmark; the hidden copy is never actually reachable by AT.
+ */
+
+const id = 'landmark-no-duplicate-main';
+
+const meta = {
+  title: 'Page must not have more than one main landmark',
+  description: 'Checks that at most one main landmark (role="main" or <main>) exists on the page.',
+  i18n: {
+    titleKey: 'landmarkNoDuplicateMain_title',
+    descriptionKey: 'landmarkNoDuplicateMain_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;
+
+  function normalizeWs(s) {
+    return String(s || '').replace(/\s+/g, ' ').trim();
+  }
+
+  function getExplicitRoleToken(el) {
+    const raw = normalizeWs(el.getAttribute && el.getAttribute('role'));
+    if (!raw) return '';
+    return raw.split(/\s+/)[0].toLowerCase();
+  }
+
+  function getLandmarkRole(el) {
+    if (!el || !el.getAttribute) return '';
+    const explicit = getExplicitRoleToken(el);
+    if (explicit) return explicit === 'main' ? 'main' : '';
+    const tag = el.tagName ? el.tagName.toLowerCase() : '';
+    return tag === 'main' ? 'main' : '';
+  }
+
+  // queryAllSmart (shadow-DOM-aware) instead of plain document.querySelectorAll -- see
+  // landmark-unique-manual.js's header comment for the real page (Airtable, 2026-07-23)
+  // that surfaced this gap: a third-party shadow-DOM-hosted widget's own landmark is
+  // invisible to a light-DOM-only query.
+  let nodes = [];
+  try {
+    nodes = helpers && typeof helpers.queryAllSmart === 'function'
+      ? helpers.queryAllSmart('main, [role]')
+      : document.querySelectorAll('main, [role]');
+  } catch {
+    nodes = [];
+  }
+
+  const isAccTreeEligible = helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+
+  function isExposedToAt(el) {
+    if (!isAccTreeEligible) return true;
+    try {
+      const r = isAccTreeEligible(el, ctx);
+      if (typeof r === 'boolean') return r;
+      return !!(r && r.eligible);
+    } catch {
+      return true;
+    }
+  }
+
+  const mains = [];
+  const seen = new Set();
+  for (const el of nodes) {
+    if (!el || seen.has(el)) continue;
+    seen.add(el);
+    if (!isExposedToAt(el)) continue;
+    if (getLandmarkRole(el) === 'main') mains.push(el);
+  }
+
+  if (mains.length <= 1) {
+    return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+  }
+
+  const occurrences = mains.map((el) => {
+    const stableSelector = helpers.buildSelector ? helpers.buildSelector(el) : 'html';
+    const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(el) : (el.outerHTML || '');
+
+    return {
+      selector: stableSelector,
+      html,
+      summary: 'This page has more than one main landmark.',
+      hint: 'Keep only one main landmark (<main>/role="main") per page.',
+      i18n: {
+        summaryKey: 'landmarkNoDuplicateMain_summary_cantTell',
+        hintKey: 'landmarkNoDuplicateMain_hint_cantTell',
+        params: { count: String(mains.length) }
+      },
+      data: {
+        details: { reasonCode: 'LANDMARK_DUPLICATE_MAIN', count: mains.length }
+      }
+    };
+  });
+
+  return { ruleId: rule.ruleId, outcome: 'cantTell', severity: rule.defaultSeverity || 'minor', occurrences };
+}
+
+module.exports = { id, meta, runInPage };

package/src/checks/manual/landmark-one-main-manual.js

@@ -0,0 +1,151 @@
+'use strict';
+
+/**
+ * @check landmark-one-main
+ * @atomic true
+ * @summary The page should have a main landmark
+ * @standard Best Practices (a widely-used reference engine's classification; no formal WCAG Success Criterion — see ROADMAP.md Tier 1b)
+ * @applicability
+ *   Always applicable to any HTML document with a <body> element —
+ *   "does the page have a main landmark" is a whole-page concern,
+ *   matching bypass-blocks-present's pattern of evaluating the
+ *   document directly.
+ * @expectation
+ *   At least one main landmark (role="main" or <main>), exposed to
+ *   assistive technology, exists on the page — a page with none gives
+ *   AT users no landmark to jump straight to for the primary content.
+ * @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.
+ * - Presence-only, matching a widely-used reference engine's real
+ *   `landmark-one-main` scope exactly (confirmed 2026-07-22 by reading that
+ *   engine's source directly: its `page-has-main` check is a plain
+ *   descendant-exists test, `has-descendant-evaluate` — it does NOT flag
+ *   more than one). This rule previously ALSO flagged "more than one main,"
+ *   which was both a real scope mismatch against that reference engine (it
+ *   ships that as a fully separate rule, `landmark-no-duplicate-main` /
+ *   `page-no-duplicate-main`, already correctly implemented here as
+ *   `landmark-no-duplicate-main`) and missing that sibling rule's
+ *   accessibility-tree visibility filter, so it double-flagged cases the
+ *   sibling rule already handles correctly — found via a real page
+ *   (2026-07-22, live-DOM corpus): Resy's and DuckDuckGo's homepages each
+ *   genuinely have two visible `<main>` elements, which that reference
+ *   engine's `landmark-one-main` doesn't flag at all (out of its scope) but
+ *   this rule wrongly did, disagreeing with it for a
+ *   reason that wasn't a real coverage gap on either side — just a
+ *   redundant, incorrectly-scoped extra branch here.
+ * - Filters candidates through `isAccTreeEligible` (hidden/aria-hidden/
+ *   display:none/inert elements don't count as "a main landmark exists"),
+ *   matching `landmark-no-duplicate-main`'s own precedent and
+ *   that reference engine's own accessibility-tree-scoped matching.
+ */
+
+const id = 'landmark-one-main';
+
+const meta = {
+  title: 'Page should have a main landmark',
+  description: 'Checks that the page has at least one main landmark (role="main" or <main>).',
+  i18n: {
+    titleKey: 'landmarkOneMain_title',
+    descriptionKey: 'landmarkOneMain_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 getExplicitRoleToken(el) {
+    const raw = (el.getAttribute && el.getAttribute('role') || '').trim();
+    if (!raw) return '';
+    return raw.split(/\s+/)[0].toLowerCase();
+  }
+
+  function isMainLandmark(el) {
+    if (!el || !el.getAttribute) return false;
+    const explicit = getExplicitRoleToken(el);
+    if (explicit) return explicit === 'main';
+    const tag = el.tagName ? el.tagName.toLowerCase() : '';
+    return tag === 'main';
+  }
+
+  const isAccTreeEligible = helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+
+  function isExposedToAt(el) {
+    if (!isAccTreeEligible) return true;
+    try {
+      const r = isAccTreeEligible(el, ctx);
+      if (typeof r === 'boolean') return r;
+      return !!(r && r.eligible);
+    } catch {
+      return true;
+    }
+  }
+
+  // queryAllSmart (shadow-DOM-aware) instead of plain document.querySelectorAll -- see
+  // landmark-unique-manual.js's header comment for the real page (Airtable, 2026-07-23)
+  // that surfaced this gap: a third-party shadow-DOM-hosted widget's own landmark is
+  // invisible to a light-DOM-only query.
+  let nodes = [];
+  try {
+    nodes = helpers && typeof helpers.queryAllSmart === 'function'
+      ? helpers.queryAllSmart('main, [role]')
+      : document.querySelectorAll('main, [role]');
+  } catch {
+    nodes = [];
+  }
+
+  let hasMain = false;
+  const seen = new Set();
+  for (const el of nodes) {
+    if (!el || seen.has(el)) continue;
+    seen.add(el);
+    if (!isMainLandmark(el)) continue;
+    if (!isExposedToAt(el)) continue;
+    hasMain = true;
+    break;
+  }
+
+  if (hasMain) {
+    return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+  }
+
+  const stableSelector = helpers.buildSelector ? helpers.buildSelector(body) : 'body';
+  const html = helpers.getOuterHtmlSnippet ? helpers.getOuterHtmlSnippet(body) : (body.outerHTML || '').slice(0, 200);
+
+  return {
+    ruleId: rule.ruleId,
+    outcome: 'cantTell',
+    severity: rule.defaultSeverity || 'minor',
+    occurrences: [{
+      selector: stableSelector,
+      html,
+      summary: 'This page has no main landmark.',
+      hint: 'Add a main landmark (<main> or role="main") around the page\'s primary content.',
+      i18n: {
+        summaryKey: 'landmarkOneMain_summary_cantTell_missing',
+        hintKey: 'landmarkOneMain_hint_cantTell_missing',
+        params: {}
+      },
+      data: {
+        details: { reasonCode: 'LANDMARK_MAIN_MISSING' }
+      }
+    }]
+  };
+}
+
+module.exports = { id, meta, runInPage };