From 8ec2054eb22817832eaf8770f1397dd1511293c1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Tue, 21 Apr 2026 12:43:05 +0200
Subject: [PATCH 1/9] =?UTF-8?q?fix:=20template-no-autofocus-attribute=20?=
 =?UTF-8?q?=E2=80=94=20value-aware=20+=20<dialog>=20exception?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes two gaps identified in PR #28 Phase 3 audit (B10 fixture on
`audit/phase3/no-autofocus`):

G3 — value-aware detection. The rule previously flagged `autofocus` purely
on presence, producing false positives for explicit opt-out forms:
  - `autofocus="false"` (GlimmerTextNode chars === "false")
  - `autofocus={{false}}` (BooleanLiteral false)
  - `autofocus={{"false"}}` (StringLiteral "false")
These are now treated as valid. jsx-a11y's `no-autofocus` reads the value
via `getPropValue` and exits early on falsy results, which is the behavior
encoded here. Truthy literals (`="true"`, `="autofocus"`, `={{true}}`,
`={{"true"}}`) and any dynamic expression (`={{this.x}}`) still flag —
the rule cannot prove a dynamic value is safe. Mustache-hash-pair forms
(`{{input autofocus=false}}`, `{{input autofocus="false"}}`) receive the
same value-aware treatment so `autofocus=true` and `autofocus=false` do
not behave inconsistently between syntaxes.

G4 — `<dialog>` exception. The rule now skips reporting when the element
carrying `autofocus` is a `<dialog>` itself OR is nested at any depth
inside a `<dialog>`. Per MDN's `<dialog>` documentation, a dialog is
expected to move focus to its initial control on open, so
`autofocus` on or within a dialog is the recommended pattern rather
than an accessibility defect. This matches
`@angular-eslint/template/no-autofocus`, which exempts the same subtree.

The descendant walk is a full parent-chain traversal via `node.parent`;
the Glimmer AST in this codebase exposes `parent` on every element node,
so no scope narrowing was required.

Behavior unchanged for: bare `<input autofocus>`, truthy string/mustache
values, dynamic mustache values, and any `autofocus` outside a dialog
subtree. 22 rule tests (10 valid, 12 invalid) pass; full suite (9089
tests) green.

Audit fixture `tests/audit/no-autofocus/peer-parity.js` lives on branch
`audit/phase3/no-autofocus` and will need separate updating to reflect
the new parity status for G3 and G4.

Refs: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dialog
Refs: https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/src/rules/no-autofocus.js
Refs: #28 (G3, G4)
---
 lib/rules/template-no-autofocus-attribute.js  | 135 +++++++++++++++---
 .../rules/template-no-autofocus-attribute.js  | 109 ++++++++++++++
 2 files changed, 221 insertions(+), 23 deletions(-)

diff --git a/lib/rules/template-no-autofocus-attribute.js b/lib/rules/template-no-autofocus-attribute.js
index d01c000e18..ef3bc28cf4 100644
--- a/lib/rules/template-no-autofocus-attribute.js
+++ b/lib/rules/template-no-autofocus-attribute.js
@@ -1,3 +1,64 @@
+/**
+ * Returns true when the attribute value is statically known to be falsy
+ * (i.e. the developer has written `autofocus="false"`, `autofocus={{false}}`,
+ * or `autofocus={{"false"}}`). These forms are aligned with jsx-a11y's
+ * `no-autofocus` rule, which reads the attribute value via `getPropValue` and
+ * skips reporting when the value is falsy (e.g. `<div autoFocus={false} />`).
+ *
+ * Valueless attributes (`<input autofocus>`) are TRUTHY per the HTML spec
+ * (boolean attribute present == "on") and must still be flagged.
+ */
+function isExplicitlyFalsy(value) {
+  if (!value) {
+    // No value property at all — treat as bare boolean attribute (truthy).
+    return false;
+  }
+
+  if (value.type === 'GlimmerTextNode') {
+    // `autofocus="false"` → chars === "false". Bare `autofocus` has chars === "".
+    return value.chars === 'false';
+  }
+
+  if (value.type === 'GlimmerMustacheStatement') {
+    const expr = value.path;
+    if (!expr) {
+      return false;
+    }
+    // `autofocus={{false}}` → BooleanLiteral(false).
+    if (expr.type === 'GlimmerBooleanLiteral' && expr.value === false) {
+      return true;
+    }
+    // `autofocus={{"false"}}` → StringLiteral("false").
+    if (expr.type === 'GlimmerStringLiteral' && expr.value === 'false') {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Returns true when the given GlimmerElementNode is a `<dialog>` element
+ * or is nested (at any depth) inside a `<dialog>` element. Per MDN,
+ * autofocus on (or within) a dialog is recommended because a dialog should
+ * focus its initial element when opened.
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dialog
+ */
+function isInsideDialog(node) {
+  if (node.type === 'GlimmerElementNode' && node.tag === 'dialog') {
+    return true;
+  }
+  let ancestor = node.parent;
+  while (ancestor) {
+    if (ancestor.type === 'GlimmerElementNode' && ancestor.tag === 'dialog') {
+      return true;
+    }
+    ancestor = ancestor.parent;
+  }
+  return false;
+}
+
 /** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
@@ -27,25 +88,39 @@ module.exports = {
       GlimmerElementNode(node) {
         const autofocusAttr = node.attributes?.find((attr) => attr.name === 'autofocus');
 
-        if (autofocusAttr) {
-          context.report({
-            node: autofocusAttr,
-            messageId: 'noAutofocus',
-            fix(fixer) {
-              const sourceCode = context.sourceCode;
-              const text = sourceCode.getText();
-              const attrStart = autofocusAttr.range[0];
-              const attrEnd = autofocusAttr.range[1];
-
-              let removeStart = attrStart;
-              while (removeStart > 0 && /\s/.test(text[removeStart - 1])) {
-                removeStart--;
-              }
-
-              return fixer.removeRange([removeStart, attrEnd]);
-            },
-          });
+        if (!autofocusAttr) {
+          return;
         }
+
+        // jsx-a11y parity: `autofocus="false"` / `={{false}}` / `={{"false"}}`
+        // explicitly opt out and should not be flagged.
+        if (isExplicitlyFalsy(autofocusAttr.value)) {
+          return;
+        }
+
+        // MDN dialog exception: autofocus on a <dialog> or inside a <dialog>
+        // is recommended behavior, not an accessibility defect.
+        if (isInsideDialog(node)) {
+          return;
+        }
+
+        context.report({
+          node: autofocusAttr,
+          messageId: 'noAutofocus',
+          fix(fixer) {
+            const sourceCode = context.sourceCode;
+            const text = sourceCode.getText();
+            const attrStart = autofocusAttr.range[0];
+            const attrEnd = autofocusAttr.range[1];
+
+            let removeStart = attrStart;
+            while (removeStart > 0 && /\s/.test(text[removeStart - 1])) {
+              removeStart--;
+            }
+
+            return fixer.removeRange([removeStart, attrEnd]);
+          },
+        });
       },
 
       GlimmerMustacheStatement(node) {
@@ -53,12 +128,26 @@ module.exports = {
           return;
         }
         const autofocusPair = node.hash.pairs.find((pair) => pair.key === 'autofocus');
-        if (autofocusPair) {
-          context.report({
-            node: autofocusPair,
-            messageId: 'noAutofocus',
-          });
+        if (!autofocusPair) {
+          return;
+        }
+
+        // Value-aware check for component/helper invocations such as
+        // `{{input autofocus=false}}` or `{{input autofocus="false"}}`.
+        const pairValue = autofocusPair.value;
+        if (pairValue) {
+          if (pairValue.type === 'GlimmerBooleanLiteral' && pairValue.value === false) {
+            return;
+          }
+          if (pairValue.type === 'GlimmerStringLiteral' && pairValue.value === 'false') {
+            return;
+          }
         }
+
+        context.report({
+          node: autofocusPair,
+          messageId: 'noAutofocus',
+        });
       },
     };
   },
diff --git a/tests/lib/rules/template-no-autofocus-attribute.js b/tests/lib/rules/template-no-autofocus-attribute.js
index ad67f03943..9709506c3a 100644
--- a/tests/lib/rules/template-no-autofocus-attribute.js
+++ b/tests/lib/rules/template-no-autofocus-attribute.js
@@ -22,6 +22,39 @@ ruleTester.run('template-no-autofocus-attribute', rule, {
     `<template>
       <button>Click me</button>
     </template>`,
+    // Value-aware: explicit falsy values opt out (jsx-a11y parity).
+    `<template>
+      <input autofocus="false" />
+    </template>`,
+    `<template>
+      <input autofocus={{false}} />
+    </template>`,
+    `<template>
+      <input autofocus={{"false"}} />
+    </template>`,
+    `<template>
+      {{input autofocus=false}}
+    </template>`,
+    `<template>
+      {{input autofocus="false"}}
+    </template>`,
+    // Dialog exception (MDN): autofocus on <dialog> is recommended.
+    `<template>
+      <dialog autofocus></dialog>
+    </template>`,
+    // Dialog descendants are also exempt (angular-eslint parity).
+    `<template>
+      <dialog>
+        <button autofocus>Close</button>
+      </dialog>
+    </template>`,
+    `<template>
+      <dialog>
+        <div>
+          <input autofocus />
+        </div>
+      </dialog>
+    </template>`,
   ],
 
   invalid: [
@@ -123,5 +156,81 @@ ruleTester.run('template-no-autofocus-attribute', rule, {
         },
       ],
     },
+    // Value-aware: truthy literals and any dynamic value still flag.
+    {
+      code: `<template>
+        <input autofocus="true" />
+      </template>`,
+      output: `<template>
+        <input />
+      </template>`,
+      errors: [
+        {
+          messageId: 'noAutofocus',
+          type: 'GlimmerAttrNode',
+        },
+      ],
+    },
+    {
+      code: `<template>
+        <input autofocus={{true}} />
+      </template>`,
+      output: `<template>
+        <input />
+      </template>`,
+      errors: [
+        {
+          messageId: 'noAutofocus',
+          type: 'GlimmerAttrNode',
+        },
+      ],
+    },
+    {
+      code: `<template>
+        <input autofocus={{"true"}} />
+      </template>`,
+      output: `<template>
+        <input />
+      </template>`,
+      errors: [
+        {
+          messageId: 'noAutofocus',
+          type: 'GlimmerAttrNode',
+        },
+      ],
+    },
+    {
+      code: `<template>
+        <input autofocus={{this.shouldFocus}} />
+      </template>`,
+      output: `<template>
+        <input />
+      </template>`,
+      errors: [
+        {
+          messageId: 'noAutofocus',
+          type: 'GlimmerAttrNode',
+        },
+      ],
+    },
+    // Dialog exception only applies within <dialog>; siblings elsewhere still flag.
+    {
+      code: `<template>
+        <section>
+          <button autofocus>Focus</button>
+        </section>
+      </template>`,
+      output: `<template>
+        <section>
+          <button>Focus</button>
+        </section>
+      </template>`,
+      errors: [
+        {
+          messageId: 'noAutofocus',
+          type: 'GlimmerAttrNode',
+        },
+      ],
+    },
   ],
 });

From 65888627ae67bf1e11c8a680aa07e8e32d904615 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Tue, 21 Apr 2026 16:26:01 +0200
Subject: [PATCH 2/9] docs: document <dialog> and falsy-value exceptions

---
 docs/rules/template-no-autofocus-attribute.md | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/docs/rules/template-no-autofocus-attribute.md b/docs/rules/template-no-autofocus-attribute.md
index b3bc9bd425..b049b29668 100644
--- a/docs/rules/template-no-autofocus-attribute.md
+++ b/docs/rules/template-no-autofocus-attribute.md
@@ -40,6 +40,28 @@ Examples of **correct** code for this rule:
 </template>
 ```
 
+Explicit opt-out via a falsy value is allowed (parity with
+[`jsx-a11y/no-autofocus`](https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/no-autofocus.md)):
+
+```gjs
+<template>
+  <input autofocus="false" />
+  <input autofocus={{false}} />
+</template>
+```
+
+`<dialog>` and its descendants are exempt. A dialog is expected to focus its
+initial element on open, per
+[MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dialog):
+
+```gjs
+<template>
+  <dialog>
+    <button autofocus>Close</button>
+  </dialog>
+</template>
+```
+
 ## When Not To Use It
 
 If you need to autofocus for specific accessibility or UX requirements and have thoroughly tested with assistive technologies, you may disable this rule for those specific cases.

From 1670293a9fec990aa1414be1c3dadacdcc4739fb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Tue, 21 Apr 2026 20:06:14 +0200
Subject: [PATCH 3/9] fix(template-no-autofocus-attribute): align value-aware
 check with HTML boolean semantics
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Per HTML Living Standard on boolean attributes, the presence of `autofocus`
indicates TRUE regardless of value — `autofocus="false"` and
`autofocus="autofocus"` are equally truthy. jsx-a11y's `no-autofocus`
treats the literal string `"false"` as an opt-out (via `getPropValue`),
but that's a peer-plugin convention that diverges from HTML semantics;
vue-a11y and lit-a11y are presence-based, consistent with the spec.

Narrow opt-out to the only case that is spec-consistent:
- `autofocus={{false}}` in angle-bracket syntax — renders no attribute.
- `{{input autofocus=false}}` in mustache hash-pair syntax — no attribute.

Revert peer-parity opt-outs for `autofocus="false"`, `autofocus={{"false"}}`,
and `{{input autofocus="false"}}` — these are now flagged per HTML spec
semantics. Moved from valid → invalid in the test suite.

Dialog exemption unchanged — keeps MDN-backed behavior for autofocus on
and within <dialog>.

Follows the spec-first direction established in #2717 (aria-hidden),
#19, #33.
---
 lib/rules/template-no-autofocus-attribute.js  | 72 ++++++++-----------
 .../rules/template-no-autofocus-attribute.js  | 42 ++++++++---
 2 files changed, 60 insertions(+), 54 deletions(-)

diff --git a/lib/rules/template-no-autofocus-attribute.js b/lib/rules/template-no-autofocus-attribute.js
index ef3bc28cf4..a5c0cdbfb5 100644
--- a/lib/rules/template-no-autofocus-attribute.js
+++ b/lib/rules/template-no-autofocus-attribute.js
@@ -1,40 +1,25 @@
 /**
- * Returns true when the attribute value is statically known to be falsy
- * (i.e. the developer has written `autofocus="false"`, `autofocus={{false}}`,
- * or `autofocus={{"false"}}`). These forms are aligned with jsx-a11y's
- * `no-autofocus` rule, which reads the attribute value via `getPropValue` and
- * skips reporting when the value is falsy (e.g. `<div autoFocus={false} />`).
+ * `autofocus` is a boolean HTML attribute. Per the HTML spec, any presence
+ * (including `autofocus="false"`, `autofocus=""`, `autofocus="autofocus"`)
+ * means the element will auto-focus. Only the genuine absence of the
+ * attribute turns off auto-focus.
  *
- * Valueless attributes (`<input autofocus>`) are TRUTHY per the HTML spec
- * (boolean attribute present == "on") and must still be flagged.
+ * jsx-a11y's `no-autofocus` treats `autofocus={false}` / `autofocus="false"`
+ * as opt-outs — that is a peer-plugin convention that diverges from HTML
+ * boolean-attribute semantics. vue-a11y and lit-a11y are presence-based,
+ * consistent with the spec. We follow the spec.
+ *
+ * The only exception is a mustache boolean-literal `{{false}}` in element
+ * syntax — Glimmer authors writing `autofocus={{false}}` are expressing
+ * intent to omit the attribute conditionally. Treat that narrow literal
+ * case as opt-out (the rendered HTML will have no autofocus attr).
  */
-function isExplicitlyFalsy(value) {
-  if (!value) {
-    // No value property at all — treat as bare boolean attribute (truthy).
+function isMustacheBooleanFalse(value) {
+  if (value?.type !== 'GlimmerMustacheStatement') {
     return false;
   }
-
-  if (value.type === 'GlimmerTextNode') {
-    // `autofocus="false"` → chars === "false". Bare `autofocus` has chars === "".
-    return value.chars === 'false';
-  }
-
-  if (value.type === 'GlimmerMustacheStatement') {
-    const expr = value.path;
-    if (!expr) {
-      return false;
-    }
-    // `autofocus={{false}}` → BooleanLiteral(false).
-    if (expr.type === 'GlimmerBooleanLiteral' && expr.value === false) {
-      return true;
-    }
-    // `autofocus={{"false"}}` → StringLiteral("false").
-    if (expr.type === 'GlimmerStringLiteral' && expr.value === 'false') {
-      return true;
-    }
-  }
-
-  return false;
+  const expr = value.path;
+  return expr?.type === 'GlimmerBooleanLiteral' && expr.value === false;
 }
 
 /**
@@ -92,9 +77,10 @@ module.exports = {
           return;
         }
 
-        // jsx-a11y parity: `autofocus="false"` / `={{false}}` / `={{"false"}}`
-        // explicitly opt out and should not be flagged.
-        if (isExplicitlyFalsy(autofocusAttr.value)) {
+        // Mustache boolean-literal `autofocus={{false}}` renders no attribute
+        // at all — the only statically-known opt-out consistent with HTML
+        // boolean-attribute semantics.
+        if (isMustacheBooleanFalse(autofocusAttr.value)) {
           return;
         }
 
@@ -132,16 +118,14 @@ module.exports = {
           return;
         }
 
-        // Value-aware check for component/helper invocations such as
-        // `{{input autofocus=false}}` or `{{input autofocus="false"}}`.
+        // Mustache hash-pair `{{input autofocus=false}}` — boolean literal
+        // false at the hash-pair level is unambiguous and renders no attr.
+        // Note: `autofocus="false"` in mustache syntax IS still flagged — per
+        // HTML boolean-attribute semantics the string "false" is truthy; it
+        // is only jsx-a11y that carves that form out.
         const pairValue = autofocusPair.value;
-        if (pairValue) {
-          if (pairValue.type === 'GlimmerBooleanLiteral' && pairValue.value === false) {
-            return;
-          }
-          if (pairValue.type === 'GlimmerStringLiteral' && pairValue.value === 'false') {
-            return;
-          }
+        if (pairValue?.type === 'GlimmerBooleanLiteral' && pairValue.value === false) {
+          return;
         }
 
         context.report({
diff --git a/tests/lib/rules/template-no-autofocus-attribute.js b/tests/lib/rules/template-no-autofocus-attribute.js
index 9709506c3a..db021179a4 100644
--- a/tests/lib/rules/template-no-autofocus-attribute.js
+++ b/tests/lib/rules/template-no-autofocus-attribute.js
@@ -22,22 +22,15 @@ ruleTester.run('template-no-autofocus-attribute', rule, {
     `<template>
       <button>Click me</button>
     </template>`,
-    // Value-aware: explicit falsy values opt out (jsx-a11y parity).
-    `<template>
-      <input autofocus="false" />
-    </template>`,
+    // Mustache boolean-literal forms render NO attribute when the literal
+    // is false — these are the statically-known opt-outs that align with
+    // HTML boolean-attribute semantics.
     `<template>
       <input autofocus={{false}} />
     </template>`,
-    `<template>
-      <input autofocus={{"false"}} />
-    </template>`,
     `<template>
       {{input autofocus=false}}
     </template>`,
-    `<template>
-      {{input autofocus="false"}}
-    </template>`,
     // Dialog exception (MDN): autofocus on <dialog> is recommended.
     `<template>
       <dialog autofocus></dialog>
@@ -232,5 +225,34 @@ ruleTester.run('template-no-autofocus-attribute', rule, {
         },
       ],
     },
+
+    // Per HTML boolean-attribute semantics, the string "false" / mustache
+    // string "false" / hash-pair string "false" are all TRUTHY. Only the
+    // mustache boolean-literal {{false}} renders no attribute.
+    {
+      code: `<template>
+        <input autofocus="false" />
+      </template>`,
+      output: `<template>
+        <input />
+      </template>`,
+      errors: [{ messageId: 'noAutofocus', type: 'GlimmerAttrNode' }],
+    },
+    {
+      code: `<template>
+        <input autofocus={{"false"}} />
+      </template>`,
+      output: `<template>
+        <input />
+      </template>`,
+      errors: [{ messageId: 'noAutofocus', type: 'GlimmerAttrNode' }],
+    },
+    {
+      code: `<template>
+        {{input autofocus="false"}}
+      </template>`,
+      output: null,
+      errors: [{ messageId: 'noAutofocus' }],
+    },
   ],
 });

From 6d4fcda2bfd739184b4e1cc0afb9eeedd6607420 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Wed, 22 Apr 2026 10:28:29 +0200
Subject: [PATCH 4/9] docs: cite Glimmer VM source verifying
 autofocus={{false}} omits attribute
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The G3 exemption's load-bearing premise (Glimmer renders no attribute
when given a mustache-literal false) was asserted in the PR body but
unverified in the rule's own documentation. Verified against Glimmer
VM's attribute-normalization path:

  glimmer-vm/packages/@glimmer/runtime/lib/vm/attributes/dynamic.ts

`normalizeValue` returns null for false/undefined/null; then
`SimpleDynamicAttribute.update()` calls element.removeAttribute(name)
when the value is null. So autofocus={{false}} genuinely omits the
attribute from the rendered DOM — not autofocus="false".

Inlined the citation into the rule's JSDoc so future readers don't
have to trace it.
---
 lib/rules/template-no-autofocus-attribute.js | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/lib/rules/template-no-autofocus-attribute.js b/lib/rules/template-no-autofocus-attribute.js
index a5c0cdbfb5..db24435f5f 100644
--- a/lib/rules/template-no-autofocus-attribute.js
+++ b/lib/rules/template-no-autofocus-attribute.js
@@ -13,6 +13,13 @@
  * syntax — Glimmer authors writing `autofocus={{false}}` are expressing
  * intent to omit the attribute conditionally. Treat that narrow literal
  * case as opt-out (the rendered HTML will have no autofocus attr).
+ *
+ * Verified against Glimmer VM's attribute-normalization source:
+ * glimmer-vm/packages/@glimmer/runtime/lib/vm/attributes/dynamic.ts —
+ * `normalizeValue` returns `null` for `false | undefined | null`, and
+ * `SimpleDynamicAttribute.update()` calls `element.removeAttribute(name)`
+ * when the normalized value is null. So `autofocus={{false}}` renders
+ * with the attribute entirely absent from the DOM.
  */
 function isMustacheBooleanFalse(value) {
   if (value?.type !== 'GlimmerMustacheStatement') {

From d0844e1a4e6d769cc86d03705bb370477ba6da36 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Wed, 22 Apr 2026 13:56:36 +0200
Subject: [PATCH 5/9] fix: apply <dialog> exemption to mustache form + update
 comment (Copilot review)

---
 lib/rules/template-no-autofocus-attribute.js      | 15 +++++++++++----
 .../lib/rules/template-no-autofocus-attribute.js  | 14 ++++++++++++++
 2 files changed, 25 insertions(+), 4 deletions(-)

diff --git a/lib/rules/template-no-autofocus-attribute.js b/lib/rules/template-no-autofocus-attribute.js
index db24435f5f..3613222b1b 100644
--- a/lib/rules/template-no-autofocus-attribute.js
+++ b/lib/rules/template-no-autofocus-attribute.js
@@ -9,10 +9,11 @@
  * boolean-attribute semantics. vue-a11y and lit-a11y are presence-based,
  * consistent with the spec. We follow the spec.
  *
- * The only exception is a mustache boolean-literal `{{false}}` in element
- * syntax — Glimmer authors writing `autofocus={{false}}` are expressing
- * intent to omit the attribute conditionally. Treat that narrow literal
- * case as opt-out (the rendered HTML will have no autofocus attr).
+ * The only exception is a boolean-literal `false` — in element syntax
+ * written as `autofocus={{false}}`, and in mustache hash syntax written as
+ * `{{input autofocus=false}}`. Both forms express intent to omit the
+ * attribute conditionally, and the rendered HTML will have no autofocus
+ * attribute. Treat both literal-false cases as opt-out.
  *
  * Verified against Glimmer VM's attribute-normalization source:
  * glimmer-vm/packages/@glimmer/runtime/lib/vm/attributes/dynamic.ts —
@@ -135,6 +136,12 @@ module.exports = {
           return;
         }
 
+        // MDN dialog exception: autofocus on a mustache component/helper
+        // nested inside a <dialog> is recommended behavior, not a defect.
+        if (isInsideDialog(node)) {
+          return;
+        }
+
         context.report({
           node: autofocusPair,
           messageId: 'noAutofocus',
diff --git a/tests/lib/rules/template-no-autofocus-attribute.js b/tests/lib/rules/template-no-autofocus-attribute.js
index db021179a4..8f0eda40e0 100644
--- a/tests/lib/rules/template-no-autofocus-attribute.js
+++ b/tests/lib/rules/template-no-autofocus-attribute.js
@@ -48,6 +48,20 @@ ruleTester.run('template-no-autofocus-attribute', rule, {
         </div>
       </dialog>
     </template>`,
+    // Dialog exception also applies to the mustache form of the `<Input>`
+    // helper (`{{input autofocus=true}}`) — whether direct child or nested.
+    `<template>
+      <dialog>
+        {{input autofocus=true}}
+      </dialog>
+    </template>`,
+    `<template>
+      <dialog>
+        <div>
+          {{input autofocus=true}}
+        </div>
+      </dialog>
+    </template>`,
   ],
 
   invalid: [

From c2a4128947d4759c1400cf6f0aa79ca91f435e31 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Thu, 23 Apr 2026 21:39:52 +0200
Subject: [PATCH 6/9] docs: address Copilot review wording (PR #32)

---
 docs/rules/template-no-autofocus-attribute.md | 9 ++++++---
 lib/rules/template-no-autofocus-attribute.js  | 5 +++--
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/docs/rules/template-no-autofocus-attribute.md b/docs/rules/template-no-autofocus-attribute.md
index b049b29668..f09fc774ea 100644
--- a/docs/rules/template-no-autofocus-attribute.md
+++ b/docs/rules/template-no-autofocus-attribute.md
@@ -40,13 +40,16 @@ Examples of **correct** code for this rule:
 </template>
 ```
 
-Explicit opt-out via a falsy value is allowed (parity with
-[`jsx-a11y/no-autofocus`](https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/no-autofocus.md)):
+Explicit opt-out via a mustache boolean `false` is allowed — this is the
+only form that statically guarantees no rendered `autofocus` attribute
+(Glimmer VM normalizes `{{false}}` to attribute removal). The string
+`autofocus="false"` is still flagged per HTML boolean-attribute semantics
+(any attribute presence, including the string `"false"`, enables autofocus).
 
 ```gjs
 <template>
-  <input autofocus="false" />
   <input autofocus={{false}} />
+  {{!-- element syntax: the mustache-boolean form --}}
 </template>
 ```
 
diff --git a/lib/rules/template-no-autofocus-attribute.js b/lib/rules/template-no-autofocus-attribute.js
index 3613222b1b..3c4271b47b 100644
--- a/lib/rules/template-no-autofocus-attribute.js
+++ b/lib/rules/template-no-autofocus-attribute.js
@@ -31,8 +31,9 @@ function isMustacheBooleanFalse(value) {
 }
 
 /**
- * Returns true when the given GlimmerElementNode is a `<dialog>` element
- * or is nested (at any depth) inside a `<dialog>` element. Per MDN,
+ * Returns true when the given node (a GlimmerElementNode OR a
+ * GlimmerMustacheStatement, e.g. `{{input autofocus=true}}`) is a `<dialog>`
+ * element or is nested (at any depth) inside a `<dialog>` element. Per MDN,
  * autofocus on (or within) a dialog is recommended because a dialog should
  * focus its initial element when opened.
  *

From c97a13138daef54fda44c26c92557600dd3e1b44 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Fri, 24 Apr 2026 13:25:52 +0200
Subject: [PATCH 7/9] fix(#32): address round-2 Copilot review (document
 hash-pair opt-out; reword {{input}} comment)

---
 docs/rules/template-no-autofocus-attribute.md      | 3 +++
 tests/lib/rules/template-no-autofocus-attribute.js | 4 ++--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/docs/rules/template-no-autofocus-attribute.md b/docs/rules/template-no-autofocus-attribute.md
index f09fc774ea..b257beac98 100644
--- a/docs/rules/template-no-autofocus-attribute.md
+++ b/docs/rules/template-no-autofocus-attribute.md
@@ -50,6 +50,9 @@ only form that statically guarantees no rendered `autofocus` attribute
 <template>
   <input autofocus={{false}} />
   {{!-- element syntax: the mustache-boolean form --}}
+
+  {{input autofocus=false}}
+  {{!-- mustache syntax: the hash-pair form --}}
 </template>
 ```
 
diff --git a/tests/lib/rules/template-no-autofocus-attribute.js b/tests/lib/rules/template-no-autofocus-attribute.js
index 8f0eda40e0..67557133c0 100644
--- a/tests/lib/rules/template-no-autofocus-attribute.js
+++ b/tests/lib/rules/template-no-autofocus-attribute.js
@@ -48,8 +48,8 @@ ruleTester.run('template-no-autofocus-attribute', rule, {
         </div>
       </dialog>
     </template>`,
-    // Dialog exception also applies to the mustache form of the `<Input>`
-    // helper (`{{input autofocus=true}}`) — whether direct child or nested.
+    // Dialog exception also applies to the classic mustache form
+    // (`{{input autofocus=true}}`) — whether direct child or nested.
     `<template>
       <dialog>
         {{input autofocus=true}}

From 57f55fce87b2f17ea218df71fadeaf718bdaa219 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Fri, 24 Apr 2026 14:47:38 +0200
Subject: [PATCH 8/9] fix(template-no-autofocus-attribute): narrow mustache
 check to native-input helpers (Copilot review)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Previously the GlimmerMustacheStatement visitor fired on ANY mustache
with an autofocus hash pair — but arbitrary custom components taking
'autofocus' as a prop are opaque. We can't statically tell whether the
prop forwards to a native <input autofocus> or is used for something
else. Narrow to the two built-ins that deterministically render a
native input:
  - {{input …}}
  - {{component "input" …}}

Future: when type-aware linting lands (Glint integration or template-
type-check), we can resolve custom components that forward 'autofocus'
to a native <input> and flag those too. For now we stay conservative
to avoid false positives on unrelated helpers.
---
 lib/rules/template-no-autofocus-attribute.js  | 41 +++++++++++++++++++
 .../rules/template-no-autofocus-attribute.js  |  8 ++++
 2 files changed, 49 insertions(+)

diff --git a/lib/rules/template-no-autofocus-attribute.js b/lib/rules/template-no-autofocus-attribute.js
index 3c4271b47b..b63768b9f1 100644
--- a/lib/rules/template-no-autofocus-attribute.js
+++ b/lib/rules/template-no-autofocus-attribute.js
@@ -39,6 +39,28 @@ function isMustacheBooleanFalse(value) {
  *
  * https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dialog
  */
+// Returns true for `{{input ...}}` and `{{component "input" ...}}` mustache
+// invocations — the only built-ins that deterministically render a native
+// <input> with forwarded attributes.
+function isNativeInputHelper(node) {
+  const path = node.path;
+  if (!path) {
+    return false;
+  }
+  // Direct invocation: `{{input ...}}`.
+  if (path.type === 'GlimmerPathExpression' && path.original === 'input') {
+    return true;
+  }
+  // Contextual component: `{{component "input" ...}}`.
+  if (path.type === 'GlimmerPathExpression' && path.original === 'component') {
+    const firstParam = node.params && node.params[0];
+    if (firstParam && firstParam.type === 'GlimmerStringLiteral' && firstParam.value === 'input') {
+      return true;
+    }
+  }
+  return false;
+}
+
 function isInsideDialog(node) {
   if (node.type === 'GlimmerElementNode' && node.tag === 'dialog') {
     return true;
@@ -127,6 +149,25 @@ module.exports = {
           return;
         }
 
+        // Narrow to helpers that deterministically render a native `autofocus`
+        // attribute. The rule's purpose is the HTML attribute; arbitrary
+        // components taking an `autofocus` prop are opaque — we can't tell
+        // statically whether that prop forwards to HTML or is used for
+        // something else.
+        //   - `{{input ...}}` — Ember's classic input helper renders a native
+        //     <input> with forwarded attributes.
+        //   - `{{component "input" ...}}` — contextual component resolution
+        //     points at the same helper.
+        //
+        // FUTURE: when type-aware linting lands (e.g., Glint integration or
+        // a template-type-check step), we can resolve custom components that
+        // forward `autofocus` to a native <input> and flag those too. For now
+        // we stay conservative to avoid false positives on unrelated helpers
+        // that happen to take an `autofocus` prop.
+        if (!isNativeInputHelper(node)) {
+          return;
+        }
+
         // Mustache hash-pair `{{input autofocus=false}}` — boolean literal
         // false at the hash-pair level is unambiguous and renders no attr.
         // Note: `autofocus="false"` in mustache syntax IS still flagged — per
diff --git a/tests/lib/rules/template-no-autofocus-attribute.js b/tests/lib/rules/template-no-autofocus-attribute.js
index 67557133c0..6c81282117 100644
--- a/tests/lib/rules/template-no-autofocus-attribute.js
+++ b/tests/lib/rules/template-no-autofocus-attribute.js
@@ -62,6 +62,14 @@ ruleTester.run('template-no-autofocus-attribute', rule, {
         </div>
       </dialog>
     </template>`,
+
+    // Custom helpers / components taking an `autofocus` prop are opaque —
+    // we can't know whether the prop forwards to a native <input autofocus>
+    // or is used for something else. Narrow to {{input}} / {{component
+    // "input"}} which deterministically render native inputs.
+    `<template>{{my-wrapper autofocus=true}}</template>`,
+    `<template>{{some-component autofocus=true name="foo"}}</template>`,
+    `<template>{{component "some-other-helper" autofocus=true}}</template>`,
   ],
 
   invalid: [

From 7ca1edc7371c89f7f40c26be6b02c2459d186d4d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Fri, 24 Apr 2026 15:31:15 +0200
Subject: [PATCH 9/9] lint: normalize string quotes to single per quotes rule

---
 tests/lib/rules/template-no-autofocus-attribute.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/lib/rules/template-no-autofocus-attribute.js b/tests/lib/rules/template-no-autofocus-attribute.js
index 6c81282117..08571b62a0 100644
--- a/tests/lib/rules/template-no-autofocus-attribute.js
+++ b/tests/lib/rules/template-no-autofocus-attribute.js
@@ -67,9 +67,9 @@ ruleTester.run('template-no-autofocus-attribute', rule, {
     // we can't know whether the prop forwards to a native <input autofocus>
     // or is used for something else. Narrow to {{input}} / {{component
     // "input"}} which deterministically render native inputs.
-    `<template>{{my-wrapper autofocus=true}}</template>`,
-    `<template>{{some-component autofocus=true name="foo"}}</template>`,
-    `<template>{{component "some-other-helper" autofocus=true}}</template>`,
+    '<template>{{my-wrapper autofocus=true}}</template>',
+    '<template>{{some-component autofocus=true name="foo"}}</template>',
+    '<template>{{component "some-other-helper" autofocus=true}}</template>',
   ],
 
   invalid: [