diff --git a/README.md b/README.md
index 79c8cec965..657d0390c3 100644
--- a/README.md
+++ b/README.md
@@ -277,6 +277,7 @@ To disable a rule for an entire `.gjs`/`.gts` file, use a regular ESLint file-le
 | [template-no-pointer-down-event-binding](docs/rules/template-no-pointer-down-event-binding.md)                   | disallow pointer down event bindings                                             | 📋 |    |    |
 | [template-no-positive-tabindex](docs/rules/template-no-positive-tabindex.md)                                     | disallow positive tabindex values                                                | 📋 |    |    |
 | [template-no-redundant-role](docs/rules/template-no-redundant-role.md)                                           | disallow redundant role attributes                                               | 📋 | 🔧 |    |
+| [template-no-role-presentation-on-focusable](docs/rules/template-no-role-presentation-on-focusable.md)           | disallow role="presentation" / role="none" on focusable elements                 |    |    |    |
 | [template-no-unsupported-role-attributes](docs/rules/template-no-unsupported-role-attributes.md)                 | disallow ARIA attributes that are not supported by the element role              | 📋 | 🔧 |    |
 | [template-no-whitespace-within-word](docs/rules/template-no-whitespace-within-word.md)                           | disallow excess whitespace within words (e.g. "W e l c o m e")                   | 📋 |    |    |
 | [template-require-aria-activedescendant-tabindex](docs/rules/template-require-aria-activedescendant-tabindex.md) | require non-interactive elements with aria-activedescendant to have tabindex     | 📋 | 🔧 |    |
@@ -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-role-presentation-on-focusable.md b/docs/rules/template-no-role-presentation-on-focusable.md
new file mode 100644
index 0000000000..c707c30346
--- /dev/null
+++ b/docs/rules/template-no-role-presentation-on-focusable.md
@@ -0,0 +1,72 @@
+# ember/template-no-role-presentation-on-focusable
+
+<!-- end auto-generated rule header -->
+
+Disallow `role="presentation"` / `role="none"` on focusable elements.
+
+`role="presentation"` and `role="none"` are intended to strip an element's semantics from the accessibility tree. However, when applied to a focusable element, user agents are **required to ignore** the presentation role — the element's native role and semantics are preserved by the browser ([WAI-ARIA 1.2 §4.6 Conflict Resolution](https://www.w3.org/TR/wai-aria-1.2/#conflict_resolution_presentation_none)). The author's intent (remove semantics) therefore conflicts with UA behavior (keep semantics), making the attribute misleading and the markup harder to reason about.
+
+This rule flags the conflict so authors can either remove the `role` (if the native semantics are desired) or remove the focus vector (if the element genuinely should be presentational).
+
+## Examples
+
+This rule **forbids** the following:
+
+```gjs
+<template>
+  <button role="presentation">Click</button>
+  <a href="/x" role="none">Link</a>
+  <input type="text" role="presentation" />
+  <div tabindex="0" role="presentation">Focusable</div>
+  {{! tabindex="-1" is also flagged — it makes the element programmatically focusable }}
+  <div tabindex="-1" role="none">Programmatically focusable</div>
+  {{! contenteditable (including valueless / mustache-boolean forms) is focusable }}
+  <div contenteditable role="presentation">Editable</div>
+  <div contenteditable={{true}} role="presentation">Editable</div>
+</template>
+```
+
+This rule **allows** the following:
+
+```gjs
+<template>
+  {{! Presentation on non-focusable elements }}
+  <div role="presentation"></div>
+  <span role="none" class="spacer"></span>
+
+  {{! Presentation + aria-hidden — fully removed from AT }}
+  <div role="presentation" aria-hidden="true"></div>
+
+  {{! input type="hidden" isn't focusable }}
+  <input type="hidden" role="presentation" />
+</template>
+```
+
+## Focusability definition
+
+Any element with a `tabindex` attribute — including `tabindex="-1"` — is considered focusable by this rule. `tabindex="-1"` removes an element from the sequential tab order but still makes it programmatically focusable (e.g. via `element.focus()`), which is exactly the kind of focus vector that creates the semantic conflict WAI-ARIA §4.6 describes. Elements with `contenteditable` (including the valueless form `<div contenteditable>` and mustache-boolean `contenteditable={{true}}`) are also considered focusable.
+
+## Scope / Rationale
+
+This rule inspects **only the element that carries the `role="presentation"` / `role="none"`** — it does not recurse into descendants. Per [WAI-ARIA 1.2 §4.6 Conflict Resolution](https://www.w3.org/TR/wai-aria-1.2/#conflict_resolution_presentation_none) and [§5.3.3 Document Structure](https://www.w3.org/TR/wai-aria-1.2/#document_structure_roles), `role="presentation"` / `role="none"` does **not** cascade to descendants — each descendant retains its own role and semantics.
+
+As a result, wrapper patterns are **not flagged**:
+
+```gjs
+<template>
+  {{! Not flagged: the div's role is a no-op (div had no meaningful role to
+      suppress), and the button keeps its role + keyboard behavior. }}
+  <div role="presentation">
+    <button type="button">Click</button>
+  </div>
+</template>
+```
+
+This is a deliberate divergence from [eslint-plugin-vuejs-accessibility's `no-role-presentation-on-focusable`](https://github.com/vue-a11y/eslint-plugin-vuejs-accessibility/blob/main/docs/rules/no-role-presentation-on-focusable.md), which recurses into descendants and flags the wrapper case above. Vue's recursion is uncommented in their source and appears to have been copy-pasted from their `aria-hidden` rule, where descendant recursion **is** spec-correct because `aria-hidden` **does** cascade (see [`template-no-aria-hidden-on-focusable`](./template-no-aria-hidden-on-focusable.md)).
+
+## References
+
+- [WAI-ARIA 1.2 — presentation role](https://www.w3.org/TR/wai-aria-1.2/#presentation)
+- [WAI-ARIA 1.2 §4.6 — Conflict Resolution for the `presentation` / `none` roles](https://www.w3.org/TR/wai-aria-1.2/#conflict_resolution_presentation_none)
+- [WAI-ARIA 1.2 §5.3.3 — Document Structure Roles](https://www.w3.org/TR/wai-aria-1.2/#document_structure_roles)
+- [`no-role-presentation-on-focusable` — eslint-plugin-vuejs-accessibility](https://github.com/vue-a11y/eslint-plugin-vuejs-accessibility/blob/main/docs/rules/no-role-presentation-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-role-presentation-on-focusable.js b/lib/rules/template-no-role-presentation-on-focusable.js
new file mode 100644
index 0000000000..d9f4d98ac9
--- /dev/null
+++ b/lib/rules/template-no-role-presentation-on-focusable.js
@@ -0,0 +1,205 @@
+// Per WAI-ARIA 1.2 §4.6 Conflict Resolution, role="presentation" / role="none"
+// does NOT cascade to descendants — each descendant retains its own role and
+// semantics. So `<div role="presentation"><button>X</button></div>` is NOT a
+// semantic problem: the div's role is a no-op (div had no meaningful role to
+// suppress), and the button remains fully interactive with its role intact.
+//
+// Therefore, unlike the sibling rule `template-no-aria-hidden-on-focusable`
+// (which recurses into descendants because aria-hidden DOES cascade and creates
+// a keyboard trap landing on AT-hidden content), this rule only checks the
+// element carrying the presentation role.
+//
+// Deliberately diverges from vue-a11y's no-role-presentation-on-focusable, which
+// recurses into descendants. Vue's recursion is uncommented in their source and
+// appears to be a copy-paste from their aria-hidden rule.
+
+'use strict';
+
+const { isNativeElement } = require('../utils/is-native-element');
+const { classifyAttribute } = require('../utils/glimmer-attr-presence');
+
+function findAttr(node, name) {
+  return node.attributes?.find((a) => a.name === name);
+}
+
+function getTextAttrValue(node, name) {
+  const attr = findAttr(node, name);
+  if (!attr) {
+    return undefined;
+  }
+  // Valueless attribute (e.g. `<div contenteditable>`): HTML treats this as
+  // the empty string, which is truthy for contenteditable per the HTML spec.
+  if (attr.value === null) {
+    return '';
+  }
+  if (attr.value?.type === 'GlimmerTextNode') {
+    return attr.value.chars;
+  }
+  // Mustache literal: `contenteditable={{true}}` or `contenteditable={{"true"}}`
+  if (attr.value?.type === 'GlimmerMustacheStatement') {
+    const path = attr.value.path;
+    if (path?.type === 'GlimmerBooleanLiteral') {
+      return String(path.value);
+    }
+    if (path?.type === 'GlimmerStringLiteral') {
+      return path.value;
+    }
+  }
+  return undefined;
+}
+
+// Per WAI-ARIA "role" attribute semantics, when multiple whitespace-separated
+// role tokens are supplied, user agents use the FIRST valid token. Subsequent
+// tokens serve as author-provided fallbacks that only apply if the first is
+// invalid/ignored. So `role="button presentation"` resolves to "button" — the
+// element is NOT presentational. We only flag when the FIRST token is
+// presentation/none.
+function hasPresentationRole(node) {
+  const attr = findAttr(node, 'role');
+  if (!attr || attr.value?.type !== 'GlimmerTextNode') {
+    return false;
+  }
+  const tokens = attr.value.chars.trim().toLowerCase().split(/\s+/u);
+  const first = tokens[0];
+  return first === 'presentation' || first === 'none';
+}
+
+// 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.
+// Elements whose default rendering creates a focusable area per HTML §6.6.3
+// "Focusable area" + the suggested-focusable list in the `tabindex` section
+// (https://html.spec.whatwg.org/multipage/interaction.html#the-tabindex-attribute):
+//   - <button>, <select>, <textarea> — form controls
+//   - <iframe>, <embed> — navigable containers
+//   - <summary> when first child of <details> — the disclosure widget itself
+// Conditionally-focusable elements are checked elsewhere via
+// `isHtmlInteractiveContent`: <a>/<area> need `href`; <input> needs a non-Hidden
+// `type`; <audio>/<video> need `controls`; <img> needs `usemap`.
+//
+// Intentionally NOT in this set, per spec:
+//   - <details> — its disclosure focus lives on the first <summary> child, not
+//     the details element itself.
+//   - <option> — focus stays on the host <select>; option is not its own
+//     focusable area.
+//   - <datalist> — `display: none` in UA stylesheets; a hidden data provider.
+const UNCONDITIONAL_FOCUSABLE_TAGS = new Set([
+  'button',
+  'select',
+  'textarea',
+  'iframe',
+  'embed',
+  'summary',
+]);
+
+// 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;
+  }
+  // Per docs/glimmer-attribute-behavior.md (rows d3, d6), bare-mustache
+  // `disabled={{false}}` / `{{null}}` / `{{undefined}}` cause Glimmer to
+  // omit the attribute at runtime — the control is NOT disabled. Use
+  // classifyAttribute so runtime-rendered presence drives the answer.
+  return classifyAttribute(findAttr(node, 'disabled')).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) {
+  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 in scope for the semantic-conflict this rule targets.
+  // Use classifyAttribute so bare `{{false}}` / `{{null}}` / `{{undefined}}`
+  // (rows t6, t7) — which Glimmer omits — are not treated as having tabindex.
+  if (classifyAttribute(findAttr(node, 'tabindex')).presence === 'present') {
+    return true;
+  }
+
+  // contenteditable (truthy) makes the element focusable.
+  const contentEditable = getTextAttrValue(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 = getTextAttrValue(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;
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'disallow role="presentation" / role="none" on focusable elements',
+      category: 'Accessibility',
+      url: 'https://github.com/ember-cli/eslint-plugin-ember/tree/master/docs/rules/template-no-role-presentation-on-focusable.md',
+      templateMode: 'both',
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      invalidPresentation:
+        'role="presentation"/"none" must not be used on focusable elements: user agents are expected to ignore role="presentation"/"none" on focusable elements (WAI-ARIA Presentational Roles Conflict Resolution, §4.6), so the markup is misleading — remove the role or remove the focus vector.',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    return {
+      GlimmerElementNode(node) {
+        if (!isNativeElement(node, sourceCode)) {
+          return;
+        }
+        if (!hasPresentationRole(node)) {
+          return;
+        }
+        if (isKeyboardFocusable(node)) {
+          context.report({ node, messageId: 'invalidPresentation' });
+        }
+      },
+    };
+  },
+};
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-role-presentation-on-focusable.js b/tests/lib/rules/template-no-role-presentation-on-focusable.js
new file mode 100644
index 0000000000..7857a3b25c
--- /dev/null
+++ b/tests/lib/rules/template-no-role-presentation-on-focusable.js
@@ -0,0 +1,210 @@
+'use strict';
+
+const rule = require('../../../lib/rules/template-no-role-presentation-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-role-presentation-on-focusable', rule, {
+  valid: [
+    // Presentation role on non-focusable elements — fine.
+    '<template><div role="presentation"></div></template>',
+    '<template><span role="none" class="spacer"></span></template>',
+    '<template><div role="presentation" aria-hidden="true"></div></template>',
+
+    // Focusable elements without presentation role — fine.
+    '<template><button>Click me</button></template>',
+    '<template><a href="/x">Link</a></template>',
+    '<template><input type="text" /></template>',
+
+    // <input type="hidden"> isn't focusable.
+    '<template><input type="hidden" role="presentation" /></template>',
+
+    // <datalist> is a hidden data provider (display:none in UA stylesheets);
+    // its options surface inside the associated input's UA popup, not on the
+    // datalist element itself — it's not a focusable area.
+    '<template><datalist role="presentation"></datalist></template>',
+
+    // <details> itself is not a focusable area per HTML §6.6.3 — its first
+    // <summary> child is the disclosure focus target. role="presentation" on
+    // the details element does not trigger the spec's conflict resolution.
+    '<template><details role="presentation"><summary>Title</summary></details></template>',
+
+    // <option> is not its own focusable area; focus stays on the host <select>.
+    '<template><option role="presentation">Foo</option></template>',
+
+    // <a> without href isn't focusable.
+    '<template><a role="presentation">Not a link</a></template>',
+
+    // <audio>/<video> without `controls` aren't focusable — no keyboard UI.
+    '<template><video role="presentation"></video></template>',
+    '<template><audio role="presentation"></audio></template>',
+
+    // Components — rule skips (isComponentInvocation).
+    '<template><CustomBtn role="presentation" /></template>',
+    '<template><@slot role="presentation" /></template>',
+    '<template><this.widget role="presentation" /></template>',
+    '<template><foo.bar role="presentation" /></template>',
+
+    // No role at all.
+    '<template><button></button></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). role="presentation" on it is fine.
+    '<template><label role="presentation">Name</label></template>',
+
+    // Per WAI-ARIA role-fallback semantics, when multiple whitespace-separated
+    // role tokens are present, user agents use the FIRST valid token; later
+    // tokens are author-provided fallbacks. So `role="button presentation"`
+    // resolves to "button" — the element is a button, not presentational, and
+    // is NOT flagged.
+    '<template><div role="button presentation" tabindex="0">Click</div></template>',
+
+    // Disabled form controls are not keyboard-focusable (HTML §4.10.18.5).
+    '<template><button disabled role="presentation">Click</button></template>',
+    '<template><input type="text" disabled role="presentation" /></template>',
+    // Bare-mustache falsy on tabindex (rows t6, t7) — Glimmer omits at runtime,
+    // element isn't focusable from tabindex, so role="presentation" is fine.
+    '<template><div tabindex={{false}} role="presentation"></div></template>',
+    '<template><div tabindex={{null}} role="none"></div></template>',
+
+    // Non-focusable wrapper with role="presentation" around a focusable child —
+    // the rule only checks the element that carries the role, not its subtree.
+    // WAI-ARIA 1.2 §4.6 says role=presentation suppresses only the host
+    // element's implicit role and does NOT cascade to descendants.
+    // (vuejs-accessibility flags these because its rule recurses into descendants;
+    // that descent is not spec-mandated for role=presentation.)
+    '<template><div role="presentation"><button>Submit</button></div></template>',
+    '<template><div role="presentation"><a href="#">Link</a></div></template>',
+    '<template><div role="presentation"><span tabindex="0">Focusable</span></div></template>',
+  ],
+  invalid: [
+    {
+      code: '<template><button role="presentation">Click</button></template>',
+      output: null,
+      errors: [{ messageId: 'invalidPresentation' }],
+    },
+    // Bare-mustache falsy on disabled (rows d3, d6) — Glimmer omits the
+    // attribute, button stays focusable, role="presentation" is invalid.
+    {
+      code: '<template><button disabled={{false}} role="presentation">Click</button></template>',
+      output: null,
+      errors: [{ messageId: 'invalidPresentation' }],
+    },
+    {
+      code: '<template><button disabled={{null}} role="presentation">Click</button></template>',
+      output: null,
+      errors: [{ messageId: 'invalidPresentation' }],
+    },
+    {
+      code: '<template><button role="none">Click</button></template>',
+      output: null,
+      errors: [{ messageId: 'invalidPresentation' }],
+    },
+    {
+      code: '<template><a href="/x" role="presentation">Link</a></template>',
+      output: null,
+      errors: [{ messageId: 'invalidPresentation' }],
+    },
+    {
+      code: '<template><input type="text" role="presentation" /></template>',
+      output: null,
+      errors: [{ messageId: 'invalidPresentation' }],
+    },
+    // Non-interactive element made focusable via tabindex.
+    {
+      code: '<template><div tabindex="0" role="presentation"></div></template>',
+      output: null,
+      errors: [{ messageId: 'invalidPresentation' }],
+    },
+    {
+      code: '<template><div tabindex="-1" role="none"></div></template>',
+      output: null,
+      errors: [{ messageId: 'invalidPresentation' }],
+    },
+    // tabindex="-1" makes an element a programmatic focus target per HTML §6.6.3
+    // ("focusable but not sequentially focusable") — focus() works and the
+    // element remains in the a11y tree, so WAI-ARIA's Presentational Roles
+    // Conflict Resolution kicks in and the UA exposes the implicit role anyway.
+    // Rule flags the author-side anti-pattern. jsx-a11y / vue-a11y exempt
+    // tabindex="-1"; we follow the spec.
+    {
+      code: '<template><button tabindex="-1" role="presentation">Press</button></template>',
+      output: null,
+      errors: [{ messageId: 'invalidPresentation' }],
+    },
+    // <video controls> / <audio controls> — focusable per HTML-AAM / browser
+    // reality (keyboard-operable transport controls), so role="presentation"
+    // on them is a semantic conflict.
+    {
+      code: '<template><video controls role="presentation"></video></template>',
+      output: null,
+      errors: [{ messageId: 'invalidPresentation' }],
+    },
+    {
+      code: '<template><audio controls role="none"></audio></template>',
+      output: null,
+      errors: [{ messageId: 'invalidPresentation' }],
+    },
+    // <area href> — same conditional-interactive rule as <a href>.
+    {
+      code: '<template><area href="/x" role="presentation" /></template>',
+      output: null,
+      errors: [{ messageId: 'invalidPresentation' }],
+    },
+    // contenteditable — valueless form (`<div contenteditable>`).
+    {
+      code: '<template><div contenteditable role="presentation">Editable</div></template>',
+      output: null,
+      errors: [{ messageId: 'invalidPresentation' }],
+    },
+    // contenteditable — mustache boolean `{{true}}`.
+    {
+      code: '<template><div contenteditable={{true}} role="presentation">Editable</div></template>',
+      output: null,
+      errors: [{ messageId: 'invalidPresentation' }],
+    },
+    // contenteditable — mustache string `{{"true"}}`.
+    {
+      code: '<template><div contenteditable={{"true"}} role="presentation">Editable</div></template>',
+      output: null,
+      errors: [{ messageId: 'invalidPresentation' }],
+    },
+  ],
+});
+
+const hbsRuleTester = new RuleTester({
+  parser: require.resolve('ember-eslint-parser/hbs'),
+  parserOptions: { ecmaVersion: 2022, sourceType: 'module' },
+});
+
+hbsRuleTester.run('template-no-role-presentation-on-focusable', rule, {
+  valid: [
+    '<div role="presentation"></div>',
+    '<input type="hidden" role="presentation" />',
+    '<CustomBtn role="presentation" />',
+    // <video> / <audio> without controls aren't focusable.
+    '<video role="presentation"></video>',
+  ],
+  invalid: [
+    {
+      code: '<button role="presentation">Click</button>',
+      output: null,
+      errors: [{ messageId: 'invalidPresentation' }],
+    },
+    {
+      code: '<div tabindex="0" role="none"></div>',
+      output: null,
+      errors: [{ messageId: 'invalidPresentation' }],
+    },
+    {
+      code: '<video controls role="presentation"></video>',
+      output: null,
+      errors: [{ messageId: 'invalidPresentation' }],
+    },
+  ],
+});
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>', () => {