diff --git a/README.md b/README.md
index 79c8cec965..db057b374a 100644
--- a/README.md
+++ b/README.md
@@ -262,6 +262,7 @@ To disable a rule for an entire `.gjs`/`.gts` file, use a regular ESLint file-le
 | [template-no-abstract-roles](docs/rules/template-no-abstract-roles.md)                                           | disallow abstract ARIA roles                                                     | 📋 |    |    |
 | [template-no-accesskey-attribute](docs/rules/template-no-accesskey-attribute.md)                                 | disallow accesskey attribute                                                     | 📋 | 🔧 |    |
 | [template-no-aria-hidden-body](docs/rules/template-no-aria-hidden-body.md)                                       | disallow aria-hidden on body element                                             | 📋 | 🔧 |    |
+| [template-no-aria-hidden-on-focusable](docs/rules/template-no-aria-hidden-on-focusable.md)                       | disallow aria-hidden="true" on focusable elements                                |    |    |    |
 | [template-no-aria-unsupported-elements](docs/rules/template-no-aria-unsupported-elements.md)                     | disallow ARIA roles, states, and properties on elements that do not support them | 📋 |    |    |
 | [template-no-autofocus-attribute](docs/rules/template-no-autofocus-attribute.md)                                 | disallow autofocus attribute                                                     | 📋 | 🔧 |    |
 | [template-no-duplicate-landmark-elements](docs/rules/template-no-duplicate-landmark-elements.md)                 | disallow duplicate landmark elements without unique labels                       | 📋 |    |    |
@@ -584,6 +585,8 @@ If you have any suggestions, ideas, or problems, feel free to [create an issue](
 
 ### Creating a New Rule
 
+If your rule inspects template attribute values (e.g. mustache forms like `attr={{X}}` or `attr="{{X}}"`), read [docs/glimmer-attribute-behavior.md](docs/glimmer-attribute-behavior.md) first — Glimmer's actual rendering behavior is non-obvious for several common forms, and the doc has the empirically-verified table.
+
 - [Create an issue](https://github.com/ember-cli/eslint-plugin-ember/issues/new) with a description of the proposed rule
 - Create files for the [new rule](https://eslint.org/docs/developer-guide/working-with-rules):
   - `lib/rules/new-rule.js` (implementation, see [no-proxies](lib/rules/no-proxies.js) for an example)
diff --git a/docs/glimmer-attribute-behavior.md b/docs/glimmer-attribute-behavior.md
new file mode 100644
index 0000000000..f0b47761d0
--- /dev/null
+++ b/docs/glimmer-attribute-behavior.md
@@ -0,0 +1,330 @@
+# Glimmer attribute rendering behavior
+
+Reference for rule authors. Most template lint rules need to answer: "given an attribute written as `attr={{X}}` or `attr="{{X}}"` or `attr="value"`, what does it actually do at runtime?" The answer is non-obvious — Glimmer's bare-mustache and concat-mustache forms coerce values differently per attribute kind, HTML serialization can disagree with the live IDL property, and several intuitive mental models are wrong.
+
+This doc captures empirically-verified rendering behavior. Every cell in every table below comes from rendering the template under [§ To reproduce the reference table](#to-reproduce-the-reference-table) in an Ember dev app and inspecting `outerHTML` plus the relevant IDL property in devtools. **No extrapolation.** If a form isn't in a table, it hasn't been verified — extend the reproduction template and add the row.
+
+> Read this before writing or modifying any rule that inspects attribute values via `GlimmerBooleanLiteral`, `GlimmerStringLiteral`, `GlimmerConcatStatement`, or `GlimmerTextNode`.
+
+## Reference table
+
+Five per-attribute tables, one per representative attribute kind. IDs (`m1`–`m19`, `h1`–`h15`, `d1`–`d10`, `t1`–`t7`, `i1`–`i5`) cross-reference the reproduction template below.
+
+### `<video>` + `muted` — boolean HTML attribute, non-reflecting
+
+`muted` is an HTML boolean attribute on `<video>`. The IDL `videoEl.muted` is the **live** muted state (independent of the content attribute); `videoEl.defaultMuted` is what reflects. At media-load time the user agent sets `muted` from `defaultMuted`. The "IDL muted" column below is read **before media load**, so for cases where only the HTML attribute is set, IDL muted reads false at that snapshot but becomes true once the media loads. The "At play time" column derives the value the rule cares about: is the audio actually muted when autoplay starts?
+
+| ID  | Source                                     | outerHTML                       | IDL `muted` (preload) | hasAttr | At play time                                                  |
+| --- | ------------------------------------------ | ------------------------------- | --------------------- | ------- | ------------------------------------------------------------- |
+| m1  | `<video muted></video>`                    | `<video muted=""></video>`      | `false`               | `true`  | **muted ON** (defaultMuted via attr)                          |
+| m2  | `<video muted=""></video>`                 | `<video muted=""></video>`      | `false`               | `true`  | **muted ON**                                                  |
+| m3  | `<video muted="true"></video>`             | `<video muted="true"></video>`  | `false`               | `true`  | **muted ON**                                                  |
+| m4  | `<video muted="false"></video>`            | `<video muted="false"></video>` | `false`               | `true`  | **muted ON** (HTML boolean-attr presence)                     |
+| m5  | `<video muted={{true}}></video>`           | `<video></video>`               | `true`                | `false` | **muted ON** (IDL set directly)                               |
+| m6  | `<video muted={{false}}></video>`          | `<video></video>`               | `false`               | `false` | **muted OFF**                                                 |
+| m7  | `<video muted={{"true"}}></video>`         | `<video muted="true"></video>`  | `false`               | `true`  | **muted ON**                                                  |
+| m8  | `<video muted={{"false"}}></video>`        | `<video muted="false"></video>` | `false`               | `true`  | **muted ON** (HTML boolean-attr presence)                     |
+| m9  | `<video muted={{null}}></video>`           | `<video></video>`               | `false`               | `false` | **muted OFF**                                                 |
+| m10 | `<video muted={{undefined}}></video>`      | `<video></video>`               | `false`               | `false` | **muted OFF**                                                 |
+| m11 | `<video muted={{""}}></video>`             | `<video muted=""></video>`      | `false`               | `true`  | **muted ON**                                                  |
+| m12 | `<video muted={{0}}></video>`              | `<video></video>`               | `false`               | `false` | **muted OFF**                                                 |
+| m13 | `<video muted="{{true}}"></video>`         | `<video></video>`               | `true`                | `false` | **muted ON** (concat sets IDL true)                           |
+| m14 | `<video muted="{{false}}"></video>`        | `<video></video>`               | `true`                | `false` | **muted ON** (concat sets IDL true regardless of inner value) |
+| m15 | `<video muted="{{'true'}}"></video>`       | `<video></video>`               | `true`                | `false` | **muted ON**                                                  |
+| m16 | `<video muted="{{'false'}}"></video>`      | `<video></video>`               | `true`                | `false` | **muted ON**                                                  |
+| m17 | `<video muted="x{{true}}"></video>`        | `<video></video>`               | `true`                | `false` | **muted ON**                                                  |
+| m18 | `<video muted="x{{false}}"></video>`       | `<video></video>`               | `true`                | `false` | **muted ON**                                                  |
+| m19 | `<video muted="{{false}}-suffix"></video>` | `<video></video>`               | `true`                | `false` | **muted ON**                                                  |
+
+**Lint truth for `muted`:** OFF iff the source is bare `{{false}}` / `{{null}}` / `{{undefined}}` / `{{0}}`. Every other form is ON at play time — including the surprising ones (any concat regardless of literal value; bare string `"false"`).
+
+### `<input>` + `disabled` — boolean HTML attribute, reflecting
+
+Same boolean-coercion behavior as `muted` for the bare-mustache form, but `disabled` reflects: when the IDL `disabled` is set, the HTML attribute appears as `disabled=""`.
+
+| ID  | Source                             | outerHTML                  | IDL `disabled` | hasAttr | At runtime                             |
+| --- | ---------------------------------- | -------------------------- | -------------- | ------- | -------------------------------------- |
+| d1  | `<input disabled />`               | `<input disabled="">`      | `true`         | `true`  | **disabled ON**                        |
+| d2  | `<input disabled={{true}} />`      | `<input disabled="">`      | `true`         | `true`  | **disabled ON**                        |
+| d3  | `<input disabled={{false}} />`     | `<input>`                  | `false`        | `false` | **disabled OFF**                       |
+| d4  | `<input disabled={{"false"}} />`   | `<input disabled="false">` | `true`         | `true`  | **disabled ON**                        |
+| d5  | `<input disabled={{"true"}} />`    | `<input disabled="true">`  | `true`         | `true`  | **disabled ON**                        |
+| d6  | `<input disabled={{null}} />`      | `<input>`                  | `false`        | `false` | **disabled OFF**                       |
+| d7  | `<input disabled="{{false}}" />`   | `<input disabled="">`      | `true`         | `true`  | **disabled ON** (concat sets IDL true) |
+| d8  | `<input disabled="{{true}}" />`    | `<input disabled="">`      | `true`         | `true`  | **disabled ON**                        |
+| d9  | `<input disabled="{{'false'}}" />` | `<input disabled="">`      | `true`         | `true`  | **disabled ON**                        |
+| d10 | `<input disabled="x{{true}}" />`   | `<input disabled="">`      | `true`         | `true`  | **disabled ON**                        |
+
+**Lint truth for `disabled`:** identical falsy-set as `muted` — bare `{{false}}` / `{{null}}` (and by inference `{{undefined}}` / `{{0}}`, not yet tested for this attribute). Every other form is ON. The HTML serialization differs from `muted` (because `disabled` reflects), but the boolean lint truth is the same.
+
+### `<div>` + `aria-hidden` — ARIA string attribute
+
+ARIA attributes are string-valued, but Glimmer's bare-mustache form applies the same falsy-coercion as for boolean HTML attributes (omit on `false`/`null`/`undefined`). Bare-string and concat forms render the value literally — concat does **not** coerce to a boolean here. The "At runtime (per ARIA spec)" column derives whether the element is hidden from assistive tech: `aria-hidden="true"` is hidden; `aria-hidden="false"` is visible; `aria-hidden=""` (and the implied default) is contested.
+
+| ID  | Source                                  | outerHTML                         | IDL `ariaHidden` | hasAttr | At runtime (ARIA)                              |
+| --- | --------------------------------------- | --------------------------------- | ---------------- | ------- | ---------------------------------------------- |
+| h1  | `<div aria-hidden></div>`               | `<div aria-hidden=""></div>`      | `""`             | `true`  | **contested** (empty value)                    |
+| h2  | `<div aria-hidden=""></div>`            | `<div aria-hidden=""></div>`      | `""`             | `true`  | **contested**                                  |
+| h3  | `<div aria-hidden="true"></div>`        | `<div aria-hidden="true"></div>`  | `"true"`         | `true`  | **hidden**                                     |
+| h4  | `<div aria-hidden="false"></div>`       | `<div aria-hidden="false"></div>` | `"false"`        | `true`  | **visible**                                    |
+| h5  | `<div aria-hidden={{true}}></div>`      | `<div aria-hidden=""></div>`      | `""`             | `true`  | **contested** (rendered empty, _not_ `"true"`) |
+| h6  | `<div aria-hidden={{false}}></div>`     | `<div></div>`                     | `null`           | `false` | **visible** (default)                          |
+| h7  | `<div aria-hidden={{"true"}}></div>`    | `<div aria-hidden="true"></div>`  | `"true"`         | `true`  | **hidden**                                     |
+| h8  | `<div aria-hidden={{"false"}}></div>`   | `<div aria-hidden="false"></div>` | `"false"`        | `true`  | **visible**                                    |
+| h9  | `<div aria-hidden={{null}}></div>`      | `<div></div>`                     | `null`           | `false` | **visible**                                    |
+| h10 | `<div aria-hidden={{undefined}}></div>` | `<div></div>`                     | `null`           | `false` | **visible**                                    |
+| h11 | `<div aria-hidden={{""}}></div>`        | `<div aria-hidden=""></div>`      | `""`             | `true`  | **contested**                                  |
+| h12 | `<div aria-hidden="{{true}}"></div>`    | `<div aria-hidden="true"></div>`  | `"true"`         | `true`  | **hidden**                                     |
+| h13 | `<div aria-hidden="{{false}}"></div>`   | `<div aria-hidden="false"></div>` | `"false"`        | `true`  | **visible**                                    |
+| h14 | `<div aria-hidden="{{'true'}}"></div>`  | `<div aria-hidden="true"></div>`  | `"true"`         | `true`  | **hidden**                                     |
+| h15 | `<div aria-hidden="{{'false'}}"></div>` | `<div aria-hidden="false"></div>` | `"false"`        | `true`  | **visible**                                    |
+
+**Lint truth for `aria-hidden`:** the rule depends on the value, not just presence. Notable differences from boolean attrs: bare `{{true}}` renders as `aria-hidden=""` (contested, not `"true"`); concat `="{{false}}"` renders as `aria-hidden="false"` (visible — _not_ IDL-coerced like boolean attrs).
+
+### `<div>` + `tabindex` — numeric attribute
+
+Falsy-coercion (`false`/`null`) omits, like boolean attrs. Numeric and string-numeric values render the literal. IDL `tabIndex` returns `-1` when no attribute is set (the default for non-focusable elements), so `hasAttr` is the cleaner signal for "tabindex is set" than checking `tabIndex`.
+
+| ID  | Source                           | outerHTML                   | IDL `tabIndex` | hasAttr | Effective   |
+| --- | -------------------------------- | --------------------------- | -------------- | ------- | ----------- |
+| t1  | `<div tabindex={{0}}></div>`     | `<div tabindex="0"></div>`  | `0`            | `true`  | tabindex 0  |
+| t2  | `<div tabindex={{-1}}></div>`    | `<div tabindex="-1"></div>` | `-1`           | `true`  | tabindex -1 |
+| t3  | `<div tabindex={{1}}></div>`     | `<div tabindex="1"></div>`  | `1`            | `true`  | tabindex 1  |
+| t4  | `<div tabindex="{{0}}"></div>`   | `<div tabindex="0"></div>`  | `0`            | `true`  | tabindex 0  |
+| t5  | `<div tabindex={{"0"}}></div>`   | `<div tabindex="0"></div>`  | `0`            | `true`  | tabindex 0  |
+| t6  | `<div tabindex={{false}}></div>` | `<div></div>`               | `-1` (default) | `false` | not set     |
+| t7  | `<div tabindex={{null}}></div>`  | `<div></div>`               | `-1` (default) | `false` | not set     |
+
+**Lint truth for `tabindex`:** rules that care about the value should extract the literal from the AST (the value is preserved as-written across all bare and concat literal forms). Rules that care about presence should check that the source is not bare `{{false}}` / `{{null}}` (and by inference `{{undefined}}`, not tested).
+
+### `<input>` + `autocomplete` — string attribute (not boolean-coerced)
+
+A regular string attribute. Glimmer's bare-mustache **does not** apply falsy-coercion here — `autocomplete={{false}}` renders as `autocomplete="false"` (kept). This is the key difference from boolean HTML attrs and from `aria-*`. The IDL `el.autocomplete` canonicalizes the attribute value (returns `""` for invalid tokens), so it differs from `getAttribute('autocomplete')` for non-spec values.
+
+| ID  | Source                               | outerHTML                      | IDL `autocomplete`   | hasAttr | attrValue |
+| --- | ------------------------------------ | ------------------------------ | -------------------- | ------- | --------- |
+| i1  | `<input autocomplete="off" />`       | `<input autocomplete="off">`   | `"off"`              | `true`  | `"off"`   |
+| i2  | `<input autocomplete={{"off"}} />`   | `<input autocomplete="off">`   | `"off"`              | `true`  | `"off"`   |
+| i3  | `<input autocomplete="{{'off'}}" />` | `<input autocomplete="off">`   | `"off"`              | `true`  | `"off"`   |
+| i4  | `<input autocomplete={{false}} />`   | `<input autocomplete="false">` | `""` (canonicalized) | `true`  | `"false"` |
+| i5  | `<input autocomplete="{{false}}" />` | `<input autocomplete="false">` | `""` (canonicalized) | `true`  | `"false"` |
+
+**Lint truth for `autocomplete`:** rules should check `getAttribute('autocomplete')` (or its AST equivalent) against the spec's valid token list, not the IDL property. The bare-mustache `{{false}}` form will give a literal `"false"` value — almost certainly an authoring bug worth flagging.
+
+### Cross-attribute observations
+
+- **Glimmer's bare-mustache "boolean coercion" list.** For `muted` (HTML boolean), `disabled` (HTML boolean), `aria-hidden` (ARIA string), and `tabindex` (numeric), bare `{{false}}` / `{{null}}` / `{{undefined}}` (and `{{0}}` for `muted`) cause the attribute to be **omitted**. For `autocomplete` (plain string), bare `{{false}}` renders as `autocomplete="false"`. So Glimmer applies boolean-coercion to a known set — at minimum HTML boolean attrs, ARIA attrs, and numeric attrs. Plain string attrs do not get coerced.
+- **Bare-mustache string literals never coerce.** `attr={{"false"}}`, `attr={{"true"}}`, `attr={{""}}` always render as `attr="<the-string>"` for every attribute kind tested. The literal `"false"` is JS-truthy and gets passed through.
+- **Bare-mustache numeric `0` is in the falsy set for `muted`.** Verified for `muted` (`{{0}}` → omitted). Not yet tested for `disabled` / `aria-hidden` / `autocomplete`.
+- **Concat-mustache forks by attribute kind.** For HTML boolean attrs (`muted`, `disabled`), any concat — including `"{{false}}"`, `"{{'false'}}"`, `"x{{false}}"` — sets the IDL property to `true`, regardless of the literal value inside. For ARIA / string attrs (`aria-hidden`, `autocomplete`), concat renders the stringified value as the attribute value (no boolean coercion); `aria-hidden="{{false}}"` becomes `aria-hidden="false"` (visible).
+- **Concat is never falsy.** Across all attribute kinds tested, no concat form produces an absent attribute. Rules treating `attr="{{false}}"` as "off" are wrong for boolean attrs (it's IDL-true) and wrong for string attrs (the rendered value is `"false"`, attribute present).
+
+## Reading attribute values in rules
+
+Rule authors who classify attribute values must consume the reference table above through one of these AST shapes — each maps to a known rendering verdict:
+
+| AST shape                                                                                                                                                                      | Source examples                                               | Verdict                                                                                                                                                                                                                                                              |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `attr.value === null` (no value)                                                                                                                                               | `<input disabled />`                                          | Attribute is **present** with empty value (rendered as `attr=""`) — see d1, h1                                                                                                                                                                                       |
+| `attr.value.type === 'GlimmerTextNode'`                                                                                                                                        | `attr="literal text"`                                         | Attribute is **present** with the literal `chars` string — see m1–m4, h2–h4, d1, t-static, i1                                                                                                                                                                        |
+| `attr.value.type === 'GlimmerMustacheStatement'` with `path.type === 'GlimmerBooleanLiteral'` and `path.value === true`                                                        | `attr={{true}}`                                               | **Reflecting boolean attrs**: present (e.g., `disabled=""`). **Non-reflecting boolean attrs** (`muted`, `autoplay`, etc.): IDL property set true, HTML attribute omitted. **ARIA string attrs**: present as `attr=""`. **Numeric attrs**: untested. — see m5, d2, h5 |
+| `attr.value.type === 'GlimmerMustacheStatement'` with `path.type === 'GlimmerBooleanLiteral'` and `path.value === false` (or `GlimmerNullLiteral` / `GlimmerUndefinedLiteral`) | `attr={{false}}` / `{{null}}` / `{{undefined}}`               | Attribute is **omitted** at runtime — see m6, m9, m10, d3, d6, h6, h9, h10, t6, t7. **Exception:** plain string attrs (e.g., `autocomplete`) do _not_ falsy-coerce; bare `{{false}}` renders as `attr="false"` (i4).                                                 |
+| `attr.value.type === 'GlimmerMustacheStatement'` with `path.type === 'GlimmerStringLiteral'`                                                                                   | `attr={{"value"}}`                                            | Attribute is **present** with the literal `path.value` string — see m7, m8, h7, h8, d4, d5, i2                                                                                                                                                                       |
+| `attr.value.type === 'GlimmerMustacheStatement'` with `path.type === 'GlimmerNumberLiteral'` (verified for `tabindex` only)                                                    | `attr={{0}}`                                                  | **Numeric attrs**: present with stringified number (t1, t2, t3). **`muted={{0}}` is in the falsy-omit set** (m12); not yet tested for other kinds.                                                                                                                   |
+| `attr.value.type === 'GlimmerMustacheStatement'` with dynamic path                                                                                                             | `attr={{this.x}}`                                             | **Unknown** at lint time.                                                                                                                                                                                                                                            |
+| `attr.value.type === 'GlimmerConcatStatement'` with all-literal parts                                                                                                          | `attr="{{X}}"` (single literal-mustache) / `attr="text{{X}}"` | **Boolean HTML attrs** (`muted`, `disabled`, etc.): IDL true regardless of inner literal — m13–m19, d7–d10. **ARIA / string attrs** (`aria-hidden`, `autocomplete`): renders the stringified value literally — h12–h15, i3, i5.                                      |
+| `attr.value.type === 'GlimmerConcatStatement'` with any dynamic part                                                                                                           | `attr="{{this.x}}"` / `attr="x{{this.y}}"`                    | **Concat is never falsy** — present at runtime, but the value is generally **unknown** at lint time.                                                                                                                                                                 |
+
+### Common mistakes to avoid
+
+1. **Don't use `findAttr(node, 'foo')` (AST-presence) as a proxy for "attribute set at runtime."** It's wrong for bare `{{false}}` / `{{null}}` / `{{undefined}}` on boolean-coerced attrs (m6/m9/m10/d3/d6/h6/h9/h10/t6/t7) — those forms still create an `AttrNode` in the AST but are omitted at runtime.
+2. **Don't lump `BooleanLiteral(false)` with `StringLiteral("false")`.** Bare `{{"false"}}` is a JS-truthy string; it renders the literal `"false"` value (i4, h8, d4, m8). Treating them together as "off" is the most common audit footgun in this codebase.
+3. **Don't treat single-mustache concat as the inner literal.** `attr="{{X}}"` is **never** falsy. For boolean HTML attrs the IDL property is set true regardless of `X`'s literal value (m14 verified: `<video muted="{{false}}">` → `videoEl.muted === true`). For ARIA/string attrs the rendered HTML is the stringified value (h13: `aria-hidden="{{false}}"` → `aria-hidden="false"`, visible per ARIA spec).
+4. **Don't apply boolean-coercion to plain string attrs.** `autocomplete`, `name`, `id`, `for`, `href`, `role`, `type`, `method`, `lang`, `title`, `alt` etc. do **not** falsy-coerce. Bare `{{false}}` on these renders the literal `"false"`. Plain-string attrs are documented under `i1`–`i5`; the falsy-coercion list (cross-attribute observations) covers HTML boolean attrs, ARIA attrs, and numeric attrs only.
+5. **`role` is plain string, not ARIA-coerced.** Despite living in the ARIA family conceptually, `role` is a plain string DOM attribute — bare `role={{false}}` renders `role="false"` (analogous to i4), not omitted.
+6. **`{{true}}` for `aria-hidden` (h5) renders `aria-hidden=""` — contested per ARIA spec, _not_ `aria-hidden="true"`.** Rules deciding "is this hidden?" should be explicit about which interpretation they take. Don't conflate h5 with h7 (`{{"true"}}` → renders the string `"true"`, hidden).
+
+### Recommended pattern
+
+The shared utility [`lib/utils/glimmer-attr-presence.js`](../lib/utils/glimmer-attr-presence.js) encodes the verdict table once. Rule authors should consume it rather than re-implementing the AST walk:
+
+```js
+const { classifyAttribute } = require('../utils/glimmer-attr-presence');
+
+const attr = node.attributes?.find((a) => a.name === 'aria-hidden');
+const { presence, value } = classifyAttribute(attr);
+// presence: 'absent' | 'present' | 'unknown'
+// value:    string | null
+//
+// kind is inferred from attr.name (boolean / aria / numeric / plain-string).
+// Override with options.kind when needed: classifyAttribute(attr, { kind: 'aria' }).
+
+if (presence === 'present' && value === 'true') {
+  // hidden — covers h3, h7, h12, h14 in one branch.
+}
+```
+
+The utility maps every row in the reference table above to a single `(presence, value)` pair, including the surprising cases (`{{"false"}}` is JS-truthy, `aria-hidden={{true}}` renders empty per h5, concat is never falsy, etc.). Cite the doc row IDs from code comments where you call it so reviewers can confirm the lint truth without re-reading the AST.
+
+## To reproduce the reference table
+
+Every cell above was populated by rendering the template below in an Ember dev app and running the bundled JS console snippet to print each test case's `outerHTML` and IDL state. To re-verify (or extend with new attributes):
+
+1. Paste sections A–E into a template in your Ember dev app.
+2. Render in the browser, open devtools.
+3. Paste the JS snippet (after the template) into the console.
+4. Compare the printed output against the tables above.
+5. If anything diverges, update the changed cell, cite the new `ember-source` version in the commit, and note the change.
+
+```hbs
+{{! A. <video> + muted (boolean HTML, non-reflecting) }}
+<video id='m1' muted></video>
+<video id='m2' muted=''></video>
+<video id='m3' muted='true'></video>
+<video id='m4' muted='false'></video>
+<video id='m5' muted={{true}}></video>
+<video id='m6' muted={{false}}></video>
+<video id='m7' muted={{'true'}}></video>
+<video id='m8' muted={{'false'}}></video>
+<video id='m9' muted={{null}}></video>
+<video id='m10' muted={{undefined}}></video>
+<video id='m11' muted={{''}}></video>
+<video id='m12' muted={{0}}></video>
+<video id='m13' muted='{{true}}'></video>
+<video id='m14' muted='{{false}}'></video>
+<video id='m15' muted='{{"true"}}'></video>
+<video id='m16' muted='{{"false"}}'></video>
+<video id='m17' muted='x{{true}}'></video>
+<video id='m18' muted='x{{false}}'></video>
+<video id='m19' muted='{{false}}-suffix'></video>
+
+{{! B. <div> + aria-hidden (ARIA string) }}
+<div id='h1' aria-hidden></div>
+<div id='h2' aria-hidden=''></div>
+<div id='h3' aria-hidden='true'></div>
+<div id='h4' aria-hidden='false'></div>
+<div id='h5' aria-hidden={{true}}></div>
+<div id='h6' aria-hidden={{false}}></div>
+<div id='h7' aria-hidden={{'true'}}></div>
+<div id='h8' aria-hidden={{'false'}}></div>
+<div id='h9' aria-hidden={{null}}></div>
+<div id='h10' aria-hidden={{undefined}}></div>
+<div id='h11' aria-hidden={{''}}></div>
+<div id='h12' aria-hidden='{{true}}'></div>
+<div id='h13' aria-hidden='{{false}}'></div>
+<div id='h14' aria-hidden='{{"true"}}'></div>
+<div id='h15' aria-hidden='{{"false"}}'></div>
+
+{{! C. <input> + disabled (boolean HTML, reflecting) }}
+<input id='d1' disabled />
+<input id='d2' disabled={{true}} />
+<input id='d3' disabled={{false}} />
+<input id='d4' disabled={{'false'}} />
+<input id='d5' disabled={{'true'}} />
+<input id='d6' disabled={{null}} />
+<input id='d7' disabled='{{false}}' />
+<input id='d8' disabled='{{true}}' />
+<input id='d9' disabled='{{"false"}}' />
+<input id='d10' disabled='x{{true}}' />
+
+{{! D. <div> + tabindex (numeric) }}
+<div id='t1' tabindex={{0}}></div>
+<div id='t2' tabindex={{-1}}></div>
+<div id='t3' tabindex={{1}}></div>
+<div id='t4' tabindex='{{0}}'></div>
+<div id='t5' tabindex={{'0'}}></div>
+<div id='t6' tabindex={{false}}></div>
+<div id='t7' tabindex={{null}}></div>
+
+{{! E. <input> + autocomplete (string) }}
+<input id='i1' autocomplete='off' />
+<input id='i2' autocomplete={{'off'}} />
+<input id='i3' autocomplete='{{"off"}}' />
+<input id='i4' autocomplete={{false}} />
+<input id='i5' autocomplete='{{false}}' />
+```
+
+After rendering, paste this into the devtools console:
+
+```js
+(() => {
+  const groups = {
+    'A. video.muted': {
+      prefix: 'm',
+      count: 19,
+      idl: (el) => ({
+        muted: el.muted,
+        hasAttr: el.hasAttribute('muted'),
+        attrValue: el.getAttribute('muted'),
+      }),
+    },
+    'B. div.ariaHidden': {
+      prefix: 'h',
+      count: 15,
+      idl: (el) => ({
+        ariaHidden: el.ariaHidden,
+        hasAttr: el.hasAttribute('aria-hidden'),
+        attrValue: el.getAttribute('aria-hidden'),
+      }),
+    },
+    'C. input.disabled': {
+      prefix: 'd',
+      count: 10,
+      idl: (el) => ({
+        disabled: el.disabled,
+        hasAttr: el.hasAttribute('disabled'),
+        attrValue: el.getAttribute('disabled'),
+      }),
+    },
+    'D. div.tabIndex': {
+      prefix: 't',
+      count: 7,
+      idl: (el) => ({
+        tabIndex: el.tabIndex,
+        hasAttr: el.hasAttribute('tabindex'),
+        attrValue: el.getAttribute('tabindex'),
+      }),
+    },
+    'E. input.autocomplete': {
+      prefix: 'i',
+      count: 5,
+      idl: (el) => ({
+        autocomplete: el.autocomplete,
+        hasAttr: el.hasAttribute('autocomplete'),
+        attrValue: el.getAttribute('autocomplete'),
+      }),
+    },
+  };
+  const lines = [];
+  for (const [label, { prefix, count, idl }] of Object.entries(groups)) {
+    lines.push(`\n==== ${label} ====`);
+    for (let i = 1; i <= count; i++) {
+      const id = prefix + i;
+      const el = document.querySelector(`#${id}`);
+      if (!el) {
+        lines.push(`${id}: (NOT FOUND)`);
+        continue;
+      }
+      const idlPairs = Object.entries(idl(el))
+        .map(([k, v]) => `${k}=${JSON.stringify(v)}`)
+        .join(' ');
+      lines.push(`${id.padEnd(4)} ${el.outerHTML.padEnd(75)} | ${idlPairs}`);
+    }
+  }
+  console.log(lines.join('\n'));
+})();
+```
+
+## Verification metadata
+
+- **Date verified:** 2026-04-28
+- **Ember version:** `ember-source` 6.12 (Glimmer VM is merged into the main Ember repo, no separate version)
+- **Verified by:** [@johanrd](https://github.com/johanrd) (rendering app, devtools inspection)
+- **Methodology:** rendered template fragments via the reproduction template above, captured `outerHTML` and IDL property state via the bundled JS console snippet
+
+## Related
+
+- HTML spec on boolean attributes and reflection: <https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#boolean-attributes>
+- HTML spec on `muted` IDL vs. `defaultMuted`: <https://html.spec.whatwg.org/multipage/media.html#dom-media-muted>
+- ARIA `aria-hidden` semantics: <https://www.w3.org/TR/wai-aria-1.2/#aria-hidden>
+- ARIA reflection via `ARIAMixin`: <https://www.w3.org/TR/wai-aria-1.2/#ARIAMixin>
diff --git a/docs/rules/template-no-aria-hidden-on-focusable.md b/docs/rules/template-no-aria-hidden-on-focusable.md
new file mode 100644
index 0000000000..a8f7c40c7b
--- /dev/null
+++ b/docs/rules/template-no-aria-hidden-on-focusable.md
@@ -0,0 +1,70 @@
+# ember/template-no-aria-hidden-on-focusable
+
+<!-- end auto-generated rule header -->
+
+Disallow `aria-hidden="true"` on focusable elements or elements containing focusable descendants.
+
+An element with `aria-hidden="true"` is removed from the accessibility tree but remains keyboard-focusable. This creates a keyboard trap — users reach the element via Tab but can't perceive it. The same applies to focusable descendants of an `aria-hidden` ancestor, since `aria-hidden` does not remove elements from the tab order.
+
+Per [WAI-ARIA 1.2 — aria-hidden](https://www.w3.org/TR/wai-aria-1.2/#aria-hidden):
+
+> Authors SHOULD NOT use `aria-hidden="true"` on any element that has focus or may receive focus, either directly via interaction with the user or indirectly via programmatic means such as JavaScript-based event handling.
+
+The phrase "may receive focus" is interpreted to include focusable descendants: `aria-hidden` cascades to hide the entire subtree from assistive tech, while any focusable descendant within that subtree remains reachable via Tab — landing keyboard users on AT-invisible content.
+
+## Examples
+
+This rule **forbids** the following:
+
+```gjs
+<template>
+  <button aria-hidden="true">Trapped</button>
+  <a href="/x" aria-hidden="true">Link</a>
+  <div tabindex="0" aria-hidden="true">Focusable but hidden</div>
+
+  {{! Focusable descendant inside an aria-hidden ancestor — classic modal backdrop trap }}
+  <div aria-hidden="true">
+    <button>Close</button>
+  </div>
+</template>
+```
+
+This rule **allows** the following:
+
+```gjs
+<template>
+  {{! Non-focusable decorative content }}
+  <div aria-hidden="true"><svg class="decoration" /></div>
+
+  {{! Explicit opt-out }}
+  <button aria-hidden="false">Click me</button>
+
+  {{! input type="hidden" is not focusable }}
+  <input type="hidden" aria-hidden="true" />
+
+  {{! Component/dynamic descendants are opaque — conservatively not flagged }}
+  <div aria-hidden="true"><CustomBtn /></div>
+</template>
+```
+
+## Caveats
+
+Component invocations, argument/`this`/path-based tags, and namespace-pathed
+tags are "opaque" — we can't statically know what they render. The descendant
+check skips these branches to avoid false positives. If a component renders a
+focusable element beneath an `aria-hidden` ancestor, the keyboard trap still
+exists at runtime; this rule can't detect it.
+
+Custom elements (hyphenated tags like `<my-widget>`) are similarly skipped: we
+can't know whether their shadow DOM defines a focusable region. If
+`<my-widget aria-hidden="true">` renders a focusable element internally, the
+trap still exists at runtime — this rule can't detect it.
+
+Dynamic content inside `{{...}}` mustache statements is similarly not inspected.
+
+## References
+
+- [WAI-ARIA 1.2 — aria-hidden](https://www.w3.org/TR/wai-aria-1.2/#aria-hidden)
+- [WebAIM — Hiding content from assistive tech](https://webaim.org/techniques/css/invisiblecontent/)
+- [`no-aria-hidden-on-focusable` — eslint-plugin-jsx-a11y](https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/no-aria-hidden-on-focusable.md)
+- [`no-aria-hidden-on-focusable` — eslint-plugin-vuejs-accessibility](https://github.com/vue-a11y/eslint-plugin-vuejs-accessibility/blob/main/docs/rules/no-aria-hidden-on-focusable.md)
diff --git a/lib/rules/template-block-indentation.js b/lib/rules/template-block-indentation.js
index 660fd1a94f..e42831516f 100644
--- a/lib/rules/template-block-indentation.js
+++ b/lib/rules/template-block-indentation.js
@@ -1,25 +1,9 @@
 'use strict';
 
+const { htmlVoidElements } = require('html-void-elements');
 const editorConfigUtil = require('../utils/editorconfig');
 
-const VOID_TAGS = new Set([
-  'area',
-  'base',
-  'br',
-  'col',
-  'command',
-  'embed',
-  'hr',
-  'img',
-  'input',
-  'keygen',
-  'link',
-  'meta',
-  'param',
-  'source',
-  'track',
-  'wbr',
-]);
+const VOID_TAGS = new Set(htmlVoidElements);
 const IGNORED_ELEMENTS = new Set(['pre', 'script', 'style', 'textarea']);
 
 function isControlChar(char) {
diff --git a/lib/rules/template-no-aria-hidden-on-focusable.js b/lib/rules/template-no-aria-hidden-on-focusable.js
new file mode 100644
index 0000000000..e56f7d9655
--- /dev/null
+++ b/lib/rules/template-no-aria-hidden-on-focusable.js
@@ -0,0 +1,206 @@
+'use strict';
+
+const { isNativeElement } = require('../utils/is-native-element');
+const { getStaticAttrValue } = require('../utils/static-attr-value');
+const { classifyAttribute } = require('../utils/glimmer-attr-presence');
+
+function findAttr(node, name) {
+  return node.attributes?.find((a) => a.name === name);
+}
+
+// Returns the statically-known string value of a named attribute, or
+// `undefined` when the attribute is absent or its value is dynamic.
+function getTextAttrValue(node, name) {
+  const attr = findAttr(node, name);
+  if (!attr) {
+    return undefined;
+  }
+  return getStaticAttrValue(attr.value);
+}
+
+// Per WAI-ARIA 1.2 §6.6 + aria-hidden value table, a missing or empty-string
+// aria-hidden resolves to the default `undefined` — NOT `true`. So only an
+// explicit `"true"` (ASCII case-insensitive per HTML enumerated-attribute
+// rules) hides the element. Mustache boolean-literal `{{true}}` and
+// string-literal `{{"true"}}` also qualify.
+function isAriaHiddenTrue(node) {
+  const value = findAttr(node, 'aria-hidden')?.value;
+  if (!value) {
+    return false;
+  }
+  // Resolve through getStaticAttrValue so quoted-mustache concat forms
+  // (e.g. aria-hidden="{{true}}") and case variants normalize uniformly.
+  const resolved = getStaticAttrValue(value);
+  if (typeof resolved !== 'string') {
+    return false;
+  }
+  return resolved.trim().toLowerCase() === 'true';
+}
+
+// Tags with an unconditional default focusable UI (sequentially focusable per
+// HTML §6.6.3 "focusable area" + widget roles per HTML-AAM).
+// NOTE: <label> is HTML-interactive-content (§3.2.5.2.7) but NOT keyboard-
+// focusable by default — clicks on a label forward to its associated control,
+// but the label itself isn't in the tab order. So it's excluded here even
+// though `isHtmlInteractiveContent` would return true for it.
+const UNCONDITIONAL_FOCUSABLE_TAGS = new Set([
+  'button',
+  'select',
+  'textarea',
+  'iframe',
+  'embed',
+  'summary',
+  'details',
+  'option',
+  'datalist',
+]);
+
+// Form-control tags whose `disabled` attribute removes them from the tab order
+// (HTML §4.10.18.5 "disabled" + HTML §6.6.3 "focusable area").
+const DISABLEABLE_TAGS = new Set(['button', 'input', 'select', 'textarea', 'fieldset']);
+
+function isDisabledFormControl(node, tag) {
+  if (!DISABLEABLE_TAGS.has(tag)) {
+    return false;
+  }
+  const attr = findAttr(node, 'disabled');
+  // Per docs/glimmer-attribute-behavior.md (rows d3, d6 plus cross-attribute
+  // observation on falsy-coercion), bare-mustache falsy literals on a boolean
+  // HTML attribute cause Glimmer to omit the attribute at runtime. We use
+  // classifyAttribute so the runtime-rendered presence drives the answer
+  // rather than AST-presence.
+  return classifyAttribute(attr).presence === 'present';
+}
+
+// Narrow rule-local "keyboard-focusable" check. Intentionally distinct from
+// `isHtmlInteractiveContent` (HTML content-model) — we want the sequential-
+// focus + programmatic-focus axis only. See WAI-ARIA "focusable" definition
+// and HTML §6.6.3.
+function isKeyboardFocusable(node, getTextAttrValueFn) {
+  const rawTag = node?.tag;
+  if (typeof rawTag !== 'string' || rawTag.length === 0) {
+    return false;
+  }
+  const tag = rawTag.toLowerCase();
+
+  // Disabled form controls are not focusable.
+  if (isDisabledFormControl(node, tag)) {
+    return false;
+  }
+
+  // Any tabindex (including "-1") makes the element at least programmatically
+  // focusable — still a keyboard-trap risk under aria-hidden. Use
+  // classifyAttribute so bare `{{false}}` / `{{null}}` / `{{undefined}}`
+  // (rows t6, t7) — which Glimmer omits at runtime — are NOT treated as
+  // having a tabindex.
+  if (classifyAttribute(findAttr(node, 'tabindex')).presence === 'present') {
+    return true;
+  }
+
+  // contenteditable (truthy) makes the element focusable.
+  const contentEditable = getTextAttrValueFn(node, 'contenteditable');
+  if (contentEditable !== undefined && contentEditable !== null) {
+    const normalized = contentEditable.trim().toLowerCase();
+    // per HTML spec, "", "true", and "plaintext-only" all enable editing.
+    if (normalized === '' || normalized === 'true' || normalized === 'plaintext-only') {
+      return true;
+    }
+  }
+
+  if (UNCONDITIONAL_FOCUSABLE_TAGS.has(tag)) {
+    return true;
+  }
+
+  if (tag === 'input') {
+    const type = getTextAttrValueFn(node, 'type');
+    return type === undefined || type === null || type.trim().toLowerCase() !== 'hidden';
+  }
+
+  if (tag === 'a' || tag === 'area') {
+    return Boolean(findAttr(node, 'href'));
+  }
+
+  if (tag === 'img') {
+    return Boolean(findAttr(node, 'usemap'));
+  }
+
+  if (tag === 'audio' || tag === 'video') {
+    return Boolean(findAttr(node, 'controls'));
+  }
+
+  return false;
+}
+
+// A focusable descendant of an aria-hidden="true" ancestor can still receive
+// focus (aria-hidden does not remove elements from the tab order), so the
+// ancestor hides AT-visible content that remains keyboard-reachable — a
+// keyboard trap. This rule targets the anti-pattern flagged by axe's
+// `aria-hidden-focus` check and by jsx-a11y's `no-aria-hidden-on-focusable`.
+// WAI-ARIA 1.2 says authors SHOULD NOT put aria-hidden on focusable content
+// (the spec normatively warns against this in the aria-hidden authoring note).
+function hasFocusableDescendant(node, sourceCode) {
+  const children = node.children;
+  if (!children || children.length === 0) {
+    return false;
+  }
+  for (const child of children) {
+    if (child.type !== 'GlimmerElementNode') {
+      // Skip TextNode, GlimmerMustacheStatement (dynamic content), yield
+      // expressions, and anything else whose rendered element we can't inspect.
+      continue;
+    }
+    if (!isNativeElement(child, sourceCode)) {
+      // Component / dynamic / shadowed tag — opaque. Don't recurse.
+      continue;
+    }
+    if (isKeyboardFocusable(child, getTextAttrValue)) {
+      return true;
+    }
+    if (hasFocusableDescendant(child, sourceCode)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'disallow aria-hidden="true" on focusable elements',
+      category: 'Accessibility',
+      url: 'https://github.com/ember-cli/eslint-plugin-ember/tree/master/docs/rules/template-no-aria-hidden-on-focusable.md',
+      templateMode: 'both',
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      noAriaHiddenOnFocusable:
+        'aria-hidden="true" must not be set on focusable elements — it creates a keyboard trap (element reachable via Tab but hidden from assistive tech).',
+      noAriaHiddenOnAncestorOfFocusable:
+        'aria-hidden="true" must not be set on an element that contains focusable descendants — the descendants remain keyboard-reachable but are hidden from assistive tech.',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    return {
+      GlimmerElementNode(node) {
+        if (!isAriaHiddenTrue(node)) {
+          return;
+        }
+        if (!isNativeElement(node, sourceCode)) {
+          return;
+        }
+        if (isKeyboardFocusable(node, getTextAttrValue)) {
+          context.report({ node, messageId: 'noAriaHiddenOnFocusable' });
+          return;
+        }
+        if (hasFocusableDescendant(node, sourceCode)) {
+          context.report({ node, messageId: 'noAriaHiddenOnAncestorOfFocusable' });
+        }
+      },
+    };
+  },
+};
diff --git a/lib/rules/template-self-closing-void-elements.js b/lib/rules/template-self-closing-void-elements.js
index 6b194979c7..2cc40f813a 100644
--- a/lib/rules/template-self-closing-void-elements.js
+++ b/lib/rules/template-self-closing-void-elements.js
@@ -1,3 +1,9 @@
+'use strict';
+
+const { htmlVoidElements } = require('html-void-elements');
+
+const VOID_ELEMENTS = new Set(htmlVoidElements);
+
 /** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
@@ -27,25 +33,6 @@ module.exports = {
   },
 
   create(context) {
-    const VOID_ELEMENTS = new Set([
-      'area',
-      'base',
-      'br',
-      'col',
-      'command',
-      'embed',
-      'hr',
-      'img',
-      'input',
-      'keygen',
-      'link',
-      'meta',
-      'param',
-      'source',
-      'track',
-      'wbr',
-    ]);
-
     const sourceCode = context.sourceCode;
     const config = context.options[0] ?? true;
 
diff --git a/lib/utils/glimmer-attr-presence.js b/lib/utils/glimmer-attr-presence.js
new file mode 100644
index 0000000000..1d8479a28e
--- /dev/null
+++ b/lib/utils/glimmer-attr-presence.js
@@ -0,0 +1,202 @@
+'use strict';
+
+const { find, html } = require('property-information');
+const { getStaticAttrValue } = require('./static-attr-value');
+
+// `colspan` is a positive-integer attribute per WHATWG, but property-information
+// 7.1.0 doesn't mark it as `number: true` (likely upstream gap — `rowspan`,
+// `cols`, etc. do have it). Override locally; remove if upstream fixes.
+const NUMERIC_OVERRIDES = new Set(['colspan']);
+
+/**
+ * Infer the attribute kind from its name. Used when the caller doesn't pass
+ * `options.kind` explicitly.
+ *
+ * Returns one of: 'boolean' | 'aria' | 'numeric' | 'plain-string'.
+ *
+ * Classification flows from the `property-information` package, which encodes
+ * attribute type info per WHATWG HTML / WAI-ARIA. ARIA prefix is checked first
+ * because Glimmer's rendering for `aria-*` attrs diverges from HTML booleans
+ * (e.g., `aria-hidden={{true}}` renders empty per h5, but `disabled={{true}}`
+ * renders `disabled=""` per d2). `role` falls through to plain-string because
+ * Glimmer does not falsy-coerce it (the doc's cross-attribute observations
+ * confirm this — `role={{false}}` renders `role="false"`).
+ */
+function inferAttrKind(name) {
+  // HTML attribute names are case-insensitive; normalize before lookup so
+  // `Disabled`, `ARIA-Hidden`, etc. classify the same as the lowercase form.
+  const lower = name.toLowerCase();
+  if (lower.startsWith('aria-')) {
+    return 'aria';
+  }
+  const info = find(html, lower);
+  // boolean: standard HTML boolean attrs (disabled, muted, …).
+  // overloadedBoolean: hidden, download — boolean-like with extra string values,
+  // but Glimmer's falsy-omit coercion still applies (verified for `hidden`-style).
+  if (info.boolean || info.overloadedBoolean) {
+    return 'boolean';
+  }
+  if (info.number || NUMERIC_OVERRIDES.has(lower)) {
+    return 'numeric';
+  }
+  // Everything else (plain strings, booleanish HTML attrs like contenteditable
+  // and draggable whose Glimmer behavior isn't verified in the doc) routes to
+  // plain-string. Conservative: no falsy-omit coercion, render the literal.
+  return 'plain-string';
+}
+
+/**
+ * Classify a Glimmer attribute against the verified rendering model in
+ * docs/glimmer-attribute-behavior.md.
+ *
+ * Result shape: { presence, value }
+ *
+ *   presence: 'absent' | 'present' | 'unknown'
+ *     - 'absent'  — attribute will not be on the rendered element.
+ *                   Either attrNode is null/undefined, OR the source is
+ *                   bare {{false}}/{{null}}/{{undefined}} (or {{0}} for
+ *                   `boolean` kind) on a falsy-coerced attribute kind
+ *                   (boolean / aria / numeric). Doc rows: m6, m9, m10, m12,
+ *                   d3, d6, h6, h9, h10, t6, t7.
+ *     - 'present' — attribute will be present at runtime. `value` is the
+ *                   resolved static string when known, or null when the
+ *                   value is dynamic (e.g., bare {{this.x}} on a plain-string
+ *                   attribute).
+ *     - 'unknown' — cannot determine statically (dynamic mustache / dynamic
+ *                   concat part on a falsy-coerced kind, since the runtime
+ *                   value could be falsy and thus omit the attribute).
+ *
+ *   value: string | null
+ *     The resolved HTML attribute value when statically known. null when:
+ *       - presence is 'absent' or 'unknown'
+ *       - presence is 'present' but the value is dynamic
+ *
+ * @param {object|null|undefined} attrNode - The AttrNode, or null/undefined when not found.
+ * @param {object} [options]
+ * @param {'boolean'|'aria'|'numeric'|'plain-string'} [options.kind] - Override inferred kind.
+ * @returns {{presence: 'absent'|'present'|'unknown', value: string|null}}
+ */
+function classifyAttribute(attrNode, options = {}) {
+  if (!attrNode) {
+    return { presence: 'absent', value: null };
+  }
+
+  const kind = options.kind || inferAttrKind(attrNode.name);
+  const isFalsyCoerced = kind === 'boolean' || kind === 'aria' || kind === 'numeric';
+  const value = attrNode.value;
+
+  // Valueless attribute: <input disabled />, <div aria-hidden></div>
+  // Renders as `attr=""`. Doc rows: d1, h1.
+  if (value === null || value === undefined) {
+    return { presence: 'present', value: '' };
+  }
+
+  // Static text: attr="anything". Renders the literal chars.
+  // Doc rows: m1-m4, h2-h4, d1, t-static, i1.
+  if (value.type === 'GlimmerTextNode') {
+    return { presence: 'present', value: value.chars };
+  }
+
+  // Bare-mustache: attr={{X}}
+  if (value.type === 'GlimmerMustacheStatement') {
+    return classifyBareMustache(value, kind, isFalsyCoerced);
+  }
+
+  // Concat-mustache: attr="...{{X}}..." — never falsy.
+  // Doc cross-attribute observation: "Concat is never falsy."
+  if (value.type === 'GlimmerConcatStatement') {
+    // For boolean attrs, the IDL property is set true regardless of inner
+    // literal (rows m13–m19, d7–d10). Report the canonical "on" value so
+    // callers comparing `value === 'false'` to detect "off" don't get a
+    // wrong answer from the inner literal of `attr="{{false}}"`.
+    if (kind === 'boolean') {
+      return { presence: 'present', value: 'true' };
+    }
+    // For aria/numeric/plain-string, the rendered HTML value is the
+    // stringified concatenation of parts (h12–h15, i3, i5). If any part
+    // is dynamic, the resolved value is unknown but presence is still 'present'.
+    const resolved = getStaticAttrValue(value);
+    return { presence: 'present', value: resolved === undefined ? null : resolved };
+  }
+
+  // Unknown AST shape (e.g., a future Glimmer node type) — be conservative.
+  return { presence: 'unknown', value: null };
+}
+
+function classifyBareMustache(value, kind, isFalsyCoerced) {
+  const path = value.path;
+  if (!path) {
+    return { presence: 'unknown', value: null };
+  }
+
+  // {{true}} / {{false}}
+  if (path.type === 'GlimmerBooleanLiteral') {
+    if (path.value === false) {
+      // {{false}} on falsy-coerced kind → omitted (m6, d3, h6, t6 verified).
+      // {{false}} on plain-string → renders "false" (i4 verified for autocomplete).
+      if (isFalsyCoerced) {
+        return { presence: 'absent', value: null };
+      }
+      return { presence: 'present', value: 'false' };
+    }
+    // {{true}}: behavior diverges by kind.
+    //   - boolean: verified (m5, d2). HTML may be empty (d2) or omitted (m5),
+    //     but the attribute is conceptually "on". Surface 'true' so callers
+    //     can string-compare like for {{"true"}}.
+    //   - aria: verified (h5). Renders aria-hidden="" — empty, NOT "true".
+    //     Callers comparing aria-hidden to "true" must not match this row.
+    //   - numeric / plain-string: untested in the verification doc. Be
+    //     conservative — return 'unknown' rather than guess.
+    if (kind === 'boolean') {
+      return { presence: 'present', value: 'true' };
+    }
+    if (kind === 'aria') {
+      return { presence: 'present', value: '' };
+    }
+    return { presence: 'unknown', value: null };
+  }
+
+  // {{null}} / {{undefined}}
+  if (path.type === 'GlimmerNullLiteral' || path.type === 'GlimmerUndefinedLiteral') {
+    // Verified for falsy-coerced kinds via cross-attribute observation
+    // (rows m9, m10, h9, h10, d6, t7).
+    // For plain-string, behavior is not yet verified — return 'unknown' to
+    // avoid claiming behavior the doc doesn't guarantee.
+    if (isFalsyCoerced) {
+      return { presence: 'absent', value: null };
+    }
+    return { presence: 'unknown', value: null };
+  }
+
+  // {{"string"}}
+  // Bare-mustache string literals never coerce — render literal value.
+  // Doc rows: m7, m8, h7, h8, d4, d5, i2.
+  if (path.type === 'GlimmerStringLiteral') {
+    return { presence: 'present', value: path.value };
+  }
+
+  // {{0}}, {{1}}, {{-1}}, etc.
+  if (path.type === 'GlimmerNumberLiteral') {
+    // {{0}} for boolean kind → omitted (m12 verified for muted).
+    // For numeric kind, t1 verifies {{0}} renders "0" (focusable).
+    // For plain-string, untested.
+    if (path.value === 0 && kind === 'boolean') {
+      return { presence: 'absent', value: null };
+    }
+    return { presence: 'present', value: String(path.value) };
+  }
+
+  // Dynamic path: {{this.x}}, {{x}}, {{(some-helper)}}, etc.
+  // For falsy-coerced kinds, runtime value could be falsy → attribute omitted.
+  // For plain-string, the attribute renders something (even null/undefined coerce
+  // via stringification), but the value isn't statically known.
+  if (isFalsyCoerced) {
+    return { presence: 'unknown', value: null };
+  }
+  return { presence: 'present', value: null };
+}
+
+module.exports = {
+  classifyAttribute,
+  inferAttrKind,
+};
diff --git a/package.json b/package.json
index af6257b79c..b75bb22bed 100644
--- a/package.json
+++ b/package.json
@@ -72,10 +72,12 @@
     "eslint-utils": "^3.0.0",
     "estraverse": "^5.3.0",
     "html-tags": "^3.3.1",
+    "html-void-elements": "^3.0.0",
     "language-tags": "^1.0.9",
     "lodash.camelcase": "^4.3.0",
     "lodash.kebabcase": "^4.1.1",
     "mathml-tag-names": "^4.0.0",
+    "property-information": "^7.1.0",
     "requireindex": "^1.2.0",
     "snake-case": "^3.0.3",
     "svg-tags": "^1.0.0"
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index fc56891f9f..6140b319e9 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -38,6 +38,9 @@ importers:
       html-tags:
         specifier: ^3.3.1
         version: 3.3.1
+      html-void-elements:
+        specifier: ^3.0.0
+        version: 3.0.0
       language-tags:
         specifier: ^1.0.9
         version: 1.0.9
@@ -50,6 +53,9 @@ importers:
       mathml-tag-names:
         specifier: ^4.0.0
         version: 4.0.0
+      property-information:
+        specifier: ^7.1.0
+        version: 7.1.0
       requireindex:
         specifier: ^1.2.0
         version: 1.2.0
@@ -2313,6 +2319,9 @@ packages:
     resolution: {integrity: sha512-n6l5uca7/y5joxZ3LUePhzmBFUJ+U2YWzhMa8XUTecSeSlQiZdF5XAd/Q3/WUl0VsXgUwWi8I7CNIwdI5WN1SQ==}
     engines: {node: '>=20.10'}
 
+  html-void-elements@3.0.0:
+    resolution: {integrity: sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==}
+
   http-cache-semantics@4.2.0:
     resolution: {integrity: sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==}
 
@@ -3394,6 +3403,9 @@ packages:
     resolution: {integrity: sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==}
     engines: {node: '>=10'}
 
+  property-information@7.1.0:
+    resolution: {integrity: sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==}
+
   proto-list@1.2.4:
     resolution: {integrity: sha512-vtK/94akxsTMhe0/cbfpR+syPuszcuwhqVjJq26CuNDgFGj682oRBXOP5MJpv2r7JtE8MsiepGIqvvOTBwn2vA==}
 
@@ -6447,6 +6459,8 @@ snapshots:
 
   html-tags@5.1.0: {}
 
+  html-void-elements@3.0.0: {}
+
   http-cache-semantics@4.2.0: {}
 
   http-proxy-agent@4.0.1:
@@ -7693,6 +7707,8 @@ snapshots:
       err-code: 2.0.3
       retry: 0.12.0
 
+  property-information@7.1.0: {}
+
   proto-list@1.2.4: {}
 
   psl@1.15.0:
diff --git a/tests/lib/rules/template-no-aria-hidden-on-focusable.js b/tests/lib/rules/template-no-aria-hidden-on-focusable.js
new file mode 100644
index 0000000000..effbbcf1a1
--- /dev/null
+++ b/tests/lib/rules/template-no-aria-hidden-on-focusable.js
@@ -0,0 +1,313 @@
+'use strict';
+
+const rule = require('../../../lib/rules/template-no-aria-hidden-on-focusable');
+const RuleTester = require('eslint').RuleTester;
+
+const ruleTester = new RuleTester({
+  parser: require.resolve('ember-eslint-parser'),
+  parserOptions: { ecmaVersion: 2022, sourceType: 'module' },
+});
+
+ruleTester.run('template-no-aria-hidden-on-focusable', rule, {
+  valid: [
+    // aria-hidden on non-focusable elements — fine.
+    '<template><div aria-hidden="true"></div></template>',
+    '<template><span aria-hidden="true">decorative</span></template>',
+    '<template><img src="/x.png" alt="" aria-hidden="true" /></template>',
+
+    // Focusable elements without aria-hidden — fine.
+    '<template><button>Click me</button></template>',
+    '<template><a href="/x">Link</a></template>',
+    '<template><input type="text" /></template>',
+
+    // aria-hidden="false" — explicit opt-out. Not flagged.
+    '<template><button aria-hidden="false">Click me</button></template>',
+
+    // Valueless / empty aria-hidden resolves to default `undefined` per
+    // WAI-ARIA 1.2 §6.6 — not hidden, not flagged even on focusable hosts.
+    '<template><button aria-hidden>Click me</button></template>',
+    '<template><button aria-hidden="">Click me</button></template>',
+    '<template><button aria-hidden={{false}}>Click me</button></template>',
+
+    // <input type="hidden"> isn't focusable, so aria-hidden on it is fine.
+    '<template><input type="hidden" aria-hidden="true" /></template>',
+    // Mustache string literal — statically resolvable to "hidden".
+    '<template><input type={{"hidden"}} aria-hidden="true" /></template>',
+
+    // <a> without href isn't focusable by default.
+    '<template><a aria-hidden="true">Not a link</a></template>',
+
+    // <label> is HTML interactive content but NOT keyboard-focusable by default
+    // (clicks forward to the associated control; the label itself isn't in the
+    // tab order). So aria-hidden on it is fine.
+    '<template><label aria-hidden="true">Name</label></template>',
+
+    // Disabled form controls are removed from the tab order (HTML §4.10.18.5),
+    // so they're not keyboard-focusable and aria-hidden on them isn't a trap.
+    '<template><button disabled aria-hidden="true">Click me</button></template>',
+    '<template><input disabled aria-hidden="true" /></template>',
+
+    // Bare-mustache falsy on tabindex (rows t6, t7) — Glimmer omits the
+    // attribute at runtime, so the element is NOT focusable from tabindex
+    // and aria-hidden isn't trapping anything. AST-presence check would
+    // have false-positive flagged these.
+    '<template><div tabindex={{false}} aria-hidden="true"></div></template>',
+    '<template><div tabindex={{null}} aria-hidden="true"></div></template>',
+    '<template><div tabindex={{undefined}} aria-hidden="true"></div></template>',
+
+    // Components — we don't know if they render a focusable element.
+    '<template><CustomBtn aria-hidden="true" /></template>',
+
+    // <audio> / <video> without `controls` are not interactive — no focusable UI.
+    '<template><video aria-hidden="true"></video></template>',
+    '<template><audio aria-hidden="true"></audio></template>',
+    '<template><div aria-hidden="true"><video></video></div></template>',
+    '<template><div aria-hidden="true"><audio></audio></div></template>',
+
+    // Descendant-focusable check — valid cases.
+    // No focusable descendant.
+    '<template><div aria-hidden="true"><span>Just text</span></div></template>',
+    // Component descendants are opaque — conservatively not flagged.
+    '<template><div aria-hidden="true"><Button>X</Button></div></template>',
+    // No focusable descendants (alt-less img is decorative, not focusable).
+    '<template><div aria-hidden="true"><img alt="static" /></div></template>',
+    // <input type="hidden"> is non-focusable per isFocusable.
+    '<template><div aria-hidden="true"><input type="hidden" /></div></template>',
+    // Event modifiers (`{{on "click" ...}}`) do not make an element focusable —
+    // only tabindex / inherent native focusability does.
+    '<template><div {{on "click" this.handler}} aria-hidden="true"></div></template>',
+
+    // Dynamic mustache descendants are not inspected.
+    '<template><div aria-hidden="true">{{this.label}}</div></template>',
+    // `@arg`-prefixed tag is opaque.
+    '<template><div aria-hidden="true"><@thing /></div></template>',
+    // `this.`-prefixed tag is opaque.
+    '<template><div aria-hidden="true"><this.Item /></div></template>',
+  ],
+  invalid: [
+    // Native interactive elements.
+    {
+      code: '<template><button aria-hidden="true">Trapped</button></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+    {
+      code: '<template><a href="/x" aria-hidden="true">Link</a></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+    {
+      code: '<template><input type="text" aria-hidden="true" /></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+    {
+      code: '<template><select aria-hidden="true"><option /></select></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+    {
+      code: '<template><textarea aria-hidden="true"></textarea></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+
+    // Non-interactive element made focusable via tabindex.
+    {
+      code: '<template><div tabindex="0" aria-hidden="true"></div></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+    {
+      // tabindex="-1" still makes it programmatically focusable — still flag.
+      code: '<template><div tabindex="-1" aria-hidden="true"></div></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+    // DIVERGENCE from jsx-a11y + vue-a11y: both accept button[tabindex="-1"][aria-hidden="true"]
+    // reasoning that tabindex="-1" removes the element from the tab order.
+    // Our rule treats tabindex="-1" as still programmatically focusable (reachable via
+    // .focus() and click), so aria-hidden on it still creates an AT-invisibility mismatch.
+    {
+      code: '<template><button aria-hidden="true" tabindex="-1"></button></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+
+    // Mustache-boolean + case-variant aria-hidden = true — truthy per spec.
+    {
+      code: '<template><button aria-hidden={{true}}></button></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+    // GlimmerConcatStatement form. Per docs/glimmer-attribute-behavior.md,
+    // `aria-hidden="{{true}}"` renders as `aria-hidden="true"`.
+    {
+      code: '<template><button aria-hidden="{{true}}"></button></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+    // disabled={{false}} is the bare-mustache boolean-false case — Glimmer
+    // omits the attribute at runtime, so the button stays focusable and
+    // aria-hidden="true" traps it. (`disabled="{{false}}"` and
+    // `disabled={{"false"}}` would NOT omit; those keep the button disabled.)
+    {
+      code: '<template><button aria-hidden="true" disabled={{false}}>click</button></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+    // Same shape with bare-mustache null/undefined — also omitted (rows d6 + cross-attr observation).
+    {
+      code: '<template><button aria-hidden="true" disabled={{null}}>click</button></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+    {
+      code: '<template><button aria-hidden="true" disabled={{undefined}}>click</button></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+    {
+      code: '<template><button aria-hidden="TRUE"></button></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+    {
+      // Whitespace-padded "true" is still a truthy aria-hidden per enumerated-
+      // attribute normalization (trim + case-insensitive).
+      code: '<template><button aria-hidden=" true "></button></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+
+    // Descendant-focusable check. Per WAI-ARIA 1.2 §aria-hidden
+    // "may receive focus" — focusable descendants are keyboard-reachable
+    // under an aria-hidden ancestor, creating a keyboard trap.
+    {
+      // Classic modal-backdrop trap.
+      code: '<template><div aria-hidden="true"><button>Close</button></div></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnAncestorOfFocusable' }],
+    },
+    {
+      // Deeper descendant.
+      code: '<template><div aria-hidden="true"><span><button>Deep</button></span></div></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnAncestorOfFocusable' }],
+    },
+    {
+      code: '<template><div aria-hidden="true"><a href="/x">Link</a></div></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnAncestorOfFocusable' }],
+    },
+    {
+      code: '<template><div aria-hidden="true"><input /></div></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnAncestorOfFocusable' }],
+    },
+    {
+      // Depth check — focusable descendant two levels deep.
+      code: '<template><section aria-hidden="true"><div><textarea></textarea></div></section></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnAncestorOfFocusable' }],
+    },
+    {
+      // tabindex on a descendant makes it focusable.
+      code: '<template><div aria-hidden="true"><span tabindex="0">x</span></div></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnAncestorOfFocusable' }],
+    },
+    // DIVERGENCE from vue-a11y: it considers tabindex="-1" on a descendant as "escaped from
+    // tab order = not focusable". Our isFocusable treats any tabindex (including "-1") as
+    // programmatically focusable, so the ancestor aria-hidden still creates a trap.
+    {
+      code: '<template><div aria-hidden="true"><button tabindex="-1">Trapped</button></div></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnAncestorOfFocusable' }],
+    },
+    {
+      code: '<template><div aria-hidden="true"><a href="#" tabindex="-1">Link</a></div></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnAncestorOfFocusable' }],
+    },
+
+    // <audio controls> / <video controls> expose focusable UI; flag directly.
+    {
+      code: '<template><video controls aria-hidden="true"></video></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+    {
+      code: '<template><audio controls aria-hidden="true"></audio></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+    // <audio controls> / <video controls> as focusable descendants of an
+    // aria-hidden ancestor.
+    {
+      code: '<template><div aria-hidden="true"><video controls></video></div></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnAncestorOfFocusable' }],
+    },
+    {
+      code: '<template><div aria-hidden="true"><audio controls></audio></div></template>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnAncestorOfFocusable' }],
+    },
+  ],
+});
+
+const hbsRuleTester = new RuleTester({
+  parser: require.resolve('ember-eslint-parser/hbs'),
+  parserOptions: { ecmaVersion: 2022, sourceType: 'module' },
+});
+
+hbsRuleTester.run('template-no-aria-hidden-on-focusable', rule, {
+  valid: [
+    '<div aria-hidden="true"></div>',
+    '<button>Click me</button>',
+    '<input type="hidden" aria-hidden="true" />',
+    // Mustache string literal — statically resolvable to "hidden".
+    '<input type={{"hidden"}} aria-hidden="true" />',
+    '<CustomBtn aria-hidden="true" />',
+    // Descendant-focusable — non-focusable child.
+    '<div aria-hidden="true"><span>Just text</span></div>',
+    // Component descendant is opaque.
+    '<div aria-hidden="true"><Button>X</Button></div>',
+  ],
+  invalid: [
+    {
+      code: '<button aria-hidden="true">Trapped</button>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+    {
+      code: '<div tabindex="0" aria-hidden="true"></div>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+    // Descendant-focusable check.
+    {
+      code: '<div aria-hidden="true"><button>Close</button></div>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnAncestorOfFocusable' }],
+    },
+    {
+      code: '<section aria-hidden="true"><div><a href="/x">Link</a></div></section>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnAncestorOfFocusable' }],
+    },
+    // <audio controls> / <video controls> — directly focusable.
+    {
+      code: '<video controls aria-hidden="true"></video>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnFocusable' }],
+    },
+    // <audio controls> / <video controls> — focusable descendant.
+    {
+      code: '<div aria-hidden="true"><audio controls></audio></div>',
+      output: null,
+      errors: [{ messageId: 'noAriaHiddenOnAncestorOfFocusable' }],
+    },
+  ],
+});
diff --git a/tests/lib/utils/glimmer-attr-presence-test.js b/tests/lib/utils/glimmer-attr-presence-test.js
new file mode 100644
index 0000000000..ba8560cd01
--- /dev/null
+++ b/tests/lib/utils/glimmer-attr-presence-test.js
@@ -0,0 +1,389 @@
+'use strict';
+
+const { classifyAttribute, inferAttrKind } = require('../../../lib/utils/glimmer-attr-presence');
+
+// Helpers to build minimal AttrNode-shaped objects for tests.
+function attr(name, value) {
+  return { name, value };
+}
+function textNode(chars) {
+  return { type: 'GlimmerTextNode', chars };
+}
+function bareMustache(path) {
+  return { type: 'GlimmerMustacheStatement', path };
+}
+function concat(parts) {
+  return { type: 'GlimmerConcatStatement', parts };
+}
+const boolLit = (v) => ({ type: 'GlimmerBooleanLiteral', value: v });
+const stringLit = (v) => ({ type: 'GlimmerStringLiteral', value: v });
+const numberLit = (v) => ({ type: 'GlimmerNumberLiteral', value: v });
+const nullLit = () => ({ type: 'GlimmerNullLiteral' });
+const undefinedLit = () => ({ type: 'GlimmerUndefinedLiteral' });
+const pathExpr = (original) => ({ type: 'GlimmerPathExpression', original });
+
+describe('inferAttrKind', () => {
+  it('classifies known HTML boolean attrs', () => {
+    expect(inferAttrKind('disabled')).toBe('boolean');
+    expect(inferAttrKind('muted')).toBe('boolean');
+    expect(inferAttrKind('autoplay')).toBe('boolean');
+    expect(inferAttrKind('hidden')).toBe('boolean');
+    expect(inferAttrKind('controls')).toBe('boolean');
+  });
+
+  it('classifies aria-* attributes', () => {
+    expect(inferAttrKind('aria-hidden')).toBe('aria');
+    expect(inferAttrKind('aria-label')).toBe('aria');
+    expect(inferAttrKind('aria-checked')).toBe('aria');
+  });
+
+  it('classifies known numeric attrs', () => {
+    expect(inferAttrKind('tabindex')).toBe('numeric');
+    expect(inferAttrKind('colspan')).toBe('numeric');
+  });
+
+  it('treats role as plain-string (not aria-coerced)', () => {
+    // Despite living conceptually with ARIA, role is a plain DOM string
+    // attribute and does NOT participate in falsy-coercion (per the
+    // cross-attribute observations in docs/glimmer-attribute-behavior.md).
+    expect(inferAttrKind('role')).toBe('plain-string');
+  });
+
+  it('classifies unknown attrs as plain-string', () => {
+    expect(inferAttrKind('autocomplete')).toBe('plain-string');
+    expect(inferAttrKind('href')).toBe('plain-string');
+    expect(inferAttrKind('id')).toBe('plain-string');
+    expect(inferAttrKind('for')).toBe('plain-string');
+    expect(inferAttrKind('type')).toBe('plain-string');
+  });
+
+  it('is case-insensitive (HTML attribute names are case-insensitive)', () => {
+    expect(inferAttrKind('Disabled')).toBe('boolean');
+    expect(inferAttrKind('MUTED')).toBe('boolean');
+    expect(inferAttrKind('TabIndex')).toBe('numeric');
+    expect(inferAttrKind('ARIA-Hidden')).toBe('aria');
+    expect(inferAttrKind('Aria-Label')).toBe('aria');
+  });
+});
+
+describe('classifyAttribute', () => {
+  describe('absent attribute', () => {
+    it('returns absent for null/undefined attrNode', () => {
+      expect(classifyAttribute(null)).toEqual({ presence: 'absent', value: null });
+      expect(classifyAttribute(undefined)).toEqual({ presence: 'absent', value: null });
+    });
+  });
+
+  describe('valueless attribute', () => {
+    it('returns present with empty string (doc rows d1, h1)', () => {
+      expect(classifyAttribute(attr('disabled', null))).toEqual({
+        presence: 'present',
+        value: '',
+      });
+      expect(classifyAttribute(attr('aria-hidden', undefined))).toEqual({
+        presence: 'present',
+        value: '',
+      });
+    });
+  });
+
+  describe('GlimmerTextNode (static text)', () => {
+    it('returns present with literal chars (doc rows m1-m4, h2-h4, d1, i1)', () => {
+      expect(classifyAttribute(attr('aria-hidden', textNode('true')))).toEqual({
+        presence: 'present',
+        value: 'true',
+      });
+      expect(classifyAttribute(attr('autocomplete', textNode('off')))).toEqual({
+        presence: 'present',
+        value: 'off',
+      });
+      expect(classifyAttribute(attr('muted', textNode('false')))).toEqual({
+        presence: 'present',
+        value: 'false',
+      });
+    });
+  });
+
+  describe('bare-mustache {{true}} / {{false}}', () => {
+    it('{{false}} on boolean attr → absent (doc rows m6, d3)', () => {
+      expect(classifyAttribute(attr('muted', bareMustache(boolLit(false))))).toEqual({
+        presence: 'absent',
+        value: null,
+      });
+      expect(classifyAttribute(attr('disabled', bareMustache(boolLit(false))))).toEqual({
+        presence: 'absent',
+        value: null,
+      });
+    });
+
+    it('{{false}} on aria attr → absent (doc row h6)', () => {
+      expect(classifyAttribute(attr('aria-hidden', bareMustache(boolLit(false))))).toEqual({
+        presence: 'absent',
+        value: null,
+      });
+    });
+
+    it('{{false}} on numeric attr → absent (doc row t6)', () => {
+      expect(classifyAttribute(attr('tabindex', bareMustache(boolLit(false))))).toEqual({
+        presence: 'absent',
+        value: null,
+      });
+    });
+
+    it('{{false}} on plain-string attr → present "false" (doc row i4)', () => {
+      expect(classifyAttribute(attr('autocomplete', bareMustache(boolLit(false))))).toEqual({
+        presence: 'present',
+        value: 'false',
+      });
+      // role is plain-string (not aria-coerced) — bare {{false}} renders literal
+      expect(classifyAttribute(attr('role', bareMustache(boolLit(false))))).toEqual({
+        presence: 'present',
+        value: 'false',
+      });
+    });
+
+    it('{{true}} on aria attr → present "" (doc row h5: renders aria-hidden="")', () => {
+      expect(classifyAttribute(attr('aria-hidden', bareMustache(boolLit(true))))).toEqual({
+        presence: 'present',
+        value: '',
+      });
+    });
+
+    it('{{true}} on boolean → present "true" (verified m5, d2)', () => {
+      expect(classifyAttribute(attr('disabled', bareMustache(boolLit(true))))).toEqual({
+        presence: 'present',
+        value: 'true',
+      });
+      expect(classifyAttribute(attr('muted', bareMustache(boolLit(true))))).toEqual({
+        presence: 'present',
+        value: 'true',
+      });
+    });
+
+    it('{{true}} on numeric / plain-string → unknown (untested in doc)', () => {
+      expect(classifyAttribute(attr('tabindex', bareMustache(boolLit(true))))).toEqual({
+        presence: 'unknown',
+        value: null,
+      });
+      expect(classifyAttribute(attr('autocomplete', bareMustache(boolLit(true))))).toEqual({
+        presence: 'unknown',
+        value: null,
+      });
+    });
+  });
+
+  describe('bare-mustache {{null}} / {{undefined}}', () => {
+    it('{{null}} on falsy-coerced kinds → absent (doc rows m9, d6, h9, t7)', () => {
+      expect(classifyAttribute(attr('muted', bareMustache(nullLit())))).toEqual({
+        presence: 'absent',
+        value: null,
+      });
+      expect(classifyAttribute(attr('disabled', bareMustache(nullLit())))).toEqual({
+        presence: 'absent',
+        value: null,
+      });
+      expect(classifyAttribute(attr('aria-hidden', bareMustache(nullLit())))).toEqual({
+        presence: 'absent',
+        value: null,
+      });
+      expect(classifyAttribute(attr('tabindex', bareMustache(nullLit())))).toEqual({
+        presence: 'absent',
+        value: null,
+      });
+    });
+
+    it('{{undefined}} on falsy-coerced kinds → absent (doc rows m10, h10)', () => {
+      expect(classifyAttribute(attr('muted', bareMustache(undefinedLit())))).toEqual({
+        presence: 'absent',
+        value: null,
+      });
+      expect(classifyAttribute(attr('aria-hidden', bareMustache(undefinedLit())))).toEqual({
+        presence: 'absent',
+        value: null,
+      });
+    });
+
+    it('{{null}} / {{undefined}} on plain-string → unknown (untested in doc)', () => {
+      expect(classifyAttribute(attr('autocomplete', bareMustache(nullLit())))).toEqual({
+        presence: 'unknown',
+        value: null,
+      });
+      expect(classifyAttribute(attr('autocomplete', bareMustache(undefinedLit())))).toEqual({
+        presence: 'unknown',
+        value: null,
+      });
+    });
+  });
+
+  describe('bare-mustache string literal {{"x"}}', () => {
+    it('renders the literal value across all kinds (doc rows m7, m8, h7, h8, d4, d5, i2)', () => {
+      expect(classifyAttribute(attr('muted', bareMustache(stringLit('false'))))).toEqual({
+        presence: 'present',
+        value: 'false',
+      });
+      expect(classifyAttribute(attr('aria-hidden', bareMustache(stringLit('true'))))).toEqual({
+        presence: 'present',
+        value: 'true',
+      });
+      expect(classifyAttribute(attr('disabled', bareMustache(stringLit('false'))))).toEqual({
+        presence: 'present',
+        value: 'false',
+      });
+      expect(classifyAttribute(attr('autocomplete', bareMustache(stringLit('off'))))).toEqual({
+        presence: 'present',
+        value: 'off',
+      });
+    });
+
+    it('handles empty string literal {{""}} as present empty', () => {
+      // Doc row m11: <video muted={{""}}> renders <video muted=""></video>
+      expect(classifyAttribute(attr('muted', bareMustache(stringLit(''))))).toEqual({
+        presence: 'present',
+        value: '',
+      });
+    });
+  });
+
+  describe('bare-mustache number literal {{0}} / {{N}}', () => {
+    it('{{0}} on boolean attr → absent (doc row m12)', () => {
+      expect(classifyAttribute(attr('muted', bareMustache(numberLit(0))))).toEqual({
+        presence: 'absent',
+        value: null,
+      });
+    });
+
+    it('{{0}} on numeric attr → present "0" (doc row t1, focusable)', () => {
+      expect(classifyAttribute(attr('tabindex', bareMustache(numberLit(0))))).toEqual({
+        presence: 'present',
+        value: '0',
+      });
+    });
+
+    it('{{-1}} / {{1}} render as stringified value', () => {
+      expect(classifyAttribute(attr('tabindex', bareMustache(numberLit(-1))))).toEqual({
+        presence: 'present',
+        value: '-1',
+      });
+      expect(classifyAttribute(attr('tabindex', bareMustache(numberLit(1))))).toEqual({
+        presence: 'present',
+        value: '1',
+      });
+    });
+  });
+
+  describe('bare-mustache dynamic path {{this.x}}', () => {
+    it('on falsy-coerced kinds → unknown (could be falsy at runtime)', () => {
+      expect(classifyAttribute(attr('muted', bareMustache(pathExpr('this.x'))))).toEqual({
+        presence: 'unknown',
+        value: null,
+      });
+      expect(classifyAttribute(attr('aria-hidden', bareMustache(pathExpr('this.x'))))).toEqual({
+        presence: 'unknown',
+        value: null,
+      });
+      expect(classifyAttribute(attr('tabindex', bareMustache(pathExpr('this.x'))))).toEqual({
+        presence: 'unknown',
+        value: null,
+      });
+    });
+
+    it('on plain-string attr → present with unknown value', () => {
+      expect(classifyAttribute(attr('autocomplete', bareMustache(pathExpr('this.x'))))).toEqual({
+        presence: 'present',
+        value: null,
+      });
+    });
+  });
+
+  describe('GlimmerConcatStatement (concat-mustache)', () => {
+    it('"{{false}}" on boolean attr → present "true" (concat sets IDL true regardless; doc row m14)', () => {
+      // Per doc m14, <video muted="{{false}}"> sets IDL muted=true.
+      // Surface canonical "true" rather than the inner literal so callers
+      // checking `value === 'false'` for "off" don't get the wrong answer.
+      expect(classifyAttribute(attr('muted', concat([bareMustache(boolLit(false))])))).toEqual({
+        presence: 'present',
+        value: 'true',
+      });
+      expect(classifyAttribute(attr('disabled', concat([bareMustache(boolLit(false))])))).toEqual({
+        presence: 'present',
+        value: 'true',
+      });
+      expect(classifyAttribute(attr('muted', concat([bareMustache(stringLit('false'))])))).toEqual({
+        presence: 'present',
+        value: 'true',
+      });
+      expect(
+        classifyAttribute(attr('muted', concat([textNode('x'), bareMustache(boolLit(false))])))
+      ).toEqual({ presence: 'present', value: 'true' });
+    });
+
+    it('"{{false}}" on aria attr → present "false" (doc row h13, visible)', () => {
+      expect(
+        classifyAttribute(attr('aria-hidden', concat([bareMustache(boolLit(false))])))
+      ).toEqual({ presence: 'present', value: 'false' });
+    });
+
+    it('"{{true}}" on aria attr → present "true" (doc row h12, hidden)', () => {
+      expect(classifyAttribute(attr('aria-hidden', concat([bareMustache(boolLit(true))])))).toEqual(
+        { presence: 'present', value: 'true' }
+      );
+    });
+
+    it('"{{\'true\'}}" on aria → present "true" (doc row h14)', () => {
+      expect(
+        classifyAttribute(attr('aria-hidden', concat([bareMustache(stringLit('true'))])))
+      ).toEqual({ presence: 'present', value: 'true' });
+    });
+
+    it('multi-part static concat resolves the joined string', () => {
+      expect(
+        classifyAttribute(
+          attr(
+            'aria-label',
+            concat([textNode('prefix-'), bareMustache(stringLit('mid')), textNode('-suffix')])
+          )
+        )
+      ).toEqual({ presence: 'present', value: 'prefix-mid-suffix' });
+    });
+
+    it('concat with dynamic part → present, value null', () => {
+      expect(
+        classifyAttribute(
+          attr('aria-label', concat([textNode('prefix-'), bareMustache(pathExpr('this.x'))]))
+        )
+      ).toEqual({ presence: 'present', value: null });
+    });
+  });
+
+  describe('options.kind override', () => {
+    it('respects explicit kind over inferred', () => {
+      // Force aria semantics on a non-aria-prefixed attribute name
+      expect(
+        classifyAttribute(attr('myCustomAttr', bareMustache(boolLit(false))), { kind: 'aria' })
+      ).toEqual({ presence: 'absent', value: null });
+
+      // Force plain-string on a known boolean attribute
+      expect(
+        classifyAttribute(attr('disabled', bareMustache(boolLit(false))), {
+          kind: 'plain-string',
+        })
+      ).toEqual({ presence: 'present', value: 'false' });
+    });
+  });
+
+  describe('unknown AST node type', () => {
+    it('returns unknown for an unrecognized value type', () => {
+      expect(classifyAttribute(attr('foo', { type: 'GlimmerSubExpression' }))).toEqual({
+        presence: 'unknown',
+        value: null,
+      });
+    });
+
+    it('returns unknown when bare-mustache has no path', () => {
+      expect(classifyAttribute(attr('foo', bareMustache(null)))).toEqual({
+        presence: 'unknown',
+        value: null,
+      });
+    });
+  });
+});
diff --git a/tests/lib/utils/html-interactive-content-test.js b/tests/lib/utils/html-interactive-content-test.js
index da9b8cebc6..eafd81757b 100644
--- a/tests/lib/utils/html-interactive-content-test.js
+++ b/tests/lib/utils/html-interactive-content-test.js
@@ -89,6 +89,14 @@ describe('isHtmlInteractiveContent', () => {
     it('is NOT interactive without usemap', () => {
       expect(isHtmlInteractiveContent(makeNode('img'), getTextAttrValue)).toBe(false);
     });
+
+    it('is NOT interactive when usemap is present but { ignoreUsemap: true }', () => {
+      expect(
+        isHtmlInteractiveContent(makeNode('img', { usemap: '#m' }), getTextAttrValue, {
+          ignoreUsemap: true,
+        })
+      ).toBe(false);
+    });
   });
 
   describe('<audio> / <video>', () => {