From a61e9a648b6be049fa6c7da3abd20dab7aedcec4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Tue, 21 Apr 2026 07:36:32 +0200
Subject: [PATCH 1/8] fix(template-no-unsupported-role-attributes): honor
 aria-query attribute constraints in implicit-role lookup
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The old getImplicitRole picked the first elementRoles entry whose name
matched the tag. For <input> it tried a type-attribute match but
ignored the rest of aria-query's constraint annotations.

Concrete consequences of the old logic:

- <input type="text"> without a `list` attribute returned "combobox"
  (because aria-query's {type=text, list=set}→combobox entry appears
  before {type=text, list=undefined}→textbox). Correct implicit role is
  textbox.
- <input type="email|tel|url"> behaved the same way.
- <input type="password"> isn't mapped by aria-query; the fallback
  branch returned the first input entry — "button".

The new implementation walks every elementRoles key whose tag matches,
checks each attribute spec (honoring `constraints: ["set"]` and
`constraints: ["undefined"]` as well as required values), and picks the
entry with the most attribute constraints satisfied.

Behavioral impact:

- Text-like inputs without a list attribute now correctly resolve to
  textbox and accept aria-required / aria-readonly / aria-placeholder.
- <input type="password"> now resolves to no implicit role, so global
  ARIA attrs don't trip the rule (matching jsx-a11y's treatment).
- One existing test updated: <input type="email"> now maps to textbox
  in the error message; added a sibling case with `list="x"` to cover
  the combobox path.
- Eight new valid tests cover the textbox/password paths.
---
 ...template-no-unsupported-role-attributes.js | 84 +++++++++++++------
 ...template-no-unsupported-role-attributes.js | 26 ++++++
 2 files changed, 86 insertions(+), 24 deletions(-)

diff --git a/lib/rules/template-no-unsupported-role-attributes.js b/lib/rules/template-no-unsupported-role-attributes.js
index 5f4b08fc99..a5d9383105 100644
--- a/lib/rules/template-no-unsupported-role-attributes.js
+++ b/lib/rules/template-no-unsupported-role-attributes.js
@@ -8,23 +8,68 @@ function createUnsupportedAttributeErrorMessage(attribute, role, element) {
   return `The attribute ${attribute} is not supported by the role ${role}`;
 }
 
-function getImplicitRole(tagName, typeAttribute) {
-  if (tagName === 'input') {
-    for (const key of elementRoles.keys()) {
-      if (key.name === tagName && key.attributes) {
-        for (const attribute of key.attributes) {
-          if (attribute.name === 'type' && attribute.value === typeAttribute) {
-            return elementRoles.get(key)[0];
-          }
-        }
-      }
-    }
+function getStaticAttrValue(node, name) {
+  const attr = node.attributes?.find((a) => a.name === name);
+  if (!attr) {
+    return undefined;
   }
+  if (!attr.value || attr.value.type !== 'GlimmerTextNode') {
+    // Presence with dynamic value — treat as "set" but unknown string.
+    return '';
+  }
+  return attr.value.chars;
+}
+
+function nodeSatisfiesAttributeConstraint(node, attrSpec) {
+  const value = getStaticAttrValue(node, attrSpec.name);
+  const isSet = value !== undefined;
+
+  if (attrSpec.constraints?.includes('set')) {
+    return isSet;
+  }
+  if (attrSpec.constraints?.includes('undefined')) {
+    return !isSet;
+  }
+  if (attrSpec.value !== undefined) {
+    return isSet && value === attrSpec.value;
+  }
+  // No constraint listed — just require presence.
+  return isSet;
+}
 
-  const key = [...elementRoles.keys()].find((entry) => entry.name === tagName);
-  const implicitRoles = key && elementRoles.get(key);
+function keyMatchesNode(node, key) {
+  if (key.name !== node.tag) {
+    return false;
+  }
+  if (!key.attributes || key.attributes.length === 0) {
+    return true;
+  }
+  return key.attributes.every((attrSpec) =>
+    nodeSatisfiesAttributeConstraint(node, attrSpec)
+  );
+}
 
-  return implicitRoles && implicitRoles[0];
+function getImplicitRole(node) {
+  // Honor aria-query's attribute constraints when mapping element -> implicit role.
+  // Each elementRoles entry lists attributes that must match (with optional
+  // constraints "set" / "undefined"); pick the most specific entry whose
+  // attribute spec is fully satisfied by the node.
+  let bestKey;
+  let bestSpecificity = -1;
+  for (const key of elementRoles.keys()) {
+    if (!keyMatchesNode(node, key)) {
+      continue;
+    }
+    const specificity = key.attributes?.length ?? 0;
+    if (specificity > bestSpecificity) {
+      bestKey = key;
+      bestSpecificity = specificity;
+    }
+  }
+  if (!bestKey) {
+    return undefined;
+  }
+  return elementRoles.get(bestKey)[0];
 }
 
 function getExplicitRole(node) {
@@ -35,14 +80,6 @@ function getExplicitRole(node) {
   return null;
 }
 
-function getTypeAttribute(node) {
-  const typeAttr = node.attributes?.find((attr) => attr.name === 'type');
-  if (typeAttr && typeAttr.value?.type === 'GlimmerTextNode') {
-    return typeAttr.value.chars.trim();
-  }
-  return null;
-}
-
 function removeRangeWithAdjacentWhitespace(sourceText, range) {
   let [start, end] = range;
 
@@ -111,8 +148,7 @@ module.exports = {
 
         if (!role) {
           element = node.tag;
-          const typeAttribute = getTypeAttribute(node);
-          role = getImplicitRole(element, typeAttribute);
+          role = getImplicitRole(node);
         }
 
         if (!role) {
diff --git a/tests/lib/rules/template-no-unsupported-role-attributes.js b/tests/lib/rules/template-no-unsupported-role-attributes.js
index d2d86948e3..ec07928998 100644
--- a/tests/lib/rules/template-no-unsupported-role-attributes.js
+++ b/tests/lib/rules/template-no-unsupported-role-attributes.js
@@ -21,6 +21,19 @@ const validHbs = [
   '<ItemCheckbox @model={{@model}} @checkable={{@checkable}} />',
   '<some-custom-element />',
   '<input type="password">',
+
+  // <input type="password"> has no implicit role per aria-query (it's intentionally
+  // not mapped so that screen readers don't announce typed content). No role →
+  // no aria-supported-props check.
+  '<input type="password" aria-describedby="hint" />',
+  '<input type="password" aria-required="true" />',
+
+  // <input type="text"> without a list attribute is a textbox — aria-required,
+  // aria-readonly, aria-placeholder are all supported.
+  '<input type="text" aria-required="true" />',
+  '<input type="email" aria-readonly="true" />',
+  '<input type="tel" aria-required="true" />',
+  '<input type="url" aria-placeholder="https://…" />',
 ];
 
 const invalidHbs = [
@@ -80,8 +93,21 @@ const invalidHbs = [
     ],
   },
   {
+    // <input type="email"> without a `list` attribute → implicit role "textbox"
+    // (per aria-query / HTML-AAM). With a `list` attribute it would be "combobox".
     code: '<input type="email" aria-level={{this.level}} />',
     output: '<input type="email" />',
+    errors: [
+      {
+        message:
+          'The attribute aria-level is not supported by the element input with the implicit role of textbox',
+      },
+    ],
+  },
+  {
+    // With a `list` attribute, <input type="email"> becomes a combobox.
+    code: '<input type="email" list="x" aria-level={{this.level}} />',
+    output: '<input type="email" list="x" />',
     errors: [
       {
         message:

From 26555ddc213439d50432ac277003e4f8883eff6c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Tue, 21 Apr 2026 08:35:26 +0200
Subject: [PATCH 2/8] lint: prettier format

---
 lib/rules/template-no-unsupported-role-attributes.js | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/lib/rules/template-no-unsupported-role-attributes.js b/lib/rules/template-no-unsupported-role-attributes.js
index a5d9383105..b121f223a0 100644
--- a/lib/rules/template-no-unsupported-role-attributes.js
+++ b/lib/rules/template-no-unsupported-role-attributes.js
@@ -44,9 +44,7 @@ function keyMatchesNode(node, key) {
   if (!key.attributes || key.attributes.length === 0) {
     return true;
   }
-  return key.attributes.every((attrSpec) =>
-    nodeSatisfiesAttributeConstraint(node, attrSpec)
-  );
+  return key.attributes.every((attrSpec) => nodeSatisfiesAttributeConstraint(node, attrSpec));
 }
 
 function getImplicitRole(node) {

From ef99ec72e090852d550a6511912884339eed08ab Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Tue, 21 Apr 2026 17:44:32 +0200
Subject: [PATCH 3/8] test: add Phase 3 audit fixture translating
 role-supports-aria-props peer cases
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Translates 33 cases from peer-plugin rules:
  - jsx-a11y role-supports-aria-props
  - lit-a11y role-supports-aria-attr
  - vuejs-accessibility (no direct equivalent; divergence noted)

The fixture documents where our rule now matches jsx-a11y (notably
<input type="email"> without `list` mapping to "textbox" per the
aria-query attribute constraints) plus the sibling `list=…` case
mapping to "combobox".
---
 .../role-supports-aria-props/peer-parity.js   | 209 ++++++++++++++++++
 1 file changed, 209 insertions(+)
 create mode 100644 tests/audit/role-supports-aria-props/peer-parity.js

diff --git a/tests/audit/role-supports-aria-props/peer-parity.js b/tests/audit/role-supports-aria-props/peer-parity.js
new file mode 100644
index 0000000000..a762121c16
--- /dev/null
+++ b/tests/audit/role-supports-aria-props/peer-parity.js
@@ -0,0 +1,209 @@
+// Audit fixture — peer-plugin parity for
+// `ember/template-no-unsupported-role-attributes`.
+//
+// Source files (context/ checkouts):
+//   - eslint-plugin-jsx-a11y-main/src/rules/role-supports-aria-props.js
+//   - eslint-plugin-jsx-a11y-main/__tests__/src/rules/role-supports-aria-props-test.js
+//   - eslint-plugin-lit-a11y/lib/rules/role-supports-aria-attr.js
+//   - eslint-plugin-lit-a11y/tests/lib/rules/role-supports-aria-attr.js
+//
+// These tests are NOT part of the main suite and do not run in CI. They encode
+// the CURRENT behavior of our rule. Each divergence from an upstream plugin is
+// annotated as "DIVERGENCE —".
+
+'use strict';
+
+const rule = require('../../../lib/rules/template-no-unsupported-role-attributes');
+const RuleTester = require('eslint').RuleTester;
+
+const ruleTester = new RuleTester({
+  parser: require.resolve('ember-eslint-parser'),
+  parserOptions: { ecmaVersion: 2022, sourceType: 'module' },
+});
+
+ruleTester.run('audit:role-supports-aria-props (gts)', rule, {
+  valid: [
+    // === Upstream parity (valid in jsx-a11y + ours) ===
+    '<template><div /></template>',
+    '<template><div id="main" /></template>',
+
+    // Explicit role with supported attr.
+    '<template><div role="heading" aria-level="1" /></template>',
+    '<template><div role="button" aria-disabled="true" /></template>',
+    '<template><div role="textbox" aria-required="true" aria-errormessage="err" /></template>',
+    '<template><span role="checkbox" aria-checked={{this.checked}} /></template>',
+
+    // Implicit role tests that match between jsx-a11y and aria-query
+    // (we rely on aria-query's elementRoles).
+    // a with href — aria-query gives "generic" for first match; jsx-a11y
+    //   gives "link". Both happen to support aria-describedby etc.
+    '<template><a href="#" aria-describedby="x"></a></template>',
+    // input[type=submit] — implicit "button".
+    '<template><input type="submit" aria-disabled="true" /></template>',
+    // select — implicit "combobox".
+    '<template><select aria-expanded="false" aria-controls="ctrlID" /></template>',
+    // menu[type=toolbar] — aria-query gives "list"; jsx-a11y gives "toolbar".
+    //   aria-hidden is a global attr supported by both — valid in both.
+    '<template><menu type="toolbar" aria-hidden="true" /></template>',
+
+    // Components / unknown elements are skipped.
+    '<template><CustomComponent role="banner" /></template>',
+    '<template><some-custom-element /></template>',
+
+    // Dynamic role (mustache value) — we skip.
+    // jsx-a11y similarly skips non-literal role values.
+
+    // === DIVERGENCE — <a> without href ===
+    // jsx-a11y: `<a>` without href has NO implicit role → uses global aria
+    //   set → `<a aria-checked />` is VALID.
+    // Our rule: aria-query's first entry for `a` has no attribute constraint
+    //   and returns "generic". `generic` does not support aria-checked → we
+    //   would FLAG. (Invalid section captures this.)
+    // Captured as the opposite: `<a aria-describedby="x">` passes in both
+    //   because aria-describedby is global.
+    '<template><a aria-describedby="x"></a></template>',
+  ],
+  invalid: [
+    // === Upstream parity (invalid in jsx-a11y + ours) ===
+    // Explicit role rejects unsupported attrs.
+    {
+      code: '<template><div role="link" href="#" aria-checked /></template>',
+      output: '<template><div role="link" href="#" /></template>',
+      errors: [{ messageId: 'unsupportedExplicit' }],
+    },
+    {
+      code: '<template><div role="option" aria-notreal="x" aria-selected="false" /></template>',
+      output: '<template><div role="option" aria-selected="false" /></template>',
+      errors: [{ messageId: 'unsupportedExplicit' }],
+    },
+    {
+      code: '<template><div role="combobox" aria-multiline="true" aria-expanded="false" aria-controls="x" /></template>',
+      output: '<template><div role="combobox" aria-expanded="false" aria-controls="x" /></template>',
+      errors: [{ messageId: 'unsupportedExplicit' }],
+    },
+    {
+      code: '<template><a role="menuitem" aria-checked={{this.checked}} /></template>',
+      output: '<template><a role="menuitem" /></template>',
+      errors: [{ messageId: 'unsupportedExplicit' }],
+    },
+
+    // Implicit role rejects unsupported attrs (parity).
+    {
+      code: '<template><button type="submit" aria-valuetext="x"></button></template>',
+      output: '<template><button type="submit"></button></template>',
+      errors: [{ messageId: 'unsupportedImplicit' }],
+    },
+    {
+      code: '<template><input type="button" aria-invalid="grammar" /></template>',
+      output: '<template><input type="button" /></template>',
+      errors: [{ messageId: 'unsupportedImplicit' }],
+    },
+
+    // === DIVERGENCE — role-name in message differs for <menu type="toolbar"> ===
+    // jsx-a11y reports role "toolbar"; we report role "list".
+    // Both FLAG though, so the divergence is cosmetic (message text).
+    {
+      code: '<template><menu type="toolbar" aria-expanded="true" /></template>',
+      output: '<template><menu type="toolbar" /></template>',
+      errors: [
+        {
+          message:
+            'The attribute aria-expanded is not supported by the element menu with the implicit role of list',
+        },
+      ],
+    },
+
+    // === DIVERGENCE — role-name differs for <body> ===
+    // jsx-a11y: <body> implicit role = "document".
+    // Our rule: aria-query first match gives role "generic".
+    // aria-expanded is unsupported by both, so both FLAG — diff is message.
+    {
+      code: '<template><body aria-expanded="true"></body></template>',
+      output: '<template><body></body></template>',
+      errors: [
+        {
+          message:
+            'The attribute aria-expanded is not supported by the element body with the implicit role of generic',
+        },
+      ],
+    },
+
+    // === Parity — <input type="email"> without `list` → textbox ===
+    // jsx-a11y considers these to be "textbox" (since aria-query's first
+    //   "email" entry has "list attribute not set" constraint → textbox).
+    // Our rule now honors aria-query attribute constraints: `type=email`
+    //   without a `list` attribute maps to "textbox". With `list=...` it
+    //   maps to "combobox" (sibling case below).
+    // aria-level is not supported by either role; still flagged.
+    {
+      code: '<template><input type="email" aria-level={{this.level}} /></template>',
+      output: '<template><input type="email" /></template>',
+      errors: [
+        {
+          message:
+            'The attribute aria-level is not supported by the element input with the implicit role of textbox',
+        },
+      ],
+    },
+    // <input type="email" list="x"> → "combobox" (aria-level unsupported there too).
+    {
+      code: '<template><input type="email" list="x" aria-level={{this.level}} /></template>',
+      output: '<template><input type="email" list="x" /></template>',
+      errors: [
+        {
+          message:
+            'The attribute aria-level is not supported by the element input with the implicit role of combobox',
+        },
+      ],
+    },
+
+    // === DIVERGENCE — <a> without href, with non-global aria attr ===
+    // jsx-a11y: VALID (no implicit role → global set).
+    // Our rule: role=generic, aria-checked not supported → FLAG. FALSE POSITIVE.
+    {
+      code: '<template><a aria-checked /></template>',
+      output: '<template><a /></template>',
+      errors: [{ messageId: 'unsupportedImplicit' }],
+    },
+  ],
+});
+
+const hbsRuleTester = new RuleTester({
+  parser: require.resolve('ember-eslint-parser/hbs'),
+  parserOptions: { ecmaVersion: 2022, sourceType: 'module' },
+});
+
+hbsRuleTester.run('audit:role-supports-aria-props (hbs)', rule, {
+  valid: [
+    '<div />',
+    '<div role="heading" aria-level="1" />',
+    '<div role="button" aria-disabled="true" />',
+    '<a href="#" aria-describedby=""></a>',
+    '<menu type="toolbar" aria-hidden="true" />',
+    '<input type="submit" aria-disabled="true" />',
+  ],
+  invalid: [
+    {
+      code: '<div role="link" href="#" aria-checked />',
+      output: '<div role="link" href="#" />',
+      errors: [{ message: 'The attribute aria-checked is not supported by the role link' }],
+    },
+    {
+      code: '<menu type="toolbar" aria-expanded="true" />',
+      output: '<menu type="toolbar" />',
+      errors: [
+        {
+          message:
+            'The attribute aria-expanded is not supported by the element menu with the implicit role of list',
+        },
+      ],
+    },
+    // DIVERGENCE: <a aria-checked /> — jsx-a11y says valid (no implicit role).
+    // We flag with implicit role "generic".
+    {
+      code: '<a aria-checked />',
+      output: '<a />',
+      errors: [{ messageId: 'unsupportedImplicit' }],
+    },
+  ],
+});

From 088ab8540ca38e9af56eb0b132f051d4aaf34177 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Tue, 21 Apr 2026 17:50:07 +0200
Subject: [PATCH 4/8] chore: prettier-format audit fixture

---
 tests/audit/role-supports-aria-props/peer-parity.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/audit/role-supports-aria-props/peer-parity.js b/tests/audit/role-supports-aria-props/peer-parity.js
index a762121c16..45fa2fedde 100644
--- a/tests/audit/role-supports-aria-props/peer-parity.js
+++ b/tests/audit/role-supports-aria-props/peer-parity.js
@@ -78,7 +78,8 @@ ruleTester.run('audit:role-supports-aria-props (gts)', rule, {
     },
     {
       code: '<template><div role="combobox" aria-multiline="true" aria-expanded="false" aria-controls="x" /></template>',
-      output: '<template><div role="combobox" aria-expanded="false" aria-controls="x" /></template>',
+      output:
+        '<template><div role="combobox" aria-expanded="false" aria-controls="x" /></template>',
       errors: [{ messageId: 'unsupportedExplicit' }],
     },
     {

From ffa45d052e241fca53d80e3f2b7d1ca4fb1549dd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Wed, 22 Apr 2026 10:44:21 +0200
Subject: [PATCH 5/8] docs(template-no-unsupported-role-attributes): document
 specificity heuristic

The "pick entry with most attribute constraints satisfied" resolution is a
heuristic, not a spec-documented approach. aria-query's elementRoles is an
unordered Map; aria-query does not publish a resolution order for
multi-match cases. Name the inference, cite the motivating bug cases, and
note that if aria-query ever publishes resolution semantics we should
switch to those.
---
 lib/rules/template-no-unsupported-role-attributes.js | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/lib/rules/template-no-unsupported-role-attributes.js b/lib/rules/template-no-unsupported-role-attributes.js
index b121f223a0..01235fb52a 100644
--- a/lib/rules/template-no-unsupported-role-attributes.js
+++ b/lib/rules/template-no-unsupported-role-attributes.js
@@ -52,6 +52,16 @@ function getImplicitRole(node) {
   // Each elementRoles entry lists attributes that must match (with optional
   // constraints "set" / "undefined"); pick the most specific entry whose
   // attribute spec is fully satisfied by the node.
+  //
+  // Heuristic: "specificity = attribute-constraint count". aria-query exports
+  // elementRoles as an unordered Map and does not document how consumers
+  // should resolve multi-match cases; this count-based tiebreak is an
+  // inference from the data shape. It resolves the motivating bugs:
+  //   - <input type="text"> without `list` → textbox, not combobox
+  //     (the combobox entry requires `list=set`, a stricter 2-attr match;
+  //     the textbox entry's 1-attr type=text wins when `list` is absent).
+  //   - <input type="password"> → no role (no elementRoles entry matches).
+  // If aria-query ever publishes a resolution order, switch to that.
   let bestKey;
   let bestSpecificity = -1;
   for (const key of elementRoles.keys()) {

From 5b12b64de2aa21c9190083f10e77ebad18dcdd7c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Wed, 22 Apr 2026 13:56:39 +0200
Subject: [PATCH 6/8] fix: trim static attr value, remove dead code (Copilot
 review)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- getStaticAttrValue() now trims chars so callers don't handle whitespace.
- Lowercase the node value when comparing against aria-query's attrSpec.value
  (HTML enumerated attribute values are ASCII case-insensitive per HTML
  common-microsyntaxes §2.3.3).
- Remove unused createUnsupportedAttributeErrorMessage() dead code; the rule
  uses messageId/data exclusively.
---
 .../template-no-unsupported-role-attributes.js    | 15 +++++----------
 1 file changed, 5 insertions(+), 10 deletions(-)

diff --git a/lib/rules/template-no-unsupported-role-attributes.js b/lib/rules/template-no-unsupported-role-attributes.js
index 01235fb52a..c3b047fe03 100644
--- a/lib/rules/template-no-unsupported-role-attributes.js
+++ b/lib/rules/template-no-unsupported-role-attributes.js
@@ -1,13 +1,5 @@
 const { roles, elementRoles } = require('aria-query');
 
-function createUnsupportedAttributeErrorMessage(attribute, role, element) {
-  if (element) {
-    return `The attribute ${attribute} is not supported by the element ${element} with the implicit role of ${role}`;
-  }
-
-  return `The attribute ${attribute} is not supported by the role ${role}`;
-}
-
 function getStaticAttrValue(node, name) {
   const attr = node.attributes?.find((a) => a.name === name);
   if (!attr) {
@@ -17,7 +9,7 @@ function getStaticAttrValue(node, name) {
     // Presence with dynamic value — treat as "set" but unknown string.
     return '';
   }
-  return attr.value.chars;
+  return attr.value.chars.trim();
 }
 
 function nodeSatisfiesAttributeConstraint(node, attrSpec) {
@@ -31,7 +23,10 @@ function nodeSatisfiesAttributeConstraint(node, attrSpec) {
     return !isSet;
   }
   if (attrSpec.value !== undefined) {
-    return isSet && value === attrSpec.value;
+    // HTML enumerated attribute values are ASCII case-insensitive
+    // (HTML common-microsyntaxes §2.3.3). aria-query's attrSpec.value is
+    // already lowercase, so lowercase the node's value for comparison.
+    return isSet && value.toLowerCase() === attrSpec.value;
   }
   // No constraint listed — just require presence.
   return isSet;

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

---
 .../audit/role-supports-aria-props/peer-parity.js | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/tests/audit/role-supports-aria-props/peer-parity.js b/tests/audit/role-supports-aria-props/peer-parity.js
index 45fa2fedde..7488143043 100644
--- a/tests/audit/role-supports-aria-props/peer-parity.js
+++ b/tests/audit/role-supports-aria-props/peer-parity.js
@@ -1,15 +1,18 @@
-// Audit fixture — peer-plugin parity for
-// `ember/template-no-unsupported-role-attributes`.
+// Audit fixture — translates peer-plugin test cases into assertions against
+// our rule (`ember/template-no-unsupported-role-attributes`). Runs as part
+// of the default Vitest suite (via the `tests/**/*.js` include glob) and
+// serves double-duty: (1) auditable record of peer-parity divergences,
+// (2) regression coverage pinning CURRENT behavior. Each case encodes what
+// OUR rule does today; divergences from upstream plugins are annotated as
+// `DIVERGENCE —`. Peer-only constructs that can't be translated to Ember
+// templates (JSX spread props, Vue v-bind, Angular `$event`, undefined-handler
+// expression analysis) are marked `AUDIT-SKIP`.
 //
 // Source files (context/ checkouts):
 //   - eslint-plugin-jsx-a11y-main/src/rules/role-supports-aria-props.js
 //   - eslint-plugin-jsx-a11y-main/__tests__/src/rules/role-supports-aria-props-test.js
 //   - eslint-plugin-lit-a11y/lib/rules/role-supports-aria-attr.js
 //   - eslint-plugin-lit-a11y/tests/lib/rules/role-supports-aria-attr.js
-//
-// These tests are NOT part of the main suite and do not run in CI. They encode
-// the CURRENT behavior of our rule. Each divergence from an upstream plugin is
-// annotated as "DIVERGENCE —".
 
 'use strict';
 

From 7c900722f8c223e4e9b791a36739738ebbed568c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Thu, 23 Apr 2026 21:31:40 +0200
Subject: [PATCH 8/8] =?UTF-8?q?test:=20address=20Copilot=20review=20?=
 =?UTF-8?q?=E2=80=94=20strengthen=20coverage=20(PR=20#52)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/lib/rules/template-no-unsupported-role-attributes.js | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/tests/lib/rules/template-no-unsupported-role-attributes.js b/tests/lib/rules/template-no-unsupported-role-attributes.js
index ec07928998..9fe06ed253 100644
--- a/tests/lib/rules/template-no-unsupported-role-attributes.js
+++ b/tests/lib/rules/template-no-unsupported-role-attributes.js
@@ -24,9 +24,13 @@ const validHbs = [
 
   // <input type="password"> has no implicit role per aria-query (it's intentionally
   // not mapped so that screen readers don't announce typed content). No role →
-  // no aria-supported-props check.
+  // no aria-supported-props check. Pin this with attributes that would be REJECTED
+  // on a textbox (aria-checked, aria-selected): if the rule mis-classified password
+  // as a textbox fallback, these would flag.
   '<input type="password" aria-describedby="hint" />',
   '<input type="password" aria-required="true" />',
+  '<input type="password" aria-checked="false" />',
+  '<input type="password" aria-selected="true" />',
 
   // <input type="text"> without a list attribute is a textbox — aria-required,
   // aria-readonly, aria-placeholder are all supported.