@surea11y/core 1.4.0 → 1.5.0

package/src/checks/automatic/avoid-inline-spacing.js

@@ -5,31 +5,36 @@
 /**
  * @check avoid-inline-spacing
  * @atomic true
- * @summary Inline style must not force text-spacing properties with !important
+ * @summary Inline style must not force text spacing below the WCAG metric
  * @standard WCAG 2.2
  * @sc 1.4.12
  * @applicability
- *   Applies to elements with an inline style attribute that sets
- *   line-height, letter-spacing, or word-spacing.
+ *   Applies to a rendered element with visible text of its own whose style
+ *   attribute declares line-height, letter-spacing or word-spacing as
+ *   `!important` with a real value. A CSS-wide keyword (inherit, initial,
+ *   unset, revert) specifies no spacing of its own and is out of scope.
  * @expectation
- *   None of those three properties are declared with `!important` in the
- *   inline style. WCAG 1.4.12 (Text Spacing) requires that users be able
- *   to override these properties via a user stylesheet without losing
- *   content or functionality; `!important` on an inline declaration
- *   defeats that override (inline `!important` wins over nearly every
- *   other origin, including user stylesheets applied the normal way).
+ *   Each such declaration already meets WCAG 1.4.12's own metric for that
+ *   property, as a multiple of the font size: line-height at least 1.5,
+ *   letter-spacing at least 0.12, word-spacing at least 0.16. A forced value
+ *   that already satisfies the criterion leaves the user nothing to override.
  * @implementation-notes
- * - Static text-based parsing of the style attribute string (regex for
- *   the three property names followed by `!important`), not computed
- *   style.
+ * - Computed style resolves the cascade and the units; the declared value is
+ *   only a fallback for environments that do not lay the document out. Spacing
+ *   that resolves to neither is left unreported rather than failed.
+ * - Within one declaration block, importance outranks order, so the effective
+ *   declaration is the last `!important` one for that property.
+ * - ACT 78fd32/24afc2/9e45ec additionally require the text to contain a soft
+ *   wrap break, which cannot be determined without layout. Not implemented, so
+ *   a forced value on text that never wraps is still reported.
  */
 
 const id = 'avoid-inline-spacing';
 
 const meta = {
-  title: 'Inline style must not force text spacing with !important',
+  title: 'Inline style must not force text spacing below the WCAG metric',
   description:
-    'Checks that inline style does not set line-height, letter-spacing, or word-spacing with !important, which blocks user text-spacing overrides.',
+    'Checks that where inline style forces line-height, letter-spacing or word-spacing with !important, the value already meets WCAG 1.4.12, so the user has nothing left to override.',
   i18n: {
     titleKey: 'avoidInlineSpacing_title',
     descriptionKey: 'avoidInlineSpacing_description'
@@ -57,6 +62,20 @@ function runInPage(ctx) {
   const { helpers, rule } = ctx;
 
   const SPACING_PROPS = ['line-height', 'letter-spacing', 'word-spacing'];
+  // WCAG 1.4.12's own metrics, as multiples of the font size.
+  const MIN_RATIO = { 'line-height': 1.5, 'letter-spacing': 0.12, 'word-spacing': 0.16 };
+  // Only these two take the value from the parent, leaving this declaration
+  // specifying no spacing of its own. `initial` and `revert` resolve to a
+  // concrete value (`normal` for all three properties), so they stay in scope.
+  const INHERITED_KEYWORDS = ['inherit', 'unset'];
+  // No user agent's `normal` line height reaches 1.5, so a forced `normal`
+  // always falls short of the metric.
+  const NORMAL_LINE_HEIGHT_RATIO = 1.2;
+  const CAMEL = {
+    'line-height': 'lineHeight',
+    'letter-spacing': 'letterSpacing',
+    'word-spacing': 'wordSpacing'
+  };
 
   const nodes = helpers.queryAllSmart
     ? helpers.queryAllSmart('[style]')
@@ -65,6 +84,136 @@ function runInPage(ctx) {
   const occurrences = [];
   let applicableCount = 0;
 
+  // Within one declaration block, importance wins over order, so the last
+  // important declaration is the one that takes effect. Passed Example 5 of ACT
+  // 78fd32 turns on this and Passed Example 6 on the non-important half.
+  function effectiveDeclaration(raw, prop) {
+    const re = new RegExp('(?:^|;)\\s*' + prop + '\\s*:\\s*([^;]*)', 'gi');
+    let chosen = null;
+    let m;
+    while ((m = re.exec(raw))) {
+      const value = String(m[1] || '').trim();
+      const important = /!\s*important\s*$/i.test(value);
+      const clean = value.replace(/!\s*important\s*$/i, '').trim();
+      if (!clean) continue;
+      if (!chosen || important || !chosen.important) {
+        if (chosen && chosen.important && !important) continue;
+        chosen = { value: clean, important };
+      }
+    }
+    return chosen;
+  }
+
+  function hasVisibleTextChild(el) {
+    let kids;
+    try {
+      kids = el.childNodes ? Array.from(el.childNodes) : [];
+    } catch {
+      return false;
+    }
+    return kids.some((n) => n && n.nodeType === 3 && String(n.nodeValue || '').trim() !== '');
+  }
+
+  function isRendered(el) {
+    if (helpers.isDomVisibleEligible) {
+      try {
+        return !!helpers.isDomVisibleEligible(el, ctx, { targetSet: 'dom' }).eligible;
+      } catch {
+        return true;
+      }
+    }
+    return true;
+  }
+
+  const px = (v) => {
+    const n = parseFloat(v);
+    return Number.isFinite(n) && /px\s*$/.test(String(v)) ? n : null;
+  };
+
+  function computedStyleOf(el) {
+    if (helpers && typeof helpers.computedStyle === 'function') {
+      try {
+        const cs = helpers.computedStyle(el);
+        if (cs) return cs;
+      } catch {
+        // fall through to the realm's own view
+      }
+    }
+    try {
+      const view = el.ownerDocument && el.ownerDocument.defaultView;
+      if (view && typeof view.getComputedStyle === 'function') return view.getComputedStyle(el);
+    } catch {
+      // no computed style available
+    }
+    return null;
+  }
+
+  // ACT scopes these rules to text visible on screen, and text pushed far off
+  // canvas is the one hidden shape the shared eligibility check keeps eligible.
+  function isOffScreen(el) {
+    if (!helpers.getVisibilityHintsInfo) return false;
+    try {
+      const info = helpers.getVisibilityHintsInfo(el, ctx, {});
+      return !!(info && Array.isArray(info.hints) && info.hints.indexOf('offscreen') !== -1);
+    } catch {
+      return false;
+    }
+  }
+
+  // A realm that does not lay the document out reports font-size as the CSS
+  // absolute-size keyword rather than a length. Resolving those keeps px-valued
+  // spacing checkable there, and cannot manufacture a failure: a font size
+  // larger than assumed only makes a px ratio smaller.
+  const ABSOLUTE_FONT_SIZES = {
+    'xx-small': 9,
+    'x-small': 10,
+    small: 13,
+    medium: 16,
+    large: 18,
+    'x-large': 24,
+    'xx-large': 32
+  };
+
+  function fontSizeOf(cs) {
+    if (!cs) return null;
+    const direct = px(cs.fontSize);
+    if (direct !== null) return direct;
+    const keyword = String(cs.fontSize || '')
+      .trim()
+      .toLowerCase();
+    return ABSOLUTE_FONT_SIZES[keyword] || null;
+  }
+
+  /**
+   * The spacing as a multiple of the font size, or null when it cannot be
+   * resolved. Computed style is preferred because it already applies the
+   * cascade and unit resolution; the declared value is only a fallback for
+   * environments that do not lay the document out.
+   */
+  function spacingRatio(el, prop, declared) {
+    const cs = computedStyleOf(el);
+    const fontSize = fontSizeOf(cs);
+    if (cs && fontSize) {
+      const used = px(cs[CAMEL[prop]]);
+      if (used !== null) return used / fontSize;
+    }
+
+    const v = String(declared || '')
+      .trim()
+      .toLowerCase();
+    // `normal`, and the keywords that resolve to it, add nothing for the two
+    // spacing properties and stay under the metric for line height.
+    if (v === 'normal' || v === 'initial' || v === 'revert' || v === 'revert-layer') {
+      return prop === 'line-height' ? NORMAL_LINE_HEIGHT_RATIO : 0;
+    }
+    if (/^[0-9.]+$/.test(v)) return parseFloat(v);
+    if (/em$/.test(v)) return parseFloat(v);
+    if (/%$/.test(v)) return parseFloat(v) / 100;
+    const asPx = px(v);
+    if (asPx !== null && fontSize) return asPx / fontSize;
+    return null;
+  }
+
   for (const el of nodes) {
     if (!el || !el.getAttribute) continue;
     const raw = String(el.getAttribute('style') || '');
@@ -74,34 +223,43 @@ function runInPage(ctx) {
     const hasAnySpacingProp = SPACING_PROPS.some((p) => lower.includes(p));
     if (!hasAnySpacingProp) continue;
 
-    applicableCount += 1;
+    // The rule is about text the user needs to re-space, so an element with no
+    // text of its own, or none that renders, is not a target.
+    if (!hasVisibleTextChild(el) || !isRendered(el) || isOffScreen(el)) continue;
 
     const flagged = [];
+    let inScope = false;
     for (const prop of SPACING_PROPS) {
-      const re = new RegExp(prop.replace('-', '\\-') + '\\s*:[^;]*!important', 'i');
-      if (re.test(raw)) flagged.push(prop);
+      const decl = effectiveDeclaration(raw, prop);
+      if (!decl || !decl.important) continue;
+      if (INHERITED_KEYWORDS.indexOf(decl.value.toLowerCase()) !== -1) continue;
+      inScope = true;
+      const ratio = spacingRatio(el, prop, decl.value);
+      // Unresolvable spacing is left alone: this engine reserves fail for
+      // high-confidence violations.
+      if (ratio === null) continue;
+      if (ratio < MIN_RATIO[prop]) flagged.push(prop);
     }
 
+    if (inScope) applicableCount += 1;
     if (!flagged.length) 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 element's inline style forces ${flagged.join(', ')} with !important, blocking user text-spacing overrides.`,
-      hint: 'Remove !important from line-height/letter-spacing/word-spacing in inline styles so users can override text spacing.',
-      i18n: {
-        summaryKey: 'avoidInlineSpacing_summary_fail',
-        hintKey: 'avoidInlineSpacing_hint_fail',
-        params: { element: tag, properties: flagged.join(', ') }
-      },
-      data: {
-        details: { reasonCode: 'INLINE_SPACING_IMPORTANT', element: tag, properties: flagged }
-      }
-    });
+
+    occurrences.push(
+      helpers.reportOccurrence(el, {
+        summary: `This element's inline style forces ${flagged.join(', ')} with !important below the WCAG text-spacing metric, so the user cannot raise it.`,
+        hint: 'Remove !important from line-height/letter-spacing/word-spacing in inline styles, or set a value that already meets the metric (line-height 1.5, letter-spacing 0.12em, word-spacing 0.16em).',
+        i18n: {
+          summaryKey: 'avoidInlineSpacing_summary_fail',
+          hintKey: 'avoidInlineSpacing_hint_fail',
+          params: { element: tag, properties: flagged.join(', ') }
+        },
+        data: {
+          details: { reasonCode: 'INLINE_SPACING_IMPORTANT', element: tag, properties: flagged }
+        }
+      })
+    );
   }
 
   if (applicableCount === 0) {

package/src/checks/automatic/binary-control-name-present.js

@@ -137,9 +137,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);
@@ -153,8 +160,9 @@ function runInPage(ctx) {
   const occurrences = [];
   let applicableCount = 0;
 
-  const selector =
-    'input[type="checkbox"], input[type="radio"], [role="checkbox"], [role="radio"], [role="switch"]';
+  // Native checkbox/radio without an explicit role belongs to
+  // form-control-programmatic-label-present.
+  const selector = '[role="checkbox"], [role="radio"], [role="switch"]';
   const nodes = helpers.queryAllSmart
     ? helpers.queryAllSmart(selector)
     : helpers.queryAll(selector);
@@ -264,28 +272,26 @@ 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 control has no accessible name.',
-      hint: 'Provide a label, aria-label, aria-labelledby, or other accessible-name mechanism so assistive technologies can identify the control.',
-      i18n: {
-        summaryKey: 'binaryControlNamePresent_summary_fail',
-        hintKey: 'binaryControlNamePresent_hint_fail',
-        params: { controlType }
-      },
-      data: {
-        details: {
-          reasonCode: 'name_missing',
-          controlType,
-          methodTried: res.method
+
+    occurrences.push(
+      helpers.reportOccurrence(el, {
+        summary: 'This control has no accessible name.',
+        hint: 'Provide a label, aria-label, aria-labelledby, or other accessible-name mechanism so assistive technologies can identify the control.',
+        i18n: {
+          summaryKey: 'binaryControlNamePresent_summary_fail',
+          hintKey: 'binaryControlNamePresent_hint_fail',
+          params: { controlType }
         },
-        visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] }
-      }
-    });
+        data: {
+          details: {
+            reasonCode: 'name_missing',
+            controlType,
+            methodTried: res.method
+          },
+          visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] }
+        }
+      })
+    );
   }
 
   if (applicableCount === 0) {

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

@@ -78,7 +78,14 @@ function runInPage(ctx) {
 
   for (const el of nodes) {
     // isAccTreeEligible returns { eligible, reasons }, not a boolean.
-    const eligResult = helpers.isAccTreeEligible ? helpers.isAccTreeEligible(el, ctx) : true;
+    // Naming rules apply only to elements included in the accessibility tree
+    // (ACT c487ae), which excludes focusable aria-hidden content;
+    // aria-hidden-focus (ACT 6cfa84) covers that markup instead.
+    const eligResult = helpers.isIncludedInAccessibilityTree
+      ? helpers.isIncludedInAccessibilityTree(el, ctx)
+      : helpers.isAccTreeEligible
+        ? helpers.isAccTreeEligible(el, ctx)
+        : true;
     const eligible =
       typeof eligResult === 'boolean' ? eligResult : !!(eligResult && eligResult.eligible);
     if (!eligible) continue;
@@ -104,24 +111,50 @@ function runInPage(ctx) {
       inputValueName = getInputButtonValueName(el);
     }
 
-    // A native <button> (or [role="button"]) whose role has been overridden to
-    // one of these roles is no longer semantically a button — per the WAI-ARIA
-    // Accessible Name and Description Computation spec these roles are
-    // name-from-author-only, and their rendered content represents a VALUE,
-    // not a NAME. E.g. <button role="combobox">List</button> where "List" is
-    // the combobox's currently selected value, not a label — crediting it as
-    // the accessible name would mask a missing name.
-    const VALUE_ROLES = [
-      'textbox',
-      'progressbar',
-      'scrollbar',
-      'slider',
-      'spinbutton',
-      'combobox',
-      'listbox'
+    // ARIA 1.2 "Name From: author, contents". Every other known role is
+    // name-from-author-only: <button role="combobox">List</button> exposes a
+    // value, not a label. An unknown role falls back to the implicit role.
+    // <generated:aria-name-from-content>
+    const NAME_FROM_CONTENT_ROLES = [
+      'button',
+      'cell',
+      'checkbox',
+      'columnheader',
+      'doc-backlink',
+      'doc-biblioref',
+      'doc-glossref',
+      'doc-noteref',
+      'graphics-object',
+      'gridcell',
+      'heading',
+      'link',
+      'menuitem',
+      'menuitemcheckbox',
+      'menuitemradio',
+      'option',
+      'radio',
+      'row',
+      'rowgroup',
+      'rowheader',
+      'switch',
+      'tab',
+      'tooltip',
+      'treeitem'
     ];
+    // </generated:aria-name-from-content>
+    const isKnownRoleToken =
+      helpers && helpers.aria && typeof helpers.aria.isKnownRole === 'function'
+        ? (() => {
+            try {
+              return !!helpers.aria.isKnownRole(roleNorm);
+            } catch {
+              return false;
+            }
+          })()
+        : false;
     const isContentNameCandidate =
-      (tag === 'button' || role === 'button') && !VALUE_ROLES.includes(roleNorm);
+      (tag === 'button' || role === 'button') &&
+      (!roleNorm || !isKnownRoleToken || NAME_FROM_CONTENT_ROLES.includes(roleNorm));
     const contentName =
       !trustedProgrammaticName && !inputValueName && isContentNameCandidate
         ? getConservativeSubtreeText(el)
@@ -137,35 +170,30 @@ function runInPage(ctx) {
         ? helpers.getEligibilityInfo(el, ctx, { targetSet: 'acc' })
         : 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 button has no accessible name.',
-        hint: 'Provide visible button text or a programmatic accessible-name mechanism (for example aria-label) so assistive technologies can identify the button.',
-        i18n: {
-          summaryKey: 'buttonNamePresent_summary_fail',
-          hintKey: 'buttonNamePresent_hint_fail',
-          params: { element: tag }
-        },
-        data: {
-          visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] },
-          details: {
-            reasonCode: 'name_missing',
-            metrics: {
-              trustedProgrammaticNameLength: trustedProgrammaticName.length,
-              inputValueNameLength: inputValueName.length,
-              contentNameLength: contentName.length,
-              explicitProgrammatic: explicitProg ? 1 : 0
-            },
-            refs: { accessibleName: nameInfo || null }
+      occurrences.push(
+        helpers.reportOccurrence(el, {
+          summary: 'This button has no accessible name.',
+          hint: 'Provide visible button text or a programmatic accessible-name mechanism (for example aria-label) so assistive technologies can identify the button.',
+          i18n: {
+            summaryKey: 'buttonNamePresent_summary_fail',
+            hintKey: 'buttonNamePresent_hint_fail',
+            params: { element: tag }
+          },
+          data: {
+            visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] },
+            details: {
+              reasonCode: 'name_missing',
+              metrics: {
+                trustedProgrammaticNameLength: trustedProgrammaticName.length,
+                inputValueNameLength: inputValueName.length,
+                contentNameLength: contentName.length,
+                explicitProgrammatic: explicitProg ? 1 : 0
+              },
+              refs: { accessibleName: nameInfo || null }
+            }
           }
-        }
-      });
+        })
+      );
     }
   }
 

package/src/checks/automatic/canvas-text-alternative-present.js

@@ -9,9 +9,8 @@
  * @standard WCAG 2.2
  * @sc 1.1.1
  * @applicability
- *   Applies to <canvas> elements that are exposed to assistive technologies.
- *   Elements otherwise hidden from the accessibility tree remain applicable
- *   if they are focusable (tabbable) or referenced by IDREF relationships (per engine eligibility checks).
+ *   Applies to <canvas> elements included in the accessibility tree.
+ *   Hidden elements are excluded whether or not they are focusable.
  * @expectation
  *   Each applicable <canvas> provides a text alternative via fallback content or an accessible name.
  */
@@ -71,8 +70,15 @@ function runInPage(ctx) {
   const getEligibilityInfo =
     helpers && typeof helpers.getEligibilityInfo === 'function' ? helpers.getEligibilityInfo : null;
 
-  const isAccTreeEligible =
-    helpers && typeof helpers.isAccTreeEligible === 'function' ? helpers.isAccTreeEligible : null;
+  // aria-hidden removes the canvas from the accessibility tree, so a text
+  // alternative on it cannot reach anyone; aria-hidden-focus reports a
+  // focusable one. Matches the other non-text-content rules.
+  const isEligibleHelper =
+    helpers && typeof helpers.isIncludedInAccessibilityTree === 'function'
+      ? helpers.isIncludedInAccessibilityTree
+      : helpers && typeof helpers.isAccTreeEligible === 'function'
+        ? helpers.isAccTreeEligible
+        : null;
 
   const getTextAlternativeInfo =
     helpers && typeof helpers.getTextAlternativeInfo === 'function'
@@ -97,15 +103,16 @@ function runInPage(ctx) {
   for (const el of canvases) {
     if (!el) continue;
 
-    // Applicability: eligible in the accessibility tree (with focusable/IDREF exceptions handled by helper).
-    if (isAccTreeEligible) {
+    // Applicability: included in the accessibility tree.
+    if (isEligibleHelper) {
       const elig = (() => {
         try {
-          return isAccTreeEligible(el, ctx);
+          return isEligibleHelper(el, ctx);
         } catch {
           return { eligible: true, reasons: [] };
         }
       })();
+      if (elig === false) continue;
       if (elig && elig.eligible === false) continue;
     }
 

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

@@ -124,9 +124,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);
@@ -224,24 +231,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 combobox has no accessible name.',
-      hint: "Provide aria-label, aria-labelledby, or a title attribute — visible text content is not exposed as this combobox's accessible name.",
-      i18n: {
-        summaryKey: 'comboboxNamePresent_summary_fail',
-        hintKey: 'comboboxNamePresent_hint_fail',
-        params: {}
-      },
-      data: {
-        details: { reasonCode: 'name_missing', controlType: 'combobox', methodTried: res.method },
-        visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] }
-      }
-    });
+    occurrences.push(
+      helpers.reportOccurrence(el, {
+        summary: 'This combobox has no accessible name.',
+        hint: "Provide aria-label, aria-labelledby, or a title attribute — visible text content is not exposed as this combobox's accessible name.",
+        i18n: {
+          summaryKey: 'comboboxNamePresent_summary_fail',
+          hintKey: 'comboboxNamePresent_hint_fail',
+          params: {}
+        },
+        data: {
+          details: { reasonCode: 'name_missing', controlType: 'combobox', methodTried: res.method },
+          visibilityFilter: eligInfo || { targetSet: 'acc', accEligible: null, reasons: [] }
+        }
+      })
+    );
   }
 
   if (applicableCount === 0) {