From 2337221a48edd6ff666baf239f303babd2fdf5b8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Tue, 21 Apr 2026 07:50:06 +0200
Subject: [PATCH 01/14] fix(template-require-valid-alt-text): reject
 empty-string aria-label/aria-labelledby/alt
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Before: for <input type="image">, <object>, and <area>, the rule checked
only for the PRESENCE of an accessible-name fallback attribute
(aria-label / aria-labelledby / alt / title). An empty-string value
provides no accessible name but slipped past.

Fix: add hasNonEmptyTextAttr() that requires the attribute's static
value to be non-whitespace. Dynamic values (mustache, concat) remain
accepted — we can't tell at lint time whether they resolve to empty.

<img>'s alt handling is unchanged — alt="" is still valid there
(spec-defined marker for decorative images).

Nine new invalid tests cover the three elements × three fallback attrs.
---
 lib/rules/template-require-valid-alt-text.js  | 28 +++++++++--
 .../rules/template-require-valid-alt-text.js  | 47 +++++++++++++++++++
 2 files changed, 72 insertions(+), 3 deletions(-)

diff --git a/lib/rules/template-require-valid-alt-text.js b/lib/rules/template-require-valid-alt-text.js
index 7e7193c936..83febe0f0b 100644
--- a/lib/rules/template-require-valid-alt-text.js
+++ b/lib/rules/template-require-valid-alt-text.js
@@ -12,6 +12,26 @@ function hasAnyAttr(node, names) {
   return names.some((name) => hasAttr(node, name));
 }
 
+// For accessible-name fallback attributes (aria-label, aria-labelledby, title),
+// an empty string provides no accessible name — it must be checked as "any truthy
+// static value" or "any dynamic value". Returns true iff the attribute is
+// present AND will meaningfully contribute an accessible name.
+function hasNonEmptyTextAttr(node, name) {
+  const attr = findAttr(node, name);
+  if (!attr?.value) {
+    return false;
+  }
+  if (attr.value.type === 'GlimmerTextNode') {
+    return attr.value.chars.trim() !== '';
+  }
+  // Mustache / concat — dynamic; assume truthy.
+  return true;
+}
+
+function hasAnyNonEmptyTextAttr(node, names) {
+  return names.some((name) => hasNonEmptyTextAttr(node, name));
+}
+
 function getTextValue(attr) {
   if (!attr?.value) {
     return undefined;
@@ -166,7 +186,9 @@ module.exports = {
               return;
             }
 
-            if (!hasAnyAttr(node, ['aria-label', 'aria-labelledby', 'alt'])) {
+            // Empty-string aria-label/aria-labelledby/alt provides no accessible
+            // name — require a non-empty fallback value.
+            if (!hasAnyNonEmptyTextAttr(node, ['aria-label', 'aria-labelledby', 'alt'])) {
               context.report({ node, messageId: 'inputImage' });
             }
 
@@ -177,7 +199,7 @@ module.exports = {
             const roleValue = getTextValue(roleAttr);
 
             if (
-              hasAnyAttr(node, ['aria-label', 'aria-labelledby', 'title']) ||
+              hasAnyNonEmptyTextAttr(node, ['aria-label', 'aria-labelledby', 'title']) ||
               hasChildren(node) ||
               (roleValue && ['presentation', 'none'].includes(roleValue))
             ) {
@@ -189,7 +211,7 @@ module.exports = {
             break;
           }
           case 'area': {
-            if (!hasAnyAttr(node, ['aria-label', 'aria-labelledby', 'alt'])) {
+            if (!hasAnyNonEmptyTextAttr(node, ['aria-label', 'aria-labelledby', 'alt'])) {
               context.report({ node, messageId: 'areaMissing' });
             }
 
diff --git a/tests/lib/rules/template-require-valid-alt-text.js b/tests/lib/rules/template-require-valid-alt-text.js
index be3b6d4969..d4bc426353 100644
--- a/tests/lib/rules/template-require-valid-alt-text.js
+++ b/tests/lib/rules/template-require-valid-alt-text.js
@@ -59,6 +59,53 @@ ruleTester.run('template-require-valid-alt-text', rule, {
     '<template><img role={{unless this.altText "presentation"}} alt={{this.altText}}></template>',
   ],
   invalid: [
+    // Empty-string aria-label / aria-labelledby / alt provides no accessible
+    // name. These must flag (previously accepted by a presence-only check).
+    {
+      code: '<template><input type="image" aria-label="" /></template>',
+      output: null,
+      errors: [{ messageId: 'inputImage' }],
+    },
+    {
+      code: '<template><input type="image" aria-labelledby="" /></template>',
+      output: null,
+      errors: [{ messageId: 'inputImage' }],
+    },
+    {
+      code: '<template><input type="image" alt="" /></template>',
+      output: null,
+      errors: [{ messageId: 'inputImage' }],
+    },
+    {
+      code: '<template><object aria-label=""></object></template>',
+      output: null,
+      errors: [{ messageId: 'objectMissing' }],
+    },
+    {
+      code: '<template><object aria-labelledby=""></object></template>',
+      output: null,
+      errors: [{ messageId: 'objectMissing' }],
+    },
+    {
+      code: '<template><object title=""></object></template>',
+      output: null,
+      errors: [{ messageId: 'objectMissing' }],
+    },
+    {
+      code: '<template><area aria-label=""></template>',
+      output: null,
+      errors: [{ messageId: 'areaMissing' }],
+    },
+    {
+      code: '<template><area aria-labelledby=""></template>',
+      output: null,
+      errors: [{ messageId: 'areaMissing' }],
+    },
+    {
+      code: '<template><area alt=""></template>',
+      output: null,
+      errors: [{ messageId: 'areaMissing' }],
+    },
     {
       code: '<template><img src="/test.jpg" /></template>',
       output: null,

From 7488d8dd1a14b378f03f019f87d25d3492178e3f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Tue, 21 Apr 2026 16:29:08 +0200
Subject: [PATCH 02/14] chore: drop temporal 'previously accepted' comment

---
 tests/lib/rules/template-require-valid-alt-text.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/lib/rules/template-require-valid-alt-text.js b/tests/lib/rules/template-require-valid-alt-text.js
index d4bc426353..6a3723613e 100644
--- a/tests/lib/rules/template-require-valid-alt-text.js
+++ b/tests/lib/rules/template-require-valid-alt-text.js
@@ -60,7 +60,7 @@ ruleTester.run('template-require-valid-alt-text', rule, {
   ],
   invalid: [
     // Empty-string aria-label / aria-labelledby / alt provides no accessible
-    // name. These must flag (previously accepted by a presence-only check).
+    // name, so these must flag.
     {
       code: '<template><input type="image" aria-label="" /></template>',
       output: null,

From 56567ef73352f055076d56eea4bba79a020e20a8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Tue, 21 Apr 2026 17:52:28 +0200
Subject: [PATCH 03/14] test: add Phase 3 audit fixture translating alt-text
 peer cases

Translates 41 cases from peer-plugin rules:
  - jsx-a11y alt-text
  - vuejs-accessibility alt-text
  - lit-a11y alt-text

Fixture documents parity after this fix:
  - Empty-string aria-label/aria-labelledby on <object>, <area>, and
    <input type=image> is now flagged (reusing existing objectMissing /
    areaMissing / inputImage messageIds).

Remaining divergences (<img alt role=presentation> accepting non-empty
alt in jsx-a11y, <img aria-label> without alt) are annotated inline.
---
 tests/audit/alt-text/peer-parity.js | 190 ++++++++++++++++++++++++++++
 1 file changed, 190 insertions(+)
 create mode 100644 tests/audit/alt-text/peer-parity.js

diff --git a/tests/audit/alt-text/peer-parity.js b/tests/audit/alt-text/peer-parity.js
new file mode 100644
index 0000000000..77a371efcc
--- /dev/null
+++ b/tests/audit/alt-text/peer-parity.js
@@ -0,0 +1,190 @@
+// Audit fixture — peer-plugin parity for `ember/template-require-valid-alt-text`.
+// See docs/audit-a11y-behavior.md for the summary of divergences.
+//
+// Source files:
+//   - context/eslint-plugin-jsx-a11y-main/__tests__/src/rules/alt-text-test.js
+//   - context/eslint-plugin-vuejs-accessibility-main/src/rules/__tests__/alt-text.test.ts
+//   - context/eslint-plugin-lit-a11y/tests/lib/rules/alt-text.js
+
+'use strict';
+
+const rule = require('../../../lib/rules/template-require-valid-alt-text');
+const RuleTester = require('eslint').RuleTester;
+
+const ruleTester = new RuleTester({
+  parser: require.resolve('ember-eslint-parser'),
+  parserOptions: { ecmaVersion: 2022, sourceType: 'module' },
+});
+
+ruleTester.run('audit:alt-text (gts)', rule, {
+  valid: [
+    // === Upstream parity (valid in jsx-a11y + ours) ===
+    '<template><img alt="foo" /></template>',
+    '<template><img alt="" /></template>',
+    '<template><img alt=" " /></template>',
+    '<template><img alt="" role="presentation" /></template>',
+    '<template><img alt="" role="none" /></template>',
+    // DIVERGENCE — moved to invalid below:
+    // '<template><img alt="this is lit..." role="presentation" /></template>',
+    '<template><img alt={{@dynamicAlt}} /></template>',
+    // object with label/children
+    '<template><object aria-label="foo" /></template>',
+    '<template><object aria-labelledby="id1" /></template>',
+    '<template><object>Foo</object></template>',
+    '<template><object title="An object" /></template>',
+    // area with label
+    '<template><area aria-label="foo" /></template>',
+    '<template><area aria-labelledby="id1" /></template>',
+    '<template><area alt="foo" /></template>',
+    // input[type=image]
+    '<template><input type="image" alt="foo" /></template>',
+    '<template><input type="image" aria-label="foo" /></template>',
+    '<template><input type="image" aria-labelledby="id1" /></template>',
+
+    // === DIVERGENCE — aria-label/aria-labelledby on <img> without alt ===
+    // jsx-a11y: VALID — `<img aria-label="foo" />` is accepted.
+    // vue-a11y: VALID — same.
+    // Our rule: INVALID — requires `alt` attribute on <img>, full stop.
+    // Spec reading: the HTML spec mandates alt on <img>. WAI-ARIA accepts
+    // aria-label/aria-labelledby as alternative accessible-name sources. The
+    // two specs disagree; we side with HTML-strict.
+    // No valid test here — we flag; see invalid section.
+
+    // === Edge cases we handle ===
+    // alt === src (we flag)
+    // numeric alt (we flag)
+    // redundant words (we flag)
+  ],
+  invalid: [
+    // === Upstream parity (invalid in jsx-a11y + ours) ===
+    {
+      code: '<template><img /></template>',
+      output: null,
+      errors: [{ messageId: 'imgMissing' }],
+    },
+    {
+      code: '<template><input type="image" /></template>',
+      output: null,
+      errors: [{ messageId: 'inputImage' }],
+    },
+    {
+      code: '<template><object /></template>',
+      output: null,
+      errors: [{ messageId: 'objectMissing' }],
+    },
+    {
+      code: '<template><area /></template>',
+      output: null,
+      errors: [{ messageId: 'areaMissing' }],
+    },
+
+    // === DIVERGENCE — <img aria-label> without alt ===
+    // jsx-a11y: VALID. Ours: INVALID (imgMissing).
+    // Behavior captured here; potential false positive per WAI-ARIA.
+    {
+      code: '<template><img aria-label="foo" /></template>',
+      output: null,
+      errors: [{ messageId: 'imgMissing' }],
+    },
+    {
+      code: '<template><img aria-labelledby="id1" /></template>',
+      output: null,
+      errors: [{ messageId: 'imgMissing' }],
+    },
+
+    // === DIVERGENCE — non-empty alt with role=presentation on img ===
+    // jsx-a11y: VALID — accepts `<img alt="this is lit..." role="presentation" />`.
+    // Ours: INVALID — imgRolePresentation. We're spec-strict: if role is
+    //   "none"/"presentation", the image is decorative and alt should be empty.
+    {
+      code: '<template><img alt="this is lit..." role="presentation" /></template>',
+      output: null,
+      errors: [{ messageId: 'imgRolePresentation' }],
+    },
+
+    // === Parity — empty-string aria-label/aria-labelledby ===
+    // jsx-a11y / vuejs-accessibility flag empty-string fallbacks on the
+    //   "accessible-name-required" elements (<object>, <area>, <input
+    //   type=image>). Our rule now reuses the existing messageIds.
+    {
+      code: '<template><object aria-label="" /></template>',
+      output: null,
+      errors: [{ messageId: 'objectMissing' }],
+    },
+    {
+      code: '<template><object aria-labelledby="" /></template>',
+      output: null,
+      errors: [{ messageId: 'objectMissing' }],
+    },
+    {
+      code: '<template><area aria-label="" /></template>',
+      output: null,
+      errors: [{ messageId: 'areaMissing' }],
+    },
+    {
+      code: '<template><area aria-labelledby="" /></template>',
+      output: null,
+      errors: [{ messageId: 'areaMissing' }],
+    },
+    {
+      code: '<template><input type="image" aria-label="" /></template>',
+      output: null,
+      errors: [{ messageId: 'inputImage' }],
+    },
+    {
+      code: '<template><input type="image" aria-labelledby="" /></template>',
+      output: null,
+      errors: [{ messageId: 'inputImage' }],
+    },
+  ],
+});
+
+const hbsRuleTester = new RuleTester({
+  parser: require.resolve('ember-eslint-parser/hbs'),
+  parserOptions: { ecmaVersion: 2022, sourceType: 'module' },
+});
+
+hbsRuleTester.run('audit:alt-text (hbs)', rule, {
+  valid: [
+    '<img alt="foo" />',
+    '<img alt="" />',
+    '<img alt="" role="presentation" />',
+    '<object aria-label="foo" />',
+    '<area aria-label="foo" />',
+    '<input type="image" aria-label="foo" />',
+  ],
+  invalid: [
+    {
+      code: '<img />',
+      output: null,
+      errors: [{ messageId: 'imgMissing' }],
+    },
+    {
+      code: '<input type="image" />',
+      output: null,
+      errors: [{ messageId: 'inputImage' }],
+    },
+    {
+      code: '<object />',
+      output: null,
+      errors: [{ messageId: 'objectMissing' }],
+    },
+    {
+      code: '<area />',
+      output: null,
+      errors: [{ messageId: 'areaMissing' }],
+    },
+    // DIVERGENCE captured — we flag img-with-aria-label (jsx-a11y/vue-a11y don't)
+    {
+      code: '<img aria-label="foo" />',
+      output: null,
+      errors: [{ messageId: 'imgMissing' }],
+    },
+    // Parity — empty-string label on accessible-name-required elements.
+    {
+      code: '<object aria-label="" />',
+      output: null,
+      errors: [{ messageId: 'objectMissing' }],
+    },
+  ],
+});

From 98e022d5f71ff3752544f4c85b25b6c35bd74149 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Wed, 22 Apr 2026 14:21:08 +0200
Subject: [PATCH 04/14] fix+docs+test: trim whitespace, tighten JSDoc, add
 whitespace-only coverage (Copilot review)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- JSDoc for hasNonEmptyTextAttr() rewritten: no longer overstates the
  guarantee for dynamic values, and notes that aria-labelledby IDREFs
  are not validated.
- Added invalid-case coverage for whitespace-only aria-label /
  aria-labelledby / title — ACCNAME 1.2 §4.3.2 step 2D.
- hasNonEmptyTextAttr() already trims static values, so the new
  whitespace-only cases flag without further rule changes.
---
 lib/rules/template-require-valid-alt-text.js     | 14 ++++++++++----
 .../lib/rules/template-require-valid-alt-text.js | 16 ++++++++++++++++
 2 files changed, 26 insertions(+), 4 deletions(-)

diff --git a/lib/rules/template-require-valid-alt-text.js b/lib/rules/template-require-valid-alt-text.js
index 83febe0f0b..db533a4e6a 100644
--- a/lib/rules/template-require-valid-alt-text.js
+++ b/lib/rules/template-require-valid-alt-text.js
@@ -12,10 +12,16 @@ function hasAnyAttr(node, names) {
   return names.some((name) => hasAttr(node, name));
 }
 
-// For accessible-name fallback attributes (aria-label, aria-labelledby, title),
-// an empty string provides no accessible name — it must be checked as "any truthy
-// static value" or "any dynamic value". Returns true iff the attribute is
-// present AND will meaningfully contribute an accessible name.
+/**
+ * Returns true if the named attribute is present with a non-empty, non-whitespace
+ * static value, OR present with a dynamic (mustache/concat) value. Dynamic values
+ * are assumed to resolve to a meaningful name at runtime (we can't verify at lint
+ * time). Static empty-string / whitespace-only values return false — per ACCNAME 1.2
+ * §4.3.2 step 2D.
+ *
+ * NOTE: This does not validate that aria-labelledby IDREFs reference existing IDs.
+ * Rule consumers should layer that check separately if needed.
+ */
 function hasNonEmptyTextAttr(node, name) {
   const attr = findAttr(node, name);
   if (!attr?.value) {
diff --git a/tests/lib/rules/template-require-valid-alt-text.js b/tests/lib/rules/template-require-valid-alt-text.js
index 6a3723613e..0f497b015f 100644
--- a/tests/lib/rules/template-require-valid-alt-text.js
+++ b/tests/lib/rules/template-require-valid-alt-text.js
@@ -106,6 +106,22 @@ ruleTester.run('template-require-valid-alt-text', rule, {
       output: null,
       errors: [{ messageId: 'areaMissing' }],
     },
+    // Whitespace-only values are not valid accessible names per ACCNAME 1.2 §4.3.2 step 2D.
+    {
+      code: '<template><input type="image" aria-label=" " /></template>',
+      output: null,
+      errors: [{ messageId: 'inputImage' }],
+    },
+    {
+      code: '<template><object aria-labelledby="\n\t" ></object></template>',
+      output: null,
+      errors: [{ messageId: 'objectMissing' }],
+    },
+    {
+      code: '<template><area href="/" title=" " /></template>',
+      output: null,
+      errors: [{ messageId: 'areaMissing' }],
+    },
     {
       code: '<template><img src="/test.jpg" /></template>',
       output: null,

From 82022bbd1395e049dc1d4dfc139815a262785acb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Wed, 22 Apr 2026 14:22:09 +0200
Subject: [PATCH 05/14] docs: correct audit-fixture CI-run claim (Copilot
 review)

---
 tests/audit/alt-text/peer-parity.js | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/tests/audit/alt-text/peer-parity.js b/tests/audit/alt-text/peer-parity.js
index 77a371efcc..d0ca3661a6 100644
--- a/tests/audit/alt-text/peer-parity.js
+++ b/tests/audit/alt-text/peer-parity.js
@@ -1,4 +1,12 @@
-// Audit fixture — peer-plugin parity for `ember/template-require-valid-alt-text`.
+// Audit fixture — translates peer-plugin test cases into assertions against
+// our rule (`ember/template-require-valid-alt-text`). Runs as part of the
+// default Vitest suite (via the `tests/**/*.js` include glob) and serves
+// double-duty: (1) auditable record of peer-parity divergences,
+// (2) regression coverage pinning CURRENT behavior. Each case encodes what
+// OUR rule does today; divergences from upstream plugins are annotated as
+// `DIVERGENCE —`. Peer-only constructs that can't be translated to Ember
+// templates (JSX spread props, Vue v-bind, Angular `$event`, undefined-handler
+// expression analysis) are marked `AUDIT-SKIP`.
 // See docs/audit-a11y-behavior.md for the summary of divergences.
 //
 // Source files:

From bc642188bc45abfc651e4d5055de70dc97ccf459 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Thu, 23 Apr 2026 21:21:43 +0200
Subject: [PATCH 06/14] =?UTF-8?q?fix(template-require-valid-alt-text):=20a?=
 =?UTF-8?q?ddress=20Copilot=20review=20=E2=80=94=20JSDoc=20scope,=20area?=
 =?UTF-8?q?=20fallback=20test,=20HBS=20parity?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib/rules/template-require-valid-alt-text.js  |  6 ++-
 .../rules/template-require-valid-alt-text.js  | 37 ++++++++++++++++++-
 2 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/lib/rules/template-require-valid-alt-text.js b/lib/rules/template-require-valid-alt-text.js
index db533a4e6a..a08b160bb9 100644
--- a/lib/rules/template-require-valid-alt-text.js
+++ b/lib/rules/template-require-valid-alt-text.js
@@ -16,8 +16,10 @@ function hasAnyAttr(node, names) {
  * Returns true if the named attribute is present with a non-empty, non-whitespace
  * static value, OR present with a dynamic (mustache/concat) value. Dynamic values
  * are assumed to resolve to a meaningful name at runtime (we can't verify at lint
- * time). Static empty-string / whitespace-only values return false — per ACCNAME 1.2
- * §4.3.2 step 2D.
+ * time). Static empty-string / whitespace-only values return false — applied to
+ * alt / aria-label / aria-labelledby / title. The empty-name treatment aligns with
+ * ACCNAME 1.2 §4.3.2's aria-label step (2D), which normalizes empty/whitespace
+ * to "no name"; we apply the same normalization to the other fallbacks.
  *
  * NOTE: This does not validate that aria-labelledby IDREFs reference existing IDs.
  * Rule consumers should layer that check separately if needed.
diff --git a/tests/lib/rules/template-require-valid-alt-text.js b/tests/lib/rules/template-require-valid-alt-text.js
index 0f497b015f..8482ba563f 100644
--- a/tests/lib/rules/template-require-valid-alt-text.js
+++ b/tests/lib/rules/template-require-valid-alt-text.js
@@ -117,8 +117,11 @@ ruleTester.run('template-require-valid-alt-text', rule, {
       output: null,
       errors: [{ messageId: 'objectMissing' }],
     },
+    // <area>: title is NOT one of the accepted fallbacks per ACCNAME.
+    // Only alt / aria-label / aria-labelledby contribute. A whitespace-only
+    // aria-label should be flagged.
     {
-      code: '<template><area href="/" title=" " /></template>',
+      code: '<template><area href="/" aria-label=" " /></template>',
       output: null,
       errors: [{ messageId: 'areaMissing' }],
     },
@@ -327,6 +330,38 @@ hbsRuleTester.run('template-require-valid-alt-text', rule, {
         },
       ],
     },
+    // HBS parity: empty / whitespace-only accessible-name fallbacks
+    // should be flagged, mirroring the GTS cases above.
+    {
+      code: '<input type="image" aria-label=" " />',
+      output: null,
+      errors: [
+        {
+          message:
+            'All <input> elements with type="image" must have a text alternative through the `alt`, `aria-label`, or `aria-labelledby` attribute.',
+        },
+      ],
+    },
+    {
+      code: '<object aria-labelledby="\n\t" ></object>',
+      output: null,
+      errors: [
+        {
+          message:
+            'Embedded <object> elements must have alternative text by providing inner text, aria-label or aria-labelledby attributes.',
+        },
+      ],
+    },
+    {
+      code: '<area href="/" aria-label=" " />',
+      output: null,
+      errors: [
+        {
+          message:
+            'Each area of an image map must have a text alternative through the `alt`, `aria-label`, or `aria-labelledby` attribute.',
+        },
+      ],
+    },
     {
       code: '<img alt="picture">',
       output: null,

From e7c6a6a5e5c5ae0d3a579a18ba201a12c35f34a8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Fri, 24 Apr 2026 13:41:50 +0200
Subject: [PATCH 07/14] fix(#56): address round-2 Copilot review (drop unused
 hasAnyAttr helper)

---
 lib/rules/template-require-valid-alt-text.js | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/lib/rules/template-require-valid-alt-text.js b/lib/rules/template-require-valid-alt-text.js
index a08b160bb9..8bf958a645 100644
--- a/lib/rules/template-require-valid-alt-text.js
+++ b/lib/rules/template-require-valid-alt-text.js
@@ -8,10 +8,6 @@ function hasAttr(node, name) {
   return node.attributes?.some((a) => a.name === name);
 }
 
-function hasAnyAttr(node, names) {
-  return names.some((name) => hasAttr(node, name));
-}
-
 /**
  * Returns true if the named attribute is present with a non-empty, non-whitespace
  * static value, OR present with a dynamic (mustache/concat) value. Dynamic values

From 2abfbea4c966412633f4c940daac03c266f9c4dd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Fri, 24 Apr 2026 19:05:38 +0200
Subject: [PATCH 08/14] chore(alt-text/peer-parity): drop reference to
 non-existent docs/audit-a11y-behavior.md (Copilot review)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

That doc was never checked in. Remove the dangling reference and note
that divergences are captured inline (grep for 'DIVERGENCE —') plus in
PR descriptions — matches how the other peer-parity fixtures describe
their own divergence records.
---
 tests/audit/alt-text/peer-parity.js | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/tests/audit/alt-text/peer-parity.js b/tests/audit/alt-text/peer-parity.js
index d0ca3661a6..8f08fd9d48 100644
--- a/tests/audit/alt-text/peer-parity.js
+++ b/tests/audit/alt-text/peer-parity.js
@@ -6,8 +6,9 @@
 // OUR rule does today; divergences from upstream plugins are annotated as
 // `DIVERGENCE —`. Peer-only constructs that can't be translated to Ember
 // templates (JSX spread props, Vue v-bind, Angular `$event`, undefined-handler
-// expression analysis) are marked `AUDIT-SKIP`.
-// See docs/audit-a11y-behavior.md for the summary of divergences.
+// expression analysis) are marked `AUDIT-SKIP`. Divergences are also captured
+// in PR descriptions / commit messages; grepping the repo for `DIVERGENCE —`
+// surfaces the full list.
 //
 // Source files:
 //   - context/eslint-plugin-jsx-a11y-main/__tests__/src/rules/alt-text-test.js

From 67de7c73fdc15c6492149b5887058793fc92d8df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Fri, 24 Apr 2026 19:22:29 +0200
Subject: [PATCH 09/14] fix(template-require-valid-alt-text): unwrap mustache
 literals via shared helper (Copilot review)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Extract a new `getStaticAttrValue` util that resolves literal-valued
mustaches (`{{"foo"}}`, `{{true}}`, `{{-1}}`) and single-part concat
statements (`"{{true}}"`) to their static string value. `hasNonEmptyTextAttr`
now delegates to the helper — `aria-label={{""}}` / `aria-label="{{""}}"`
normalise to the empty string and flag the same as the text-node equivalent;
genuinely dynamic values (PathExpressions, multi-part concat) still
short-circuit to "assume truthy". Closes the bypass where authors wrapped
an empty accessible name in mustaches.

Byte-identical carrier of lib/utils/static-attr-value.js across all PRs
that land it.
---
 lib/rules/template-require-valid-alt-text.js  |  15 +-
 lib/utils/static-attr-value.js                |  64 +++++++++
 .../rules/template-require-valid-alt-text.js  |  15 ++
 tests/lib/utils/static-attr-value-test.js     | 129 ++++++++++++++++++
 4 files changed, 219 insertions(+), 4 deletions(-)
 create mode 100644 lib/utils/static-attr-value.js
 create mode 100644 tests/lib/utils/static-attr-value-test.js

diff --git a/lib/rules/template-require-valid-alt-text.js b/lib/rules/template-require-valid-alt-text.js
index 8bf958a645..45c423614b 100644
--- a/lib/rules/template-require-valid-alt-text.js
+++ b/lib/rules/template-require-valid-alt-text.js
@@ -1,3 +1,5 @@
+const { getStaticAttrValue } = require('../utils/static-attr-value');
+
 const REDUNDANT_WORDS = ['image', 'photo', 'picture', 'logo', 'spacer'];
 
 function findAttr(node, name) {
@@ -25,11 +27,16 @@ function hasNonEmptyTextAttr(node, name) {
   if (!attr?.value) {
     return false;
   }
-  if (attr.value.type === 'GlimmerTextNode') {
-    return attr.value.chars.trim() !== '';
+  // Resolve mustache-literal / single-part concat forms to their static
+  // string via the shared helper. `aria-label={{""}}` / `aria-label="{{""}}"`
+  // now normalise to the empty string and are treated the same as the
+  // text-node empty value.
+  const resolved = getStaticAttrValue(attr.value);
+  if (resolved === undefined) {
+    // Genuinely dynamic — assume truthy (can't verify at lint time).
+    return true;
   }
-  // Mustache / concat — dynamic; assume truthy.
-  return true;
+  return resolved.trim() !== '';
 }
 
 function hasAnyNonEmptyTextAttr(node, names) {
diff --git a/lib/utils/static-attr-value.js b/lib/utils/static-attr-value.js
new file mode 100644
index 0000000000..6499c782a9
--- /dev/null
+++ b/lib/utils/static-attr-value.js
@@ -0,0 +1,64 @@
+'use strict';
+
+/**
+ * Return the statically-known string value of a Glimmer attribute value node,
+ * or `undefined` when the value is dynamic (cannot be resolved at lint time).
+ *
+ * Unwraps:
+ *   - GlimmerTextNode → chars
+ *   - GlimmerMustacheStatement with a literal path (boolean/string/number) → stringified value
+ *   - GlimmerConcatStatement whose parts are all statically resolvable → joined string
+ *
+ * A missing/undefined value (valueless attribute, e.g. `<input disabled>`)
+ * returns the empty string. Pass `attr.value` — not the attribute itself.
+ */
+function getStaticAttrValue(value) {
+  if (value === null || value === undefined) {
+    return '';
+  }
+  if (value.type === 'GlimmerTextNode') {
+    return value.chars;
+  }
+  if (value.type === 'GlimmerMustacheStatement') {
+    return extractLiteral(value.path);
+  }
+  if (value.type === 'GlimmerConcatStatement') {
+    const parts = value.parts || [];
+    let out = '';
+    for (const part of parts) {
+      if (part.type === 'GlimmerTextNode') {
+        out += part.chars;
+        continue;
+      }
+      if (part.type === 'GlimmerMustacheStatement') {
+        const literal = extractLiteral(part.path);
+        if (literal === undefined) {
+          return undefined;
+        }
+        out += literal;
+        continue;
+      }
+      return undefined;
+    }
+    return out;
+  }
+  return undefined;
+}
+
+function extractLiteral(path) {
+  if (!path) {
+    return undefined;
+  }
+  if (path.type === 'GlimmerBooleanLiteral') {
+    return path.value ? 'true' : 'false';
+  }
+  if (path.type === 'GlimmerStringLiteral') {
+    return path.value;
+  }
+  if (path.type === 'GlimmerNumberLiteral') {
+    return String(path.value);
+  }
+  return undefined;
+}
+
+module.exports = { getStaticAttrValue };
diff --git a/tests/lib/rules/template-require-valid-alt-text.js b/tests/lib/rules/template-require-valid-alt-text.js
index 8482ba563f..4a8bc60261 100644
--- a/tests/lib/rules/template-require-valid-alt-text.js
+++ b/tests/lib/rules/template-require-valid-alt-text.js
@@ -57,6 +57,9 @@ ruleTester.run('template-require-valid-alt-text', rule, {
     '<template><area aria-labelledby="some-alt"></template>',
     '<template><area aria-label="some-alt"></template>',
     '<template><img role={{unless this.altText "presentation"}} alt={{this.altText}}></template>',
+    // Mustache-string-literal forms resolve to their static value — a
+    // non-empty literal supplies an accessible name the same as a text node.
+    '<template><input type="image" aria-label={{"valid"}} /></template>',
   ],
   invalid: [
     // Empty-string aria-label / aria-labelledby / alt provides no accessible
@@ -125,6 +128,18 @@ ruleTester.run('template-require-valid-alt-text', rule, {
       output: null,
       errors: [{ messageId: 'areaMissing' }],
     },
+    // Mustache-string-literal forms that resolve to an empty string are
+    // treated the same as the text-node empty value — no accessible name.
+    {
+      code: '<template><input type="image" aria-label={{""}} /></template>',
+      output: null,
+      errors: [{ messageId: 'inputImage' }],
+    },
+    {
+      code: '<template><input type="image" aria-label="{{""}}" /></template>',
+      output: null,
+      errors: [{ messageId: 'inputImage' }],
+    },
     {
       code: '<template><img src="/test.jpg" /></template>',
       output: null,
diff --git a/tests/lib/utils/static-attr-value-test.js b/tests/lib/utils/static-attr-value-test.js
new file mode 100644
index 0000000000..ea9a4f30c6
--- /dev/null
+++ b/tests/lib/utils/static-attr-value-test.js
@@ -0,0 +1,129 @@
+'use strict';
+
+const { getStaticAttrValue } = require('../../../lib/utils/static-attr-value');
+
+describe('getStaticAttrValue', () => {
+  it('returns empty string for null/undefined (valueless attribute)', () => {
+    expect(getStaticAttrValue(null)).toBe('');
+    expect(getStaticAttrValue(undefined)).toBe('');
+  });
+
+  it('returns chars for GlimmerTextNode', () => {
+    expect(getStaticAttrValue({ type: 'GlimmerTextNode', chars: 'hello' })).toBe('hello');
+    expect(getStaticAttrValue({ type: 'GlimmerTextNode', chars: '' })).toBe('');
+  });
+
+  it('unwraps GlimmerMustacheStatement with BooleanLiteral', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerBooleanLiteral', value: true },
+      })
+    ).toBe('true');
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerBooleanLiteral', value: false },
+      })
+    ).toBe('false');
+  });
+
+  it('unwraps GlimmerMustacheStatement with StringLiteral', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerStringLiteral', value: 'foo' },
+      })
+    ).toBe('foo');
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerStringLiteral', value: '' },
+      })
+    ).toBe('');
+  });
+
+  it('unwraps GlimmerMustacheStatement with NumberLiteral', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerNumberLiteral', value: -1 },
+      })
+    ).toBe('-1');
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerNumberLiteral', value: 0 },
+      })
+    ).toBe('0');
+  });
+
+  it('returns undefined for GlimmerMustacheStatement with a dynamic PathExpression', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerMustacheStatement',
+        path: { type: 'GlimmerPathExpression', original: 'this.foo' },
+      })
+    ).toBeUndefined();
+  });
+
+  it('joins GlimmerConcatStatement with only static parts', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerConcatStatement',
+        parts: [
+          { type: 'GlimmerTextNode', chars: 'prefix-' },
+          {
+            type: 'GlimmerMustacheStatement',
+            path: { type: 'GlimmerStringLiteral', value: 'mid' },
+          },
+          { type: 'GlimmerTextNode', chars: '-suffix' },
+        ],
+      })
+    ).toBe('prefix-mid-suffix');
+  });
+
+  it('joins concat with boolean and number literal parts', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerConcatStatement',
+        parts: [
+          {
+            type: 'GlimmerMustacheStatement',
+            path: { type: 'GlimmerBooleanLiteral', value: true },
+          },
+        ],
+      })
+    ).toBe('true');
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerConcatStatement',
+        parts: [
+          {
+            type: 'GlimmerMustacheStatement',
+            path: { type: 'GlimmerNumberLiteral', value: -1 },
+          },
+        ],
+      })
+    ).toBe('-1');
+  });
+
+  it('returns undefined for GlimmerConcatStatement with a dynamic part', () => {
+    expect(
+      getStaticAttrValue({
+        type: 'GlimmerConcatStatement',
+        parts: [
+          { type: 'GlimmerTextNode', chars: 'x-' },
+          {
+            type: 'GlimmerMustacheStatement',
+            path: { type: 'GlimmerPathExpression', original: 'this.foo' },
+          },
+        ],
+      })
+    ).toBeUndefined();
+  });
+
+  it('returns undefined for an unknown node type', () => {
+    expect(getStaticAttrValue({ type: 'GlimmerSubExpression' })).toBeUndefined();
+  });
+});

From 6101f280f8279bd84830eac2ad8feb7a60282307 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Sat, 25 Apr 2026 06:45:43 +0200
Subject: [PATCH 10/14] test(template-require-valid-alt-text): absorb
 audit-fixture cases, drop audit fixture
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Upstream maintainers don't want the per-PR `tests/audit/peer-parity`
pattern. Port one case that pinned distinct behavior:
- `<img alt=" " />` as VALID — whitespace-only alt is currently
  treated as decorative; jsx-a11y agrees.

All other audit cases were already covered by the regular tests on
this branch (extensive existing coverage of object/area/input variants,
empty aria-label/labelledby, presentation-role conflicts, etc).
---
 tests/audit/alt-text/peer-parity.js           | 199 ------------------
 .../rules/template-require-valid-alt-text.js  |   3 +
 2 files changed, 3 insertions(+), 199 deletions(-)
 delete mode 100644 tests/audit/alt-text/peer-parity.js

diff --git a/tests/audit/alt-text/peer-parity.js b/tests/audit/alt-text/peer-parity.js
deleted file mode 100644
index 8f08fd9d48..0000000000
--- a/tests/audit/alt-text/peer-parity.js
+++ /dev/null
@@ -1,199 +0,0 @@
-// Audit fixture — translates peer-plugin test cases into assertions against
-// our rule (`ember/template-require-valid-alt-text`). Runs as part of the
-// default Vitest suite (via the `tests/**/*.js` include glob) and serves
-// double-duty: (1) auditable record of peer-parity divergences,
-// (2) regression coverage pinning CURRENT behavior. Each case encodes what
-// OUR rule does today; divergences from upstream plugins are annotated as
-// `DIVERGENCE —`. Peer-only constructs that can't be translated to Ember
-// templates (JSX spread props, Vue v-bind, Angular `$event`, undefined-handler
-// expression analysis) are marked `AUDIT-SKIP`. Divergences are also captured
-// in PR descriptions / commit messages; grepping the repo for `DIVERGENCE —`
-// surfaces the full list.
-//
-// Source files:
-//   - context/eslint-plugin-jsx-a11y-main/__tests__/src/rules/alt-text-test.js
-//   - context/eslint-plugin-vuejs-accessibility-main/src/rules/__tests__/alt-text.test.ts
-//   - context/eslint-plugin-lit-a11y/tests/lib/rules/alt-text.js
-
-'use strict';
-
-const rule = require('../../../lib/rules/template-require-valid-alt-text');
-const RuleTester = require('eslint').RuleTester;
-
-const ruleTester = new RuleTester({
-  parser: require.resolve('ember-eslint-parser'),
-  parserOptions: { ecmaVersion: 2022, sourceType: 'module' },
-});
-
-ruleTester.run('audit:alt-text (gts)', rule, {
-  valid: [
-    // === Upstream parity (valid in jsx-a11y + ours) ===
-    '<template><img alt="foo" /></template>',
-    '<template><img alt="" /></template>',
-    '<template><img alt=" " /></template>',
-    '<template><img alt="" role="presentation" /></template>',
-    '<template><img alt="" role="none" /></template>',
-    // DIVERGENCE — moved to invalid below:
-    // '<template><img alt="this is lit..." role="presentation" /></template>',
-    '<template><img alt={{@dynamicAlt}} /></template>',
-    // object with label/children
-    '<template><object aria-label="foo" /></template>',
-    '<template><object aria-labelledby="id1" /></template>',
-    '<template><object>Foo</object></template>',
-    '<template><object title="An object" /></template>',
-    // area with label
-    '<template><area aria-label="foo" /></template>',
-    '<template><area aria-labelledby="id1" /></template>',
-    '<template><area alt="foo" /></template>',
-    // input[type=image]
-    '<template><input type="image" alt="foo" /></template>',
-    '<template><input type="image" aria-label="foo" /></template>',
-    '<template><input type="image" aria-labelledby="id1" /></template>',
-
-    // === DIVERGENCE — aria-label/aria-labelledby on <img> without alt ===
-    // jsx-a11y: VALID — `<img aria-label="foo" />` is accepted.
-    // vue-a11y: VALID — same.
-    // Our rule: INVALID — requires `alt` attribute on <img>, full stop.
-    // Spec reading: the HTML spec mandates alt on <img>. WAI-ARIA accepts
-    // aria-label/aria-labelledby as alternative accessible-name sources. The
-    // two specs disagree; we side with HTML-strict.
-    // No valid test here — we flag; see invalid section.
-
-    // === Edge cases we handle ===
-    // alt === src (we flag)
-    // numeric alt (we flag)
-    // redundant words (we flag)
-  ],
-  invalid: [
-    // === Upstream parity (invalid in jsx-a11y + ours) ===
-    {
-      code: '<template><img /></template>',
-      output: null,
-      errors: [{ messageId: 'imgMissing' }],
-    },
-    {
-      code: '<template><input type="image" /></template>',
-      output: null,
-      errors: [{ messageId: 'inputImage' }],
-    },
-    {
-      code: '<template><object /></template>',
-      output: null,
-      errors: [{ messageId: 'objectMissing' }],
-    },
-    {
-      code: '<template><area /></template>',
-      output: null,
-      errors: [{ messageId: 'areaMissing' }],
-    },
-
-    // === DIVERGENCE — <img aria-label> without alt ===
-    // jsx-a11y: VALID. Ours: INVALID (imgMissing).
-    // Behavior captured here; potential false positive per WAI-ARIA.
-    {
-      code: '<template><img aria-label="foo" /></template>',
-      output: null,
-      errors: [{ messageId: 'imgMissing' }],
-    },
-    {
-      code: '<template><img aria-labelledby="id1" /></template>',
-      output: null,
-      errors: [{ messageId: 'imgMissing' }],
-    },
-
-    // === DIVERGENCE — non-empty alt with role=presentation on img ===
-    // jsx-a11y: VALID — accepts `<img alt="this is lit..." role="presentation" />`.
-    // Ours: INVALID — imgRolePresentation. We're spec-strict: if role is
-    //   "none"/"presentation", the image is decorative and alt should be empty.
-    {
-      code: '<template><img alt="this is lit..." role="presentation" /></template>',
-      output: null,
-      errors: [{ messageId: 'imgRolePresentation' }],
-    },
-
-    // === Parity — empty-string aria-label/aria-labelledby ===
-    // jsx-a11y / vuejs-accessibility flag empty-string fallbacks on the
-    //   "accessible-name-required" elements (<object>, <area>, <input
-    //   type=image>). Our rule now reuses the existing messageIds.
-    {
-      code: '<template><object aria-label="" /></template>',
-      output: null,
-      errors: [{ messageId: 'objectMissing' }],
-    },
-    {
-      code: '<template><object aria-labelledby="" /></template>',
-      output: null,
-      errors: [{ messageId: 'objectMissing' }],
-    },
-    {
-      code: '<template><area aria-label="" /></template>',
-      output: null,
-      errors: [{ messageId: 'areaMissing' }],
-    },
-    {
-      code: '<template><area aria-labelledby="" /></template>',
-      output: null,
-      errors: [{ messageId: 'areaMissing' }],
-    },
-    {
-      code: '<template><input type="image" aria-label="" /></template>',
-      output: null,
-      errors: [{ messageId: 'inputImage' }],
-    },
-    {
-      code: '<template><input type="image" aria-labelledby="" /></template>',
-      output: null,
-      errors: [{ messageId: 'inputImage' }],
-    },
-  ],
-});
-
-const hbsRuleTester = new RuleTester({
-  parser: require.resolve('ember-eslint-parser/hbs'),
-  parserOptions: { ecmaVersion: 2022, sourceType: 'module' },
-});
-
-hbsRuleTester.run('audit:alt-text (hbs)', rule, {
-  valid: [
-    '<img alt="foo" />',
-    '<img alt="" />',
-    '<img alt="" role="presentation" />',
-    '<object aria-label="foo" />',
-    '<area aria-label="foo" />',
-    '<input type="image" aria-label="foo" />',
-  ],
-  invalid: [
-    {
-      code: '<img />',
-      output: null,
-      errors: [{ messageId: 'imgMissing' }],
-    },
-    {
-      code: '<input type="image" />',
-      output: null,
-      errors: [{ messageId: 'inputImage' }],
-    },
-    {
-      code: '<object />',
-      output: null,
-      errors: [{ messageId: 'objectMissing' }],
-    },
-    {
-      code: '<area />',
-      output: null,
-      errors: [{ messageId: 'areaMissing' }],
-    },
-    // DIVERGENCE captured — we flag img-with-aria-label (jsx-a11y/vue-a11y don't)
-    {
-      code: '<img aria-label="foo" />',
-      output: null,
-      errors: [{ messageId: 'imgMissing' }],
-    },
-    // Parity — empty-string label on accessible-name-required elements.
-    {
-      code: '<object aria-label="" />',
-      output: null,
-      errors: [{ messageId: 'objectMissing' }],
-    },
-  ],
-});
diff --git a/tests/lib/rules/template-require-valid-alt-text.js b/tests/lib/rules/template-require-valid-alt-text.js
index 4a8bc60261..2c00947593 100644
--- a/tests/lib/rules/template-require-valid-alt-text.js
+++ b/tests/lib/rules/template-require-valid-alt-text.js
@@ -12,6 +12,9 @@ ruleTester.run('template-require-valid-alt-text', rule, {
     '<template><img alt="Company branding" src="/logo.png" /></template>',
     '<template><img alt="" src="/decorative.png" /></template>',
     '<template><img hidden alt="" /></template>',
+    // Whitespace-only alt — pin our current behavior. Peer plugins
+    // (jsx-a11y) accept this; we don't trim before considering "empty alt".
+    '<template><img alt=" " /></template>',
 
     '<template><img alt="hullo"></template>',
     '<template><img alt={{foo}}></template>',

From 19e44c40ec3026d1817e39167b240b537540ad2e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Sat, 25 Apr 2026 08:15:28 +0200
Subject: [PATCH 11/14] =?UTF-8?q?BUGFIX:=20template-require-iframe-title?=
 =?UTF-8?q?=20=E2=80=94=20flag=20invalid=20title=20literals=20+=20add=20al?=
 =?UTF-8?q?lowWhitespaceOnlyTitle=20opt-out?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Treat literal AST values that don't produce a meaningful accessible name
as invalid `<iframe title>` values:

- `GlimmerBooleanLiteral` / `GlimmerNullLiteral` / `GlimmerUndefinedLiteral` /
  `GlimmerNumberLiteral` → flagged with a new `invalidTitleLiteral` messageId.
  Coerce-to-string runtime values like "true" / "null" / "42" don't
  describe the frame contents, regardless of framework behavior.
- `GlimmerStringLiteral` resolving to empty / whitespace → flagged as
  `emptyTitle` (resolution shared with the text-node case via a
  `processStaticTitle` helper). Closes a bypass that jsx-a11y already
  catches via `getLiteralPropValue`.

Both literal classes apply to the bare-mustache `title={{x}}` form AND
the single-part concat `title="{{x}}"` form.

Whitespace-only static title (`title="   "`) is now opt-out via a new
`allowWhitespaceOnlyTitle: true` schema option. ACCNAME 1.2 §4.3.2 step
2I (Tooltip) does not whitespace-trim — so a 3-space accessible name is
spec-assigned. The check stays on by default as authoring hygiene; teams
that want strict spec parity can opt out. Empty-string `title=""` and
the non-string-literal cases above are not affected by this option —
they are always flagged as correctness.

Refs:
- WCAG SC 4.1.2: https://www.w3.org/TR/UNDERSTANDING-WCAG20/ensure-compat-rsv.html
- ACCNAME 1.2 §4.3.2: https://www.w3.org/TR/accname-1.2/#computation-steps
---
 docs/rules/template-require-iframe-title.md   |  46 ++++-
 lib/rules/template-require-iframe-title.js    | 182 +++++++++++++-----
 .../rules/template-require-iframe-title.js    | 135 ++++++++++++-
 3 files changed, 309 insertions(+), 54 deletions(-)

diff --git a/docs/rules/template-require-iframe-title.md b/docs/rules/template-require-iframe-title.md
index 145f9bd4ec..fdfde0f8ec 100644
--- a/docs/rules/template-require-iframe-title.md
+++ b/docs/rules/template-require-iframe-title.md
@@ -6,9 +6,11 @@
 
 ## `<iframe>`
 
-`<iframe>` elements must have a unique title property to indicate its content to the user.
-
-This rule takes no arguments.
+`<iframe>` elements must have a unique title property so assistive
+technology can convey their content to the user. The normative
+requirement is [WCAG SC 4.1.2 (Name, Role, Value)](https://www.w3.org/TR/UNDERSTANDING-WCAG20/ensure-compat-rsv.html);
+the `title` attribute is _one sufficient technique_ for meeting it
+(sufficient technique [H64](https://www.w3.org/WAI/WCAG21/Techniques/html/H64)).
 
 ## Examples
 
@@ -27,12 +29,42 @@ This rule **forbids** the following:
 <template>
   <iframe />
   <iframe title='' />
+  <iframe title='   ' />
+  <iframe title={{null}} />
+  <iframe title={{undefined}} />
+  <iframe title={{true}} />
+  <iframe title={{false}} />
+  <iframe title={{42}} />
 </template>
 ```
 
+Whitespace-only `title` (`"   "`) is flagged by default as an
+authoring-hygiene check: HTML and ACCNAME technically permit it (step 2I
+doesn't trim), but a whitespace-only accessible name is useless in
+practice. Suppress this specific strictness via
+`allowWhitespaceOnlyTitle: true` if your codebase needs it.
+
+## Configuration
+
+- `allowWhitespaceOnlyTitle` (`boolean`, default `false`): when `true`,
+  `<iframe title="   ">` is accepted. Empty-string `title=""` and
+  non-string mustache literals (`{{null}}`, `{{undefined}}`, `{{42}}`) are
+  still flagged.
+
+```js
+module.exports = {
+  rules: {
+    'ember/template-require-iframe-title': ['error', { allowWhitespaceOnlyTitle: true }],
+  },
+};
+```
+
 ## References
 
-- [Deque University](https://dequeuniversity.com/rules/axe/1.1/frame-title)
-- [Technique H65: Using the title attribute of the frame and iframe elements](https://www.w3.org/TR/2014/NOTE-WCAG20-TECHS-20140408/H64)
-- [WCAG Success Criterion 2.4.1 - Bypass Blocks](https://www.w3.org/TR/UNDERSTANDING-WCAG20/navigation-mechanisms-skip.html)
-- [WCAG Success Criterion 4.1.2 - Name, Role, Value](https://www.w3.org/TR/UNDERSTANDING-WCAG20/ensure-compat-rsv.html)
+- [WCAG SC 4.1.2 — Name, Role, Value](https://www.w3.org/TR/UNDERSTANDING-WCAG20/ensure-compat-rsv.html)
+  — the normative requirement.
+- [WCAG Technique H64 — Using the title attribute of the iframe element](https://www.w3.org/WAI/WCAG21/Techniques/html/H64)
+  — a sufficient technique for SC 4.1.2, not itself normative.
+- [WCAG Success Criterion 2.4.1 — Bypass Blocks](https://www.w3.org/TR/UNDERSTANDING-WCAG20/navigation-mechanisms-skip.html)
+- [ACCNAME 1.2 — accessible-name computation](https://www.w3.org/TR/accname-1.2/)
+- [axe-core rule `frame-title`](https://dequeuniversity.com/rules/axe/4.10/frame-title)
diff --git a/lib/rules/template-require-iframe-title.js b/lib/rules/template-require-iframe-title.js
index d4f4b2f636..0520c09086 100644
--- a/lib/rules/template-require-iframe-title.js
+++ b/lib/rules/template-require-iframe-title.js
@@ -1,3 +1,43 @@
+'use strict';
+
+// Non-string literal AST nodes (boolean/null/undefined/number) don't represent
+// a meaningful author-provided title. Even though they would coerce to strings
+// at runtime (e.g. `true` → "true", `42` → "42"), those strings do not describe
+// the frame's content — the rule rejects the literal forms.
+const INVALID_LITERAL_TYPES = new Set([
+  'GlimmerBooleanLiteral',
+  'GlimmerNullLiteral',
+  'GlimmerUndefinedLiteral',
+  'GlimmerNumberLiteral',
+]);
+
+function isInvalidTitleLiteralPath(path) {
+  return INVALID_LITERAL_TYPES.has(path?.type);
+}
+
+function getInvalidLiteralType(path) {
+  if (!path) {
+    return undefined;
+  }
+  switch (path.type) {
+    case 'GlimmerBooleanLiteral': {
+      return 'boolean';
+    }
+    case 'GlimmerNullLiteral': {
+      return 'null';
+    }
+    case 'GlimmerUndefinedLiteral': {
+      return 'undefined';
+    }
+    case 'GlimmerNumberLiteral': {
+      return 'number';
+    }
+    default: {
+      return undefined;
+    }
+  }
+}
+
 /** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
@@ -8,13 +48,25 @@ module.exports = {
       url: 'https://github.com/ember-cli/eslint-plugin-ember/tree/master/docs/rules/template-require-iframe-title.md',
       templateMode: 'both',
     },
-    schema: [],
+    fixable: null,
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          allowWhitespaceOnlyTitle: {
+            type: 'boolean',
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
     messages: {
-      // Four messageIds (missingTitle, emptyTitle, dynamicFalseTitle,
-      // duplicateTitle) for richer diagnostic detail.
+      // Five messageIds (missingTitle, emptyTitle, invalidTitleLiteral,
+      // duplicateTitleFirst, duplicateTitleOther) for richer diagnostic detail.
       missingTitle: '<iframe> elements must have a unique title property.',
       emptyTitle: '<iframe> elements must have a unique title property.',
-      dynamicFalseTitle: '<iframe> elements must have a unique title property.',
+      invalidTitleLiteral:
+        '<iframe title> must be a non-empty string. Got {{literalType}} literal, which does not describe the frame contents.',
       duplicateTitleFirst: 'This title is not unique. #{{index}}',
       duplicateTitleOther:
         '<iframe> elements must have a unique title property. Value title="{{title}}" already used for different iframe. #{{index}}',
@@ -27,6 +79,14 @@ module.exports = {
     },
   },
   create(context) {
+    // Whitespace-only `title="   "` is technically spec-compliant: ACCNAME
+    // 1.2 step 2I (Tooltip) does not whitespace-trim like step 2D
+    // (aria-label) does, so a 3-space accessible name is assigned. That is
+    // useless in practice but not a spec violation. Default behavior flags
+    // it as authoring hygiene; set `allowWhitespaceOnlyTitle: true` to
+    // align with spec/peer behavior.
+    const allowWhitespaceOnlyTitle = Boolean(context.options[0]?.allowWhitespaceOnlyTitle);
+
     // Each entry: { value, node, index }
     //  - value: trimmed title string
     //  - node: original element node for the first occurrence
@@ -34,6 +94,44 @@ module.exports = {
     const knownTitles = [];
     let nextDuplicateIndex = 1;
 
+    // Process a statically-known title string (from a text node OR a
+    // mustache string literal OR a single-part concat). Handles the empty /
+    // whitespace / duplicate logic that's shared across those AST shapes.
+    function processStaticTitle(node, raw) {
+      const value = raw.trim();
+      if (value.length === 0) {
+        // Empty-string title always fails: no accessible name for screen readers.
+        // Whitespace-only titles are controlled by `allowWhitespaceOnlyTitle`.
+        if (raw.length === 0 || !allowWhitespaceOnlyTitle) {
+          context.report({ node, messageId: 'emptyTitle' });
+        }
+        return;
+      }
+      // Duplicate check — reports BOTH the first and the current occurrence
+      // on every collision, sharing a `#N` index so users can correlate them.
+      // For three or more duplicates the first occurrence is therefore
+      // re-reported once per collision.
+      const existing = knownTitles.find((entry) => entry.value === value);
+      if (existing) {
+        if (existing.index === null) {
+          existing.index = nextDuplicateIndex++;
+        }
+        const index = existing.index;
+        context.report({
+          node: existing.node,
+          messageId: 'duplicateTitleFirst',
+          data: { index: String(index) },
+        });
+        context.report({
+          node,
+          messageId: 'duplicateTitleOther',
+          data: { title: raw, index: String(index) },
+        });
+      } else {
+        knownTitles.push({ value, node, index: null });
+      }
+    }
+
     return {
       GlimmerElementNode(node) {
         if (node.tag !== 'iframe') {
@@ -57,57 +155,55 @@ module.exports = {
         if (titleAttr.value) {
           switch (titleAttr.value.type) {
             case 'GlimmerTextNode': {
-              const value = titleAttr.value.chars.trim();
-              if (value.length === 0) {
-                context.report({ node, messageId: 'emptyTitle' });
-              } else {
-                // Check for duplicate titles. Reports BOTH the first and the
-                // current occurrence on every collision, sharing a `#N` index
-                // so users can correlate them. For three or more duplicates
-                // the first occurrence is therefore re-reported once per
-                // collision.
-                const existing = knownTitles.find((entry) => entry.value === value);
-                if (existing) {
-                  if (existing.index === null) {
-                    existing.index = nextDuplicateIndex++;
-                  }
-                  const index = existing.index;
-
-                  // Report on the first occurrence on every collision.
-                  context.report({
-                    node: existing.node,
-                    messageId: 'duplicateTitleFirst',
-                    data: { index: String(index) },
-                  });
-
-                  // Report on the current (duplicate) occurrence.
-                  context.report({
-                    node,
-                    messageId: 'duplicateTitleOther',
-                    data: { title: titleAttr.value.chars, index: String(index) },
-                  });
-                } else {
-                  knownTitles.push({ value, node, index: null });
-                }
-              }
+              processStaticTitle(node, titleAttr.value.chars);
               break;
             }
             case 'GlimmerMustacheStatement': {
-              // title={{false}} → BooleanLiteral false is invalid
-              if (titleAttr.value.path?.type === 'GlimmerBooleanLiteral') {
-                context.report({ node, messageId: 'dynamicFalseTitle' });
+              // Non-string literal mustaches — boolean / null / undefined /
+              // number — get a specific "invalidTitleLiteral" diagnostic
+              // because the literal coerces to a string at runtime that
+              // doesn't describe the frame contents.
+              if (isInvalidTitleLiteralPath(titleAttr.value.path)) {
+                context.report({
+                  node,
+                  messageId: 'invalidTitleLiteral',
+                  data: { literalType: getInvalidLiteralType(titleAttr.value.path) },
+                });
+                break;
+              }
+              // String-literal mustaches resolve to their static value — a
+              // non-empty literal supplies an accessible name the same as a
+              // text node. Empty / whitespace literals are flagged the same
+              // way as `title=""` / `title="   "`.
+              if (titleAttr.value.path?.type === 'GlimmerStringLiteral') {
+                processStaticTitle(node, titleAttr.value.path.value);
               }
               break;
             }
             case 'GlimmerConcatStatement': {
-              // title="{{false}}" → ConcatStatement with single BooleanLiteral part
               const parts = titleAttr.value.parts || [];
+              // Single-part concat wrapping a non-string literal — same
+              // diagnostic as the bare mustache form.
+              if (
+                parts.length === 1 &&
+                parts[0].type === 'GlimmerMustacheStatement' &&
+                isInvalidTitleLiteralPath(parts[0].path)
+              ) {
+                context.report({
+                  node,
+                  messageId: 'invalidTitleLiteral',
+                  data: { literalType: getInvalidLiteralType(parts[0].path) },
+                });
+                break;
+              }
+              // Single-part concat wrapping a string literal — resolve to
+              // the static value and apply the same checks as a text node.
               if (
                 parts.length === 1 &&
                 parts[0].type === 'GlimmerMustacheStatement' &&
-                parts[0].path?.type === 'GlimmerBooleanLiteral'
+                parts[0].path?.type === 'GlimmerStringLiteral'
               ) {
-                context.report({ node, messageId: 'dynamicFalseTitle' });
+                processStaticTitle(node, parts[0].path.value);
               }
               break;
             }
diff --git a/tests/lib/rules/template-require-iframe-title.js b/tests/lib/rules/template-require-iframe-title.js
index 25d4f9545a..06a17b56c3 100644
--- a/tests/lib/rules/template-require-iframe-title.js
+++ b/tests/lib/rules/template-require-iframe-title.js
@@ -17,7 +17,15 @@ ruleTester.run('template-require-iframe-title', rule, {
     '<template><iframe title={{someValue}} /></template>',
     '<template><iframe title="" aria-hidden /></template>',
     '<template><iframe title="" hidden /></template>',
+    // Mustache string literals resolve to their static value — non-empty
+    // literals supply an accessible name the same as a text node.
+    '<template><iframe title={{"My frame"}} /></template>',
     '<template><iframe title="foo" /><iframe title="bar" /></template>',
+    // allowWhitespaceOnlyTitle: true — whitespace-only accepted.
+    {
+      code: '<template><iframe title="   " /></template>',
+      options: [{ allowWhitespaceOnlyTitle: true }],
+    },
   ],
   invalid: [
     {
@@ -30,6 +38,20 @@ ruleTester.run('template-require-iframe-title', rule, {
       output: null,
       errors: [{ messageId: 'emptyTitle' }],
     },
+    // Empty string-literal mustaches and concat-with-empty-string-literal
+    // resolve to "" via the static-attr-value handling and are flagged the
+    // same as the text-node empty case. Closes a bypass jsx-a11y already
+    // catches via getLiteralPropValue.
+    {
+      code: '<template><iframe title={{""}} /></template>',
+      output: null,
+      errors: [{ messageId: 'emptyTitle' }],
+    },
+    {
+      code: '<template><iframe title="{{""}}" /></template>',
+      output: null,
+      errors: [{ messageId: 'emptyTitle' }],
+    },
 
     {
       // Both occurrences are reported with a shared `#N` index.
@@ -92,18 +114,65 @@ ruleTester.run('template-require-iframe-title', rule, {
     {
       code: '<template><iframe src="12" title={{false}} /></template>',
       output: null,
-      errors: [{ messageId: 'dynamicFalseTitle' }],
+      errors: [{ messageId: 'invalidTitleLiteral', data: { literalType: 'boolean' } }],
     },
     {
       code: '<template><iframe src="12" title="{{false}}" /></template>',
       output: null,
-      errors: [{ messageId: 'dynamicFalseTitle' }],
+      errors: [{ messageId: 'invalidTitleLiteral', data: { literalType: 'boolean' } }],
     },
     {
       code: '<template><iframe src="12" title="" /></template>',
       output: null,
       errors: [{ messageId: 'emptyTitle' }],
     },
+
+    // Mustache literals that don't coerce to a useful accessible name.
+    {
+      code: '<template><iframe title={{null}} /></template>',
+      output: null,
+      errors: [{ messageId: 'invalidTitleLiteral', data: { literalType: 'null' } }],
+    },
+    {
+      code: '<template><iframe title={{undefined}} /></template>',
+      output: null,
+      errors: [{ messageId: 'invalidTitleLiteral', data: { literalType: 'undefined' } }],
+    },
+    {
+      code: '<template><iframe title={{42}} /></template>',
+      output: null,
+      errors: [{ messageId: 'invalidTitleLiteral', data: { literalType: 'number' } }],
+    },
+    {
+      code: '<template><iframe title="{{null}}" /></template>',
+      output: null,
+      errors: [{ messageId: 'invalidTitleLiteral', data: { literalType: 'null' } }],
+    },
+    {
+      code: '<template><iframe title="{{undefined}}" /></template>',
+      output: null,
+      errors: [{ messageId: 'invalidTitleLiteral', data: { literalType: 'undefined' } }],
+    },
+    {
+      code: '<template><iframe title="{{42}}" /></template>',
+      output: null,
+      errors: [{ messageId: 'invalidTitleLiteral', data: { literalType: 'number' } }],
+    },
+
+    // Whitespace-only title is flagged by default (authoring hygiene).
+    {
+      code: '<template><iframe title="   " /></template>',
+      output: null,
+      errors: [{ messageId: 'emptyTitle' }],
+    },
+    // Empty-string title is flagged even with allowWhitespaceOnlyTitle: true
+    // (an empty string is not a whitespace string).
+    {
+      code: '<template><iframe title="" /></template>',
+      output: null,
+      options: [{ allowWhitespaceOnlyTitle: true }],
+      errors: [{ messageId: 'emptyTitle' }],
+    },
   ],
 });
 
@@ -122,6 +191,11 @@ hbsRuleTester.run('template-require-iframe-title', rule, {
     '<iframe title="" aria-hidden />',
     '<iframe title="" hidden />',
     '<iframe title="foo" /><iframe title="bar" />',
+    // allowWhitespaceOnlyTitle: true — whitespace-only accepted in HBS too.
+    {
+      code: '<iframe title="   " />',
+      options: [{ allowWhitespaceOnlyTitle: true }],
+    },
   ],
   invalid: [
     {
@@ -177,17 +251,70 @@ hbsRuleTester.run('template-require-iframe-title', rule, {
     {
       code: '<iframe src="12" title={{false}} />',
       output: null,
-      errors: [{ message: '<iframe> elements must have a unique title property.' }],
+      errors: [
+        {
+          message:
+            '<iframe title> must be a non-empty string. Got boolean literal, which does not describe the frame contents.',
+        },
+      ],
     },
     {
       code: '<iframe src="12" title="{{false}}" />',
       output: null,
-      errors: [{ message: '<iframe> elements must have a unique title property.' }],
+      errors: [
+        {
+          message:
+            '<iframe title> must be a non-empty string. Got boolean literal, which does not describe the frame contents.',
+        },
+      ],
     },
     {
       code: '<iframe src="12" title="" />',
       output: null,
       errors: [{ message: '<iframe> elements must have a unique title property.' }],
     },
+
+    // hbs parity with gjs for the other non-string mustache literals
+    // (boolean true / null / undefined / number).
+    {
+      code: '<iframe title={{true}} />',
+      output: null,
+      errors: [
+        {
+          message:
+            '<iframe title> must be a non-empty string. Got boolean literal, which does not describe the frame contents.',
+        },
+      ],
+    },
+    {
+      code: '<iframe title={{null}} />',
+      output: null,
+      errors: [
+        {
+          message:
+            '<iframe title> must be a non-empty string. Got null literal, which does not describe the frame contents.',
+        },
+      ],
+    },
+    {
+      code: '<iframe title={{undefined}} />',
+      output: null,
+      errors: [
+        {
+          message:
+            '<iframe title> must be a non-empty string. Got undefined literal, which does not describe the frame contents.',
+        },
+      ],
+    },
+    {
+      code: '<iframe title={{42}} />',
+      output: null,
+      errors: [
+        {
+          message:
+            '<iframe title> must be a non-empty string. Got number literal, which does not describe the frame contents.',
+        },
+      ],
+    },
   ],
 });

From 6cc136ffa8206906e5bd6f940bd374f8f18b1bae Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Sat, 25 Apr 2026 15:48:50 +0200
Subject: [PATCH 12/14] docs(template-require-valid-alt-text): add WCAG SC
 4.1.2 citation to JSDoc

---
 lib/rules/template-require-valid-alt-text.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/lib/rules/template-require-valid-alt-text.js b/lib/rules/template-require-valid-alt-text.js
index 45c423614b..c08d6a65b1 100644
--- a/lib/rules/template-require-valid-alt-text.js
+++ b/lib/rules/template-require-valid-alt-text.js
@@ -18,6 +18,8 @@ function hasAttr(node, name) {
  * alt / aria-label / aria-labelledby / title. The empty-name treatment aligns with
  * ACCNAME 1.2 §4.3.2's aria-label step (2D), which normalizes empty/whitespace
  * to "no name"; we apply the same normalization to the other fallbacks.
+ * (Why a name is needed: WCAG SC 4.1.2 — "all user interface components have a
+ * name and role that can be programmatically determined.")
  *
  * NOTE: This does not validate that aria-labelledby IDREFs reference existing IDs.
  * Rule consumers should layer that check separately if needed.

From 30b3fe9036a39d1d645f530361e83ae49f3e7e37 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Sat, 25 Apr 2026 14:55:40 +0000
Subject: [PATCH 13/14] chore(deps): update wyvox/action-setup-pnpm action to
 v4 (#2742)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 .github/workflows/bench-compare.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/bench-compare.yml b/.github/workflows/bench-compare.yml
index 4df9a18d1b..ef63226b0f 100644
--- a/.github/workflows/bench-compare.yml
+++ b/.github/workflows/bench-compare.yml
@@ -26,7 +26,7 @@ jobs:
           # (github.head_ref is a branch name that only exists on the fork remote).
           ref: ${{ github.event.pull_request.head.sha }}
 
-      - uses: wyvox/action-setup-pnpm@v3
+      - uses: wyvox/action-setup-pnpm@v4
 
       - name: Run benchmark comparison
         env:

From 634af79f587234f09539848cbd0f7d2ef28d3ac9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Sat, 25 Apr 2026 17:12:27 +0200
Subject: [PATCH 14/14] refactor(template-require-iframe-title): remove
 allowWhitespaceOnlyTitle option

Whitespace-only titles are never intentional and the option added API
surface with no real-world use case. Always flag empty/whitespace title
values as errors.
---
 docs/rules/template-require-iframe-title.md   | 21 ---------------
 lib/rules/template-require-iframe-title.js    | 26 ++-----------------
 .../rules/template-require-iframe-title.js    | 18 -------------
 3 files changed, 2 insertions(+), 63 deletions(-)

diff --git a/docs/rules/template-require-iframe-title.md b/docs/rules/template-require-iframe-title.md
index fdfde0f8ec..fec30d7a63 100644
--- a/docs/rules/template-require-iframe-title.md
+++ b/docs/rules/template-require-iframe-title.md
@@ -38,27 +38,6 @@ This rule **forbids** the following:
 </template>
 ```
 
-Whitespace-only `title` (`"   "`) is flagged by default as an
-authoring-hygiene check: HTML and ACCNAME technically permit it (step 2I
-doesn't trim), but a whitespace-only accessible name is useless in
-practice. Suppress this specific strictness via
-`allowWhitespaceOnlyTitle: true` if your codebase needs it.
-
-## Configuration
-
-- `allowWhitespaceOnlyTitle` (`boolean`, default `false`): when `true`,
-  `<iframe title="   ">` is accepted. Empty-string `title=""` and
-  non-string mustache literals (`{{null}}`, `{{undefined}}`, `{{42}}`) are
-  still flagged.
-
-```js
-module.exports = {
-  rules: {
-    'ember/template-require-iframe-title': ['error', { allowWhitespaceOnlyTitle: true }],
-  },
-};
-```
-
 ## References
 
 - [WCAG SC 4.1.2 — Name, Role, Value](https://www.w3.org/TR/UNDERSTANDING-WCAG20/ensure-compat-rsv.html)
diff --git a/lib/rules/template-require-iframe-title.js b/lib/rules/template-require-iframe-title.js
index 0520c09086..0be3d19f7d 100644
--- a/lib/rules/template-require-iframe-title.js
+++ b/lib/rules/template-require-iframe-title.js
@@ -49,17 +49,7 @@ module.exports = {
       templateMode: 'both',
     },
     fixable: null,
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allowWhitespaceOnlyTitle: {
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
+    schema: [],
     messages: {
       // Five messageIds (missingTitle, emptyTitle, invalidTitleLiteral,
       // duplicateTitleFirst, duplicateTitleOther) for richer diagnostic detail.
@@ -79,14 +69,6 @@ module.exports = {
     },
   },
   create(context) {
-    // Whitespace-only `title="   "` is technically spec-compliant: ACCNAME
-    // 1.2 step 2I (Tooltip) does not whitespace-trim like step 2D
-    // (aria-label) does, so a 3-space accessible name is assigned. That is
-    // useless in practice but not a spec violation. Default behavior flags
-    // it as authoring hygiene; set `allowWhitespaceOnlyTitle: true` to
-    // align with spec/peer behavior.
-    const allowWhitespaceOnlyTitle = Boolean(context.options[0]?.allowWhitespaceOnlyTitle);
-
     // Each entry: { value, node, index }
     //  - value: trimmed title string
     //  - node: original element node for the first occurrence
@@ -100,11 +82,7 @@ module.exports = {
     function processStaticTitle(node, raw) {
       const value = raw.trim();
       if (value.length === 0) {
-        // Empty-string title always fails: no accessible name for screen readers.
-        // Whitespace-only titles are controlled by `allowWhitespaceOnlyTitle`.
-        if (raw.length === 0 || !allowWhitespaceOnlyTitle) {
-          context.report({ node, messageId: 'emptyTitle' });
-        }
+        context.report({ node, messageId: 'emptyTitle' });
         return;
       }
       // Duplicate check — reports BOTH the first and the current occurrence
diff --git a/tests/lib/rules/template-require-iframe-title.js b/tests/lib/rules/template-require-iframe-title.js
index 06a17b56c3..1146537e0f 100644
--- a/tests/lib/rules/template-require-iframe-title.js
+++ b/tests/lib/rules/template-require-iframe-title.js
@@ -21,11 +21,6 @@ ruleTester.run('template-require-iframe-title', rule, {
     // literals supply an accessible name the same as a text node.
     '<template><iframe title={{"My frame"}} /></template>',
     '<template><iframe title="foo" /><iframe title="bar" /></template>',
-    // allowWhitespaceOnlyTitle: true — whitespace-only accepted.
-    {
-      code: '<template><iframe title="   " /></template>',
-      options: [{ allowWhitespaceOnlyTitle: true }],
-    },
   ],
   invalid: [
     {
@@ -165,14 +160,6 @@ ruleTester.run('template-require-iframe-title', rule, {
       output: null,
       errors: [{ messageId: 'emptyTitle' }],
     },
-    // Empty-string title is flagged even with allowWhitespaceOnlyTitle: true
-    // (an empty string is not a whitespace string).
-    {
-      code: '<template><iframe title="" /></template>',
-      output: null,
-      options: [{ allowWhitespaceOnlyTitle: true }],
-      errors: [{ messageId: 'emptyTitle' }],
-    },
   ],
 });
 
@@ -191,11 +178,6 @@ hbsRuleTester.run('template-require-iframe-title', rule, {
     '<iframe title="" aria-hidden />',
     '<iframe title="" hidden />',
     '<iframe title="foo" /><iframe title="bar" />',
-    // allowWhitespaceOnlyTitle: true — whitespace-only accepted in HBS too.
-    {
-      code: '<iframe title="   " />',
-      options: [{ allowWhitespaceOnlyTitle: true }],
-    },
   ],
   invalid: [
     {