@surea11y/core 1.0.0

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

@@ -0,0 +1,206 @@
+'use strict';
+
+/**
+ * @check css-orientation-lock
+ * @atomic true
+ * @summary CSS must not lock the page to a single display orientation via a rotate() hack
+ * @standard WCAG 2.2
+ * @sc 1.3.4
+ * @applicability
+ *   Any accessible (same-document, non-cross-origin) stylesheet — inline
+ *   `<style>` blocks and same-origin `<link>` stylesheets already loaded
+ *   into `document.styleSheets`.
+ * @expectation
+ *   No `@media (orientation: portrait)` or `@media (orientation:
+ *   landscape)` block sets a `transform`/`-webkit-transform`/`rotate`
+ *   rotation of approximately 90 degrees (mod 180, i.e. ~90 or ~270) —
+ *   the well-known technique for visually forcing one orientation
+ *   regardless of the device's actual orientation, which defeats WCAG
+ *   1.3.4's requirement that content not restrict its view to a single
+ *   display orientation unless that orientation is essential.
+ * @implementation-notes
+ * - The rotation DEGREE is what makes this the exploit signature, not
+ *   merely the presence of a `rotate()` function — verified against a
+ *   widely-used reference engine's own `css-orientation-lock` check
+ *   (`cssOrientationLockEvaluate`), which computes the actual rotation angle and only
+ *   flags ~90/~270 degrees, explicitly excluding ~0/~180 (a no-op or a
+ *   flip, neither of which changes portrait<->landscape). A prior
+ *   version of this rule flagged the bare presence of "rotate(" in an
+ *   orientation-media-query rule regardless of angle — a real, confirmed
+ *   false positive found via the live-DOM cross-engine corpus 2026-07-23
+ *   on a real page (Times of India) whose `@media (orientation:portrait)`
+ *   block only rotated a small decorative arrow icon 45 degrees, nothing
+ *   resembling a page-orientation lock.
+ * - Only `rotate`/`rotateZ` (transform functions) and the standalone CSS
+ *   `rotate` property are parsed for degrees — matches that reference engine's
+ *   own two sources (`style.transform`/`style.rotate`) but, like that engine,
+ *   does not attempt to decompose `matrix()`/`matrix3d()`/`rotate3d()` into an
+ *   equivalent angle (that engine does handle those; deliberately deferred here
+ *   as the same class of "genuinely more complex, lower real-world
+ *   value" work already deferred elsewhere in this engine, e.g.
+ *   `table-th-has-data-cells`'s narrower positional-header algorithm).
+ * - Cross-origin stylesheets throw on `.cssRules` access (browser
+ *   security model) and are skipped — same class of limitation as any
+ *   check that can only see same-origin/inspectable content (compare
+ *   `iframe-focusable-content`).
+ * - Not per-element: this is a whole-document/whole-stylesheet concern,
+ *   so occurrences are reported against `document.documentElement`,
+ *   matching the "whole-document checks" precedent documented in
+ *   `docs/RULE_AUTHORING.md` §11.2 (e.g. `aria-hidden-body`,
+ *   `meta-viewport-zoom-enabled`).
+ */
+
+const id = 'css-orientation-lock';
+
+const meta = {
+  title: 'CSS must not lock the page to a single orientation',
+  description:
+    'Checks that no @media (orientation: portrait|landscape) rule sets a transform: rotate(...) on the page, a known technique for defeating device orientation.',
+  i18n: {
+    titleKey: 'cssOrientationLock_title',
+    descriptionKey: 'cssOrientationLock_description'
+  },
+  helpUrl: null,
+  tags: ['wcag21aa', 'wcag134', 'structure', 'atomic', 'automatic'],
+  wcagSc: ['1.3.4'],
+  normativeMappings: [
+    { standard: 'WCAG', version: '2.2', requirement: '1.3.4', title: 'Orientation', conformanceLevel: 'AA' }
+  ],
+  defaultSeverity: 'serious',
+  category: 'perceivable',
+  type: 'automatic',
+  defaultConfidence: 'high',
+  coverage: { facetsBySc: { '1.3.4': ['css-orientation-lock'] } }
+};
+
+function runInPage(ctx) {
+  const { document, helpers, rule } = ctx;
+
+  const CSS_MEDIA_RULE = 4;
+  const CSS_STYLE_RULE = 1;
+
+  function trim(v) { return (v == null ? '' : String(v)).trim(); }
+
+  // Converts a rotate()/rotateZ() angle argument (with unit) to degrees.
+  // Matches a widely-used reference engine's own getAngleInDegrees: only deg/grad/rad/turn are
+  // recognized; a unitless or unrecognized value contributes 0 (ignored,
+  // not treated as a lock -- an unparseable angle isn't a confirmed exploit).
+  function angleToDegrees(raw) {
+    const m = /(-?[\d.]+)\s*(deg|grad|rad|turn)/i.exec(raw);
+    if (!m) return 0;
+    const value = parseFloat(m[1]);
+    if (!Number.isFinite(value)) return 0;
+    const unit = m[2].toLowerCase();
+    if (unit === 'rad') return value * (180 / Math.PI);
+    if (unit === 'grad') return value * (360 / 400);
+    if (unit === 'turn') return value * 360;
+    return value; // deg
+  }
+
+  // Sums the degrees of every rotate()/rotateZ() function found in a
+  // transform value (a real transform can legitimately compose more than
+  // one, e.g. "translate(-50%) rotate(90deg)").
+  function rotateDegreesFromTransform(t) {
+    if (!t) return 0;
+    let total = 0;
+    const re = /rotate(?:Z)?\s*\(([^)]*)\)/gi;
+    let m;
+    while ((m = re.exec(t)) !== null) {
+      total += angleToDegrees(m[1]);
+    }
+    return total;
+  }
+
+  // Whole-page-orientation-lock detection, matching a widely-used reference engine's own degree
+  // math exactly (see @implementation-notes): a rotation near 0 or 180
+  // degrees (mod 180) is a no-op or a flip, neither of which changes
+  // portrait<->landscape, so it's explicitly NOT a lock; only a rotation
+  // near 90 or 270 degrees (mod 90, once the 0/180 case is excluded) is.
+  function isLockingRotation(styleDecl) {
+    if (!styleDecl) return false;
+    const transformVal = trim(styleDecl.transform) || trim(styleDecl.getPropertyValue ? styleDecl.getPropertyValue('-webkit-transform') : '');
+    // The standalone CSS `rotate` property (distinct from `transform: rotate()`) -- that reference engine checks this too.
+    const rotatePropVal = trim(styleDecl.getPropertyValue ? styleDecl.getPropertyValue('rotate') : '');
+
+    let degrees = rotateDegreesFromTransform(transformVal);
+    if (!degrees && rotatePropVal) degrees = angleToDegrees(rotatePropVal);
+
+    if (!degrees) return false;
+
+    const abs = Math.abs(degrees);
+    if (Math.abs(abs - 180) % 180 <= 0) return false; // near 0/180: not a lock
+    return Math.abs(abs - 90) % 90 <= 0; // near 90/270: a lock
+  }
+
+  function isOrientationMedia(mediaText) {
+    const m = trim(mediaText).toLowerCase();
+    return m.includes('orientation') && (m.includes('portrait') || m.includes('landscape'));
+  }
+
+  function scanRuleList(rules, mediaText, findings) {
+    if (!rules) return;
+    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)' });
+      }
+    }
+  }
+
+  const findings = [];
+  let sheetCount = 0;
+
+  try {
+    const sheets = document.styleSheets || [];
+    for (const sheet of sheets) {
+      let rules = null;
+      try {
+        rules = sheet && sheet.cssRules ? sheet.cssRules : null;
+      } catch {
+        continue; // cross-origin stylesheet, not inspectable
+      }
+      if (!rules) continue;
+      sheetCount += 1;
+
+      for (const rule2 of rules) {
+        if (!rule2 || rule2.type !== CSS_MEDIA_RULE) continue;
+        const mediaText = rule2.media ? rule2.media.mediaText : '';
+        if (!isOrientationMedia(mediaText)) continue;
+        scanRuleList(rule2.cssRules, mediaText, findings);
+      }
+    }
+  } catch {
+    // no-throw: treat as no accessible stylesheets
+  }
+
+  if (sheetCount === 0) {
+    return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+  }
+
+  if (!findings.length) {
+    return { ruleId: rule.ruleId, outcome: 'pass', severity: 'minor', occurrences: [] };
+  }
+
+  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 }
+    }
+  }));
+
+  return { ruleId: rule.ruleId, outcome: 'fail', severity: rule.defaultSeverity || 'serious', occurrences };
+}
+
+module.exports = { id, meta, runInPage };

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

@@ -0,0 +1,148 @@
+'use strict';
+
+/**
+ * @check definition-list-children-valid
+ * @atomic true
+ * @summary <dl> must only contain <dt>/<dd> groups (optionally wrapped in one <div>), <script>, <template>, or <style>
+ * @standard WCAG 2.2
+ * @sc 1.3.1
+ * @applicability
+ *   Applies to <dl> elements that have at least one direct element child.
+ * @expectation
+ *   Every direct element child is <dt>, <dd>, <script>, <template>, <style>,
+ *   or a <div> whose own children are drawn from that same set (a single
+ *   level of wrapping div is allowed, matching how authors commonly group
+ *   dt/dd pairs). If the flattened set contains any <dt> or <dd> at all, it
+ *   must contain BOTH (an unbalanced dt-without-dd or dd-without-dt is
+ *   invalid) — a flattened set with neither is vacuously fine, not a
+ *   violation (see implementation-notes). Any other direct or wrapped child
+ *   breaks the description-list semantics assistive technologies rely on.
+ * @implementation-notes
+ * - Only one level of <div> wrapping is flattened, matching a widely-used
+ *   reference engine's definition-list algorithm — a <div> nested inside
+ *   another wrapping <div> is not flattened further and its contents are
+ *   reported invalid.
+ * - Verified 2026-07-20 against a widely-used reference engine: the dt/dd pairing is
+ *   only required "when not empty". A flattened set with NEITHER dt nor dd
+ *   — whether from an empty wrapping <div>, only <script>/<template>/
+ *   <style> content, or a genuinely childless <dl> — is not flagged; only
+ *   an unbalanced dt/dd pairing is a real structural problem.
+ * - Distinct, atomic decision from dlitem-parent-valid (the
+ *   inverse relationship: does a given <dt>/<dd> have a valid parent).
+ */
+
+const id = 'definition-list-children-valid';
+
+const meta = {
+  title: 'Description lists must be structured correctly',
+  description: 'Checks that <dl> elements only directly contain <dt>/<dd> groups (optionally wrapped in one <div>), <script>, <template>, or <style>.',
+  i18n: {
+    titleKey: 'definitionListChildrenValid_title',
+    descriptionKey: 'definitionListChildrenValid_description'
+  },
+  helpUrl: null,
+  tags: ['wcag2a', 'wcag131', 'structure', 'atomic', 'automatic', 'list'],
+  wcagSc: ['1.3.1'],
+  normativeMappings: [
+    { standard: 'WCAG', version: '2.2', requirement: '1.3.1', title: 'Info and Relationships', conformanceLevel: 'A' }
+  ],
+  defaultSeverity: 'serious',
+  category: 'perceivable',
+  type: 'automatic',
+  defaultConfidence: 'high',
+  coverage: { facetsBySc: { '1.3.1': ['definition-list-children-valid'] } }
+};
+
+function runInPage(ctx) {
+  const { document, root, helpers, rule } = ctx;
+  const safeRoot = root || document;
+
+  // Declared inside runInPage — see scripts/build-core.js header
+  // ("runInPage MUST be self-contained").
+  const PASSTHROUGH_TAGS = new Set(['dt', 'dd', 'script', 'template', 'style']);
+
+  const nodes = helpers.queryAllSmart ? helpers.queryAllSmart('dl', safeRoot) : helpers.queryAll('dl', safeRoot);
+
+  const occurrences = [];
+  let applicableCount = 0;
+
+  for (const el of nodes) {
+    if (!el || !el.children) continue;
+    if (!el.children.length) continue;
+
+    applicableCount += 1;
+
+    // Flatten one level of wrapping <div> (common dt/dd grouping pattern).
+    const flattened = [];
+    for (const child of el.children) {
+      if (!child || !child.tagName) continue;
+      if (child.tagName.toLowerCase() === 'div') {
+        for (const grandchild of child.children || []) {
+          if (grandchild && grandchild.tagName) flattened.push(grandchild);
+        }
+      } else {
+        flattened.push(child);
+      }
+    }
+
+    let hasDt = false;
+    let hasDd = false;
+    const invalidTags = [];
+    for (const node of flattened) {
+      const tag = node.tagName.toLowerCase();
+      if (tag === 'dt') { hasDt = true; continue; }
+      if (tag === 'dd') { hasDd = true; continue; }
+      if (!PASSTHROUGH_TAGS.has(tag)) invalidTags.push(tag);
+    }
+
+    // Verified 2026-07-20 against a widely-used reference engine's definition-list check:
+    // the dt/dd pairing is only required "when not empty" — a <dl> with
+    // NEITHER dt nor dd (whether genuinely childless after flattening, only
+    // passthrough script/template/style content, or an empty wrapping div)
+    // is vacuously fine, not a violation. Only an UNBALANCED pairing (dt
+    // present without any dd, or vice versa) is a real structural problem.
+    const reasonCode = invalidTags.length
+        ? 'DL_INVALID_CHILD'
+        : ((hasDt || hasDd) && !(hasDt && hasDd) ? 'DL_NO_DT_DD' : 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.';
+    const hint = invalidTags.length
+        ? '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: invalidTags.join(', ') }
+      },
+      data: {
+        details: { reasonCode, invalidChildren: invalidTags }
+      }
+    });
+  }
+
+  if (applicableCount === 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: [] };
+}
+
+module.exports = { id, meta, runInPage };

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

@@ -0,0 +1,91 @@
+'use strict';
+
+/**
+ * @check deprecated-elements-not-used
+ * @atomic true
+ * @summary Obsolete non-stoppable elements must not be used
+ * @standard WCAG 2.2
+ * @sc 2.2.2
+ * @applicability
+ *   Applies to any <blink> or <marquee> element present in scope. These are
+ *   obsolete, non-standard HTML elements whose defining behavior (blinking
+ *   or auto-scrolling text) has no built-in user mechanism to pause, stop,
+ *   or hide it.
+ * @expectation
+ *   Neither element is present. Since their movement can never be paused,
+ *   stopped, or hidden by the user, presence is itself the violation — this
+ *   rule has no partial-pass case, matching a widely-used reference engine's `blink`/`marquee`
+ *   rules (which report only when the element is found).
+ * @implementation-notes
+ * - Not gated on isAccTreeEligible: presence in markup is itself the
+ *   violation, independent of visibility (moving/blinking content inside a
+ *   hidden ancestor could still become visible later without a code
+ *   change, so hiding it today does not remove the underlying defect).
+ */
+
+const id = 'deprecated-elements-not-used';
+
+const meta = {
+  title: 'Obsolete non-stoppable elements (<blink>, <marquee>) must not be used',
+  description: 'Checks that deprecated, non-standard HTML elements whose blinking/scrolling content cannot be paused, stopped, or hidden by the user (<blink>, <marquee>) are not present.',
+  i18n: {
+    titleKey: 'deprecatedElements_title',
+    descriptionKey: 'deprecatedElements_description'
+  },
+  helpUrl: null,
+  tags: ['wcag2a', 'wcag222', 'structure', 'atomic', 'automatic'],
+  wcagSc: ['2.2.2'],
+  normativeMappings: [
+    { standard: 'WCAG', version: '2.2', requirement: '2.2.2', title: 'Pause, Stop, Hide', conformanceLevel: 'A' }
+  ],
+  defaultSeverity: 'serious',
+  category: 'operable',
+  type: 'automatic',
+  defaultConfidence: 'high',
+  coverage: { facetsBySc: { '2.2.2': ['deprecated-non-stoppable-elements-absent'] } }
+};
+
+function runInPage(ctx) {
+  const { document, root, helpers, rule } = ctx;
+  const safeRoot = root || document;
+
+  const nodes = helpers.queryAllSmart ? helpers.queryAllSmart('blink, marquee', safeRoot) : helpers.queryAll('blink, marquee', safeRoot);
+
+  const occurrences = [];
+  let applicableCount = 0;
+
+  for (const el of nodes) {
+    if (!el || !el.tagName) continue;
+
+    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 }
+      }
+    });
+  }
+
+  if (applicableCount === 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: [] };
+}
+
+module.exports = { id, meta, runInPage };

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

@@ -0,0 +1,209 @@
+'use strict';
+
+const id = 'dialog-name-present';
+
+const meta = {
+  title: 'Dialogs have an accessible name',
+  description: 'Checks that elements with role="dialog" or role="alertdialog" expose a non-empty accessible name.',
+  i18n: {
+    titleKey: 'dialogNamePresent_title',
+    descriptionKey: 'dialogNamePresent_description'
+  },
+  helpUrl: null,
+  tags: ['wcag2a','wcag412','structure','atomic','automatic','name','dialog'],
+  wcagSc: ['4.1.2'],
+  normativeMappings: [
+    { standard: 'WCAG', version: '2.2', requirement: '4.1.2', title: 'Name, Role, Value', conformanceLevel: 'A' }
+  ],
+  defaultSeverity: 'serious',
+  category: 'robust',
+  type: 'automatic',
+  defaultConfidence: 'high',
+  coverage: { facetsBySc: { '4.1.2': ['dialog-name-present'] } }
+};
+
+function runInPage(ctx) {
+  const { document, root, helpers, rule } = ctx;
+  const getEligibilityInfo = helpers && typeof helpers.getEligibilityInfo === 'function'
+      ? helpers.getEligibilityInfo
+      : null;
+  const safeRoot = root || document;
+
+
+  function normalizeWs(s) {
+    return String(s || '').replace(/\s+/g, ' ').trim();
+  }
+
+  function getAttr(el, name) {
+    try {
+      if (!el || !el.getAttribute) return '';
+      return normalizeWs(el.getAttribute(name));
+    } catch { return ''; }
+  }
+
+  function hasAttr(el, name) {
+    try { return !!(el && el.hasAttribute && el.hasAttribute(name)); } catch { return false; }
+  }
+
+  function isExplicitProgrammatic(el) {
+    // Programmatic name mechanisms we treat as authoritative (presence-only):
+    // - aria-label (non-empty)
+    // - aria-labelledby (non-empty)
+    // - title (non-empty) [weak but allowed for presence]
+    const al = getAttr(el, 'aria-label');
+    if (al) return true;
+    const alb = getAttr(el, 'aria-labelledby');
+    if (alb) return true;
+    const t = getAttr(el, 'title');
+    if (t) return true;
+    return false;
+  }
+
+  function buildLabelForMap(doc) {
+    const map = new Map(); // id -> label element (first)
+    try {
+      const labels = doc && doc.getElementsByTagName ? doc.getElementsByTagName('label') : [];
+      for (let i = 0; i < labels.length; i += 1) {
+        const lab = labels[i];
+        if (!lab || !lab.getAttribute) continue;
+        const f = normalizeWs(lab.getAttribute('for'));
+        if (!f) continue;
+        if (!map.has(f)) map.set(f, lab);
+      }
+    } catch {}
+    return map;
+  }
+
+  function getConservativeSubtreeText(document, container) {
+    // "Name from content" — recurses into descendants and uses each one's
+    // own accessible name (img alt, aria-label/aria-labelledby, title) when
+    // it has one, not just literal text nodes. See getContentNameInfo's
+    // header comment in src/core/dom-helpers.js for the full rationale
+    // (this replaced a text-node-only TreeWalker that missed the common
+    // "<a><img alt='...'></a>" logo-link / "<button><img alt='...'></button>"
+    // icon-button pattern).
+    if (helpers.getContentNameInfo) {
+      const info = helpers.getContentNameInfo(container, ctx);
+      return info && info.present ? info.value : '';
+    }
+    const t = (container && container.textContent) ? String(container.textContent) : '';
+    return t.replace(/\s+/g, ' ').trim();
+  }
+
+  function resolveAriaLabelledbyText(document, el, maxRefs) {
+    const raw = getAttr(el, 'aria-labelledby');
+    if (!raw) return '';
+    // Resolve via the shared getTextFromIdRefs helper — computes each
+    // referenced element's own ACCESSIBLE NAME (aria-label, then
+    // aria-labelledby, then a value-like name, then content, then title),
+    // not just its content text. Found via a real page (BBC News' cookie-
+    // consent dialog, 2026-07-22): aria-labelledby pointed at an
+    // <iframe title="SP Consent Message">, whose only name source is its
+    // title attribute (an iframe's content is opaque/cross-origin per
+    // HTML-AAM, so "name from content" is always empty). The previous
+    // version here only ever computed name-from-content of the referenced
+    // node (via getConservativeSubtreeText), silently missing the title
+    // fallback and reporting no accessible name at all — the identical
+    // pattern was hand-copied into 15 other *-name-present rules; all
+    // fixed the same way.
+    if (helpers.getTextFromIdRefs) {
+      try {
+        const r = helpers.getTextFromIdRefs(raw, ctx, { maxRefs: maxRefs || 8 });
+        return normalizeWs(r && r.text);
+      } catch {}
+    }
+    return '';
+  }
+
+  function getInputValueName(el) {
+    try {
+      const type = getAttr(el, 'type').toLowerCase();
+      if (type !== 'button' && type !== 'submit' && type !== 'reset') return '';
+      const v = getAttr(el, 'value');
+      return v;
+    } catch { return ''; }
+  }
+
+  function isEligibleAcc(helpers, el, ctx) {
+    const fn = helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+    if (!fn) return true;
+    try {
+      const r = fn(el, ctx);
+      if (typeof r === 'boolean') return r;
+      return !!(r && r.eligible);
+    } catch {
+      return true;
+    }
+  }
+
+
+  const occurrences = [];
+  let applicableCount = 0;
+
+  const selector = '[role="dialog"],[role="alertdialog"]';
+  const nodes = helpers.queryAllSmart ? helpers.queryAllSmart(selector, safeRoot) : helpers.queryAll(selector, safeRoot);
+
+
+  function evaluate(el) {
+    const ariaLabel = getAttr(el, 'aria-label');
+    if (ariaLabel) return { ok: true, method: 'aria-label' };
+
+    const ariaLabelledby = resolveAriaLabelledbyText(document, el, 8);
+    if (ariaLabelledby) return { ok: true, method: 'aria-labelledby' };
+
+    const title = getAttr(el, 'title');
+    if (title) return { ok: true, method: 'title' };
+
+    // role="dialog"/"alertdialog" is name-from-author-only per WAI-ARIA: it
+    // must NOT fall back to subtree content. A dialog's heading or body
+    // text is not reliably exposed to assistive technologies as the
+    // dialog's accessible name unless explicitly wired via aria-labelledby.
+    return { ok: false, method: 'none' };
+  }
+
+  for (const el of nodes) {
+    if (!el) continue;
+    if (!isEligibleAcc(helpers, el, ctx)) continue;
+
+    const role = getAttr(el, 'role').toLowerCase();
+    if (role !== 'dialog' && role !== 'alertdialog') continue;
+
+    applicableCount += 1;
+
+    const res = evaluate(el);
+    if (res.ok) continue;
+
+    const eligInfo = getEligibilityInfo
+        ? (() => { try { return getEligibilityInfo(el, ctx, { targetSet: 'acc' }); } catch { return null; } })()
+        : 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: [] }
+      }
+    });
+  }
+
+
+  if (applicableCount === 0) {
+    return { ruleId: rule.ruleId, outcome: 'notApplicable', severity: 'minor', occurrences: [] };
+  }
+  if (occurrences.length) {
+    return { ruleId: rule.ruleId, outcome: 'fail', severity: rule.defaultSeverity || 'minor', occurrences };
+  }
+  return { ruleId: rule.ruleId, outcome: 'pass', severity: 'minor', occurrences: [] };
+}
+
+module.exports = { id, meta, runInPage };