From 167c720632e253772d8a270f24be4ea7ee526b78 Mon Sep 17 00:00:00 2001
From: pooya-si <pahm@siteimprove.com>
Date: Mon, 14 Sep 2026 15:40:06 -0400
Subject: [PATCH 01/10] [A11Y-12317] Add SIA-R119.

Check that <ul>, <ol> and <dl> elements only contain the children the HTML
content model allows, following the specification rather than a relaxed
reading of it: a <dl> wraps every name-value group or none of them, a <div>
inside a <dl> holds exactly one group, every group must be well formed, and
children are matched by element name rather than by role.
---
 .changeset/brave-lists-gather.md              |  29 ++
 packages/alfa-rules/src/rules.ts              |   2 +
 packages/alfa-rules/src/sia-r119/rule.ts      | 193 +++++++
 packages/alfa-rules/src/tsconfig.json         |   1 +
 .../alfa-rules/test/sia-r119/rule.spec.tsx    | 472 ++++++++++++++++++
 packages/alfa-rules/test/tsconfig.json        |   3 +-
 6 files changed, 699 insertions(+), 1 deletion(-)
 create mode 100644 .changeset/brave-lists-gather.md
 create mode 100644 packages/alfa-rules/src/sia-r119/rule.ts
 create mode 100644 packages/alfa-rules/test/sia-r119/rule.spec.tsx
diff --git a/.changeset/brave-lists-gather.md b/.changeset/brave-lists-gather.md
new file mode 100644
index 0000000000..49a570fdb5
--- /dev/null
+++ b/.changeset/brave-lists-gather.md
@@ -0,0 +1,29 @@
+---
+"@siteimprove/alfa-rules": minor
+---
+
+**Added:** The new rule R119 checks that `<ul>`, `<ol>` and `<dl>` elements only contain the children allowed by the HTML content model.
+
+The rule follows the content model as the HTML specification states it, rather than a relaxed reading of it:
+
+- A `<dl>` either wraps every name-value group in a `<div>` or wraps none of them. The two forms cannot be mixed in one list.
+- A `<div>` inside a `<dl>` holds exactly one group. Its content model is one or more `<dt>` elements followed by one or more `<dd>` elements, so packing a second group into the same wrapper is reported and each group needs its own.
+- Every group must be well formed, not only the first, so a trailing `<dt>` with no `<dd>` of its own is reported.
+- Children are matched by element name rather than by role, so a `<div role="listitem">` does not satisfy a content model asking for an `<li>`. See the [`listitem` role best practices](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Reference/Roles/listitem_role#best_practices). Pasting the following into <https://validator.w3.org/nu> reports `Element "div" not allowed as child of element "ul" in this context`:
+
+  ```html
+  <!DOCTYPE html>
+  <html lang="en">
+    <head>
+      <meta charset="utf-8" />
+      <title>List content model check</title>
+    </head>
+    <body>
+      <ul>
+        <div role="listitem">List item 1</div>
+        <div role="listitem">List item 2</div>
+      </ul>
+    </body>
+  </html>
+  ```
+  
diff --git a/packages/alfa-rules/src/rules.ts b/packages/alfa-rules/src/rules.ts
index ede4741e9a..253cbdc7d7 100644
--- a/packages/alfa-rules/src/rules.ts
+++ b/packages/alfa-rules/src/rules.ts
@@ -87,6 +87,7 @@ import R110 from "./sia-r110/rule.ts";
 import R111 from "./sia-r111/rule.ts";
 import R113 from "./sia-r113/rule.ts";
 import R116 from "./sia-r116/rule.ts";
+import R119 from "./sia-r119/rule.ts";
 
 export {
   R1,
@@ -178,4 +179,5 @@ export {
   R111,
   R113,
   R116,
+  R119,
 };
diff --git a/packages/alfa-rules/src/sia-r119/rule.ts b/packages/alfa-rules/src/sia-r119/rule.ts
new file mode 100644
index 0000000000..f90556a31b
--- /dev/null
+++ b/packages/alfa-rules/src/sia-r119/rule.ts
@@ -0,0 +1,193 @@
+import { Diagnostic, Rule } from "@siteimprove/alfa-act";
+import { Element, Namespace, Node, Query, Text } from "@siteimprove/alfa-dom";
+import { EAA } from "@siteimprove/alfa-eaa";
+import { Refinement } from "@siteimprove/alfa-refinement";
+import type { Result } from "@siteimprove/alfa-result";
+import { Err, Ok } from "@siteimprove/alfa-result";
+import type { Sequence } from "@siteimprove/alfa-sequence";
+import { String } from "@siteimprove/alfa-string";
+import { Style } from "@siteimprove/alfa-style";
+import { Criterion } from "@siteimprove/alfa-wcag";
+import type { Page } from "@siteimprove/alfa-web";
+
+import { expectation } from "../common/act/index.ts";
+import { WithBadElements } from "../common/diagnostic/with-bad-elements.ts";
+
+import { Scope, Stability } from "../tags/index.ts";
+
+const { hasName, hasNamespace, isElement } = Element;
+const { and } = Refinement;
+const { isRendered } = Style;
+const { isText } = Text;
+const { getElementDescendants } = Query;
+
+/**
+ * This rule checks that `<ul>`, `<ol>` and `<dl>` elements only contain the
+ * children the HTML content model allows.
+ *
+ * Four readings of that content model are deliberate, and each one makes the
+ * rule stricter than a relaxed reading would:
+ *
+ * - A `<dl>` wraps every name-value group in a `<div>` or wraps none of them.
+ * - A `<div>` inside a `<dl>` holds exactly one group, so a second group packed
+ *   into the same wrapper is reported.
+ * - Every group must be well formed, not only the first, so a trailing `<dt>`
+ *   with no `<dd>` is reported.
+ * - Children are matched by element name, so a `<div role="listitem">` does not
+ *   satisfy a content model asking for an `<li>`.
+ *
+ * {@link https://html.spec.whatwg.org/multipage/grouping-content.html#the-dl-element}
+ */
+export default Rule.Atomic.of<Page, Element>({
+  uri: "https://alfa.siteimprove.com/rules/sia-r119",
+  requirements: [Criterion.of("1.3.1"), EAA.of("9.1.3.1")],
+  tags: [Scope.Component, Stability.Stable],
+  evaluate({ device, document }) {
+    return {
+      applicability() {
+        return getElementDescendants(document, Node.fullTree).filter(
+          and(
+            hasNamespace(Namespace.HTML),
+            and(hasName("ul", "ol", "dl"), isRendered(device)),
+          ),
+        );
+      },
+
+      expectations(target) {
+        return {
+          1: expectation(
+            hasTextContent(target),
+            () => Outcomes.HasDisallowedText,
+            () =>
+              expectation(
+                hasName("dl")(target),
+                () => descriptionListContent(target),
+                () => listContent(target),
+              ),
+          ),
+        };
+      },
+    };
+  },
+});
+
+const isScriptSupporting = hasName("script", "template");
+
+function elementChildren(element: Element): Sequence<Element> {
+  return element
+    .children(Node.fullTree)
+    .filter(isElement)
+    .reject(isScriptSupporting);
+}
+
+function hasTextContent(element: Element): boolean {
+  return element
+    .children(Node.fullTree)
+    .filter(isText)
+    .some((text) => !String.isWhitespace(text.data));
+}
+
+function listContent(target: Element): Result<Diagnostic> {
+  const disallowed = elementChildren(target).reject(hasName("li"));
+
+  return disallowed.isEmpty()
+    ? Outcomes.HasValidContent
+    : Outcomes.HasDisallowedElements(disallowed);
+}
+
+function descriptionListContent(target: Element): Result<Diagnostic> {
+  const children = elementChildren(target);
+  const disallowed = children.reject(hasName("div", "dt", "dd"));
+
+  if (!disallowed.isEmpty()) {
+    return Outcomes.HasDisallowedElements(disallowed);
+  }
+
+  const wrappers = children.filter(hasName("div"));
+  const items = children.filter(hasName("dt", "dd"));
+
+  if (!wrappers.isEmpty()) {
+    if (!items.isEmpty()) {
+      return Outcomes.HasMixedGroups(items);
+    }
+
+    const malformed = wrappers.reject(isWellFormedGroup);
+
+    return malformed.isEmpty()
+      ? Outcomes.HasValidContent
+      : Outcomes.HasMalformedGroups(malformed);
+  }
+
+  const ungrouped = ungroupedItems(items);
+
+  return ungrouped.isEmpty()
+    ? Outcomes.HasValidContent
+    : Outcomes.HasMalformedGroups(ungrouped);
+}
+
+function isWellFormedGroup(wrapper: Element): boolean {
+  if (hasTextContent(wrapper)) {
+    return false;
+  }
+
+  const children = elementChildren(wrapper);
+
+  if (!children.reject(hasName("dt", "dd")).isEmpty()) {
+    return false;
+  }
+
+  const terms = children.takeWhile(hasName("dt"));
+  const descriptions = children.skip(terms.size);
+
+  return (
+    !terms.isEmpty() &&
+    !descriptions.isEmpty() &&
+    descriptions.every(hasName("dd"))
+  );
+}
+
+function ungroupedItems(items: Sequence<Element>): Sequence<Element> {
+  const leadingDescriptions: Sequence<Element> = items.takeWhile(hasName("dd"));
+  const trailingTerms = items.takeLastWhile(hasName("dt"));
+
+  return leadingDescriptions.concat(trailingTerms);
+}
+
+/**
+ * @public
+ */
+export namespace Outcomes {
+  export const HasValidContent = Ok.of(
+    Diagnostic.of(
+      `The element only contains the content allowed by its content model.`,
+    ),
+  );
+
+  export const HasDisallowedText = Err.of(
+    Diagnostic.of(`The element contains text outside of any list item.`),
+  );
+
+  export const HasDisallowedElements = (errors: Iterable<Element>) =>
+    Err.of(
+      WithBadElements.of(
+        `The element contains child elements that its content model does not allow.`,
+        errors,
+      ),
+    );
+
+  export const HasMixedGroups = (errors: Iterable<Element>) =>
+    Err.of(
+      WithBadElements.of(
+        `The <dl> element mixes name-value groups wrapped in a <div> with groups that are not wrapped.`,
+        errors,
+      ),
+    );
+
+  export const HasMalformedGroups = (errors: Iterable<Element>) =>
+    Err.of(
+      WithBadElements.of(
+        `The <dl> element contains a name-value group that is not one or more <dt> elements followed by one or more <dd> elements.`,
+        errors,
+      ),
+    );
+}
diff --git a/packages/alfa-rules/src/tsconfig.json b/packages/alfa-rules/src/tsconfig.json
index ba0cf4a786..a9ec491b73 100644
--- a/packages/alfa-rules/src/tsconfig.json
+++ b/packages/alfa-rules/src/tsconfig.json
@@ -165,6 +165,7 @@
     "./sia-r116/rule.ts",
     "./sia-r117/rule.ts",
     "./sia-r118/rule.ts",
+    "./sia-r119/rule.ts",
     "./tags/index.ts",
     "./tags/stability.ts",
     "./tags/scope.ts",
diff --git a/packages/alfa-rules/test/sia-r119/rule.spec.tsx b/packages/alfa-rules/test/sia-r119/rule.spec.tsx
new file mode 100644
index 0000000000..41e77c23dd
--- /dev/null
+++ b/packages/alfa-rules/test/sia-r119/rule.spec.tsx
@@ -0,0 +1,472 @@
+import { h } from "@siteimprove/alfa-dom";
+import { test } from "@siteimprove/alfa-test";
+
+import R119, { Outcomes } from "../../src/sia-r119/rule.ts";
+
+import { evaluate } from "../common/evaluate.ts";
+import { failed, inapplicable, passed } from "../common/outcome.ts";
+
+/* <ul> and <ol> */
+
+test(`evaluate() passes a <ul> whose children are all <li>`, async (t) => {
+  const target = (
+    <ul>
+      <li>Foo</li>
+      <li>Bar</li>
+    </ul>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() passes an <ol> that intermixes script-supporting elements`, async (t) => {
+  const target = (
+    <ol>
+      <script>{"const foo = 1;"}</script>
+      <li>Foo</li>
+      <template></template>
+    </ol>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() passes an empty <ul>`, async (t) => {
+  const target = <ul></ul>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() fails a <ul> with a <div> child`, async (t) => {
+  const error = <div>Foo</div>;
+
+  const target = <ul>{error}</ul>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, {
+      1: Outcomes.HasDisallowedElements([error]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a <ul> containing text outside of a list item`, async (t) => {
+  const target = (
+    <ul>
+      Foo
+      <li>Bar</li>
+    </ul>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, { 1: Outcomes.HasDisallowedText }),
+  ]);
+});
+
+test(`evaluate() fails a <ul> whose items carry the listitem role without being <li>`, async (t) => {
+  const error = <div role="listitem">Foo</div>;
+
+  const target = <ul role="list">{error}</ul>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, {
+      1: Outcomes.HasDisallowedElements([error]),
+    }),
+  ]);
+});
+
+/* <dl> with groups written out directly */
+
+test(`evaluate() passes a <dl> with a single name-value group`, async (t) => {
+  const target = (
+    <dl>
+      <dt>Foo</dt>
+      <dd>Bar</dd>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() passes a <dl> with several names and values per group`, async (t) => {
+  const target = (
+    <dl>
+      <dt>Foo</dt>
+      <dt>Bar</dt>
+      <dd>Baz</dd>
+      <dd>Qux</dd>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() passes a <dl> with consecutive name-value groups`, async (t) => {
+  const target = (
+    <dl>
+      <dt>Foo</dt>
+      <dd>Bar</dd>
+      <dt>Baz</dt>
+      <dd>Qux</dd>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() passes an empty <dl>`, async (t) => {
+  const target = <dl></dl>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() passes a <dl> that intermixes script-supporting elements`, async (t) => {
+  const target = (
+    <dl>
+      <script>{"const foo = 1;"}</script>
+      <dt>Foo</dt>
+      <script>{"const bar = 2;"}</script>
+      <dd>Bar</dd>
+      <template></template>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() passes a <dl> that contains only script-supporting elements`, async (t) => {
+  const target = (
+    <dl>
+      <script>{"const foo = 1;"}</script>
+      <template></template>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() fails a <dl> with a description without a term`, async (t) => {
+  const error = <dd>Foo</dd>;
+
+  const target = (
+    <dl>
+      {error}
+      <dt>Bar</dt>
+      <dd>Baz</dd>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, {
+      1: Outcomes.HasMalformedGroups([error]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a <dl> with a trailing term that is given no description`, async (t) => {
+  const error = <dt>Baz</dt>;
+
+  const target = (
+    <dl>
+      <dt>Foo</dt>
+      <dd>Bar</dd>
+      {error}
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, {
+      1: Outcomes.HasMalformedGroups([error]),
+    }),
+  ]);
+});
+
+test(`every malformed group in a <dl> is evaluated, not only the first`, async (t) => {
+  const first = <dd>Foo</dd>;
+  const last = <dt>Qux</dt>;
+
+  const target = (
+    <dl>
+      {first}
+      <dt>Bar</dt>
+      <dd>Baz</dd>
+      {last}
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, {
+      1: Outcomes.HasMalformedGroups([first, last]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a <dl> with a child that is neither <dt>, <dd> nor <div>`, async (t) => {
+  const error = <p>Foo</p>;
+
+  const target = (
+    <dl>
+      {error}
+      <dt>Bar</dt>
+      <dd>Baz</dd>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, {
+      1: Outcomes.HasDisallowedElements([error]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a <dl> containing text outside of a name or value`, async (t) => {
+  const target = (
+    <dl>
+      Foo
+      <dt>Bar</dt>
+      <dd>Baz</dd>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, { 1: Outcomes.HasDisallowedText }),
+  ]);
+});
+
+/* <dl> with groups wrapped in <div> */
+
+test(`evaluate() passes a <dl> whose groups are each wrapped in a <div>`, async (t) => {
+  const target = (
+    <dl>
+      <div>
+        <dt>Foo</dt>
+        <dd>Bar</dd>
+      </div>
+      <div>
+        <dt>Baz</dt>
+        <dd>Qux</dd>
+      </div>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() passes a <dl> with a script-supporting element between wrappers`, async (t) => {
+  const target = (
+    <dl>
+      <div>
+        <dt>Foo</dt>
+        <dd>Bar</dd>
+      </div>
+      <script>{"const foo = 1;"}</script>
+      <div>
+        <dt>Baz</dt>
+        <dd>Qux</dd>
+      </div>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() passes a <dl> with a script-supporting element inside a wrapper`, async (t) => {
+  const target = (
+    <dl>
+      <div>
+        <dt>Foo</dt>
+        <script>{"const foo = 1;"}</script>
+        <dd>Bar</dd>
+      </div>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() fails a <dl> that mixes wrapped and unwrapped groups`, async (t) => {
+  const name = <dt>Baz</dt>;
+  const value = <dd>Qux</dd>;
+
+  const target = (
+    <dl>
+      <div>
+        <dt>Foo</dt>
+        <dd>Bar</dd>
+      </div>
+      {name}
+      {value}
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, {
+      1: Outcomes.HasMixedGroups([name, value]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a <dl> with a wrapper that holds a name and no value`, async (t) => {
+  const error = (
+    <div>
+      <dt>Foo</dt>
+    </div>
+  );
+
+  const target = <dl>{error}</dl>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, {
+      1: Outcomes.HasMalformedGroups([error]),
+    }),
+  ]);
+});
+
+test(`a <dl> with a wrapper with wrong order of elements`, async (t) => {
+  const error = (
+    <div>
+      <dd>Foo</dd>
+      <dt>Bar</dt>
+    </div>
+  );
+
+  const target = <dl>{error}</dl>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, {
+      1: Outcomes.HasMalformedGroups([error]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a <dl> with a wrapper that holds more than one group`, async (t) => {
+  const error = (
+    <div>
+      <dt>Foo</dt>
+      <dd>Bar</dd>
+      <dt>Baz</dt>
+      <dd>Qux</dd>
+    </div>
+  );
+
+  const target = <dl>{error}</dl>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, {
+      1: Outcomes.HasMalformedGroups([error]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a <dl> with a wrapper that holds a disallowed element`, async (t) => {
+  const error = (
+    <div>
+      <dt>Foo</dt>
+      <dd>Bar</dd>
+      <p>Baz</p>
+    </div>
+  );
+
+  const target = <dl>{error}</dl>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, {
+      1: Outcomes.HasMalformedGroups([error]),
+    }),
+  ]);
+});
+
+/* Applicability */
+
+test(`evaluate() is inapplicable to a document with no list`, async (t) => {
+  const document = h.document([
+    <div>
+      <p>Foo</p>
+    </div>,
+  ]);
+
+  t.deepEqual(await evaluate(R119, { document }), [inapplicable(R119)]);
+});
+
+test(`evaluate() is inapplicable to a list that is not rendered`, async (t) => {
+  const document = h.document([
+    <ul style={{ display: "none" }}>
+      <div>Foo</div>
+    </ul>,
+  ]);
+
+  t.deepEqual(await evaluate(R119, { document }), [inapplicable(R119)]);
+});
diff --git a/packages/alfa-rules/test/tsconfig.json b/packages/alfa-rules/test/tsconfig.json
index 35a68c388a..5612de8902 100644
--- a/packages/alfa-rules/test/tsconfig.json
+++ b/packages/alfa-rules/test/tsconfig.json
@@ -123,7 +123,8 @@
     "./sia-r115/rule.spec.tsx",
     "./sia-r116/rule.spec.tsx",
     "./sia-r117/rule.spec.tsx",
-    "./sia-r118/rule.spec.tsx"
+    "./sia-r118/rule.spec.tsx",
+    "./sia-r119/rule.spec.tsx"
   ],
   "references": [
     { "path": "../src" },

From 7664506a5e7919ac276d25bb03a6ea34ba0c41e1 Mon Sep 17 00:00:00 2001
From: pooya-si <pahm@siteimprove.com>
Date: Mon, 14 Sep 2026 18:52:51 -0400
Subject: [PATCH 02/10] [11Y-12317] Update based on code review.

---
 packages/alfa-rules/src/sia-r119/rule.ts      | 14 +++++++++-----
 .../alfa-rules/test/sia-r119/rule.spec.tsx    | 19 ++++++++++++++++++-
 2 files changed, 27 insertions(+), 6 deletions(-)

diff --git a/packages/alfa-rules/src/sia-r119/rule.ts b/packages/alfa-rules/src/sia-r119/rule.ts
index f90556a31b..c85fa13cd4 100644
--- a/packages/alfa-rules/src/sia-r119/rule.ts
+++ b/packages/alfa-rules/src/sia-r119/rule.ts
@@ -71,11 +71,15 @@ export default Rule.Atomic.of<Page, Element>({
   },
 });
 
-const isScriptSupporting = hasName("script", "template");
+function hasHtmlName<N extends string>(name: N, ...rest: Array<N>) {
+  return and(hasNamespace(Namespace.HTML), hasName(name, ...rest));
+}
+
+const isScriptSupporting = hasHtmlName("script", "template");
 
 function elementChildren(element: Element): Sequence<Element> {
   return element
-    .children(Node.fullTree)
+    .children()
     .filter(isElement)
     .reject(isScriptSupporting);
 }
@@ -88,7 +92,7 @@ function hasTextContent(element: Element): boolean {
 }
 
 function listContent(target: Element): Result<Diagnostic> {
-  const disallowed = elementChildren(target).reject(hasName("li"));
+  const disallowed = elementChildren(target).reject(hasHtmlName("li"));
 
   return disallowed.isEmpty()
     ? Outcomes.HasValidContent
@@ -97,7 +101,7 @@ function listContent(target: Element): Result<Diagnostic> {
 
 function descriptionListContent(target: Element): Result<Diagnostic> {
   const children = elementChildren(target);
-  const disallowed = children.reject(hasName("div", "dt", "dd"));
+  const disallowed = children.reject(hasHtmlName("div", "dt", "dd"));
 
   if (!disallowed.isEmpty()) {
     return Outcomes.HasDisallowedElements(disallowed);
@@ -132,7 +136,7 @@ function isWellFormedGroup(wrapper: Element): boolean {
 
   const children = elementChildren(wrapper);
 
-  if (!children.reject(hasName("dt", "dd")).isEmpty()) {
+  if (!children.reject(hasHtmlName("dt", "dd")).isEmpty()) {
     return false;
   }
 
diff --git a/packages/alfa-rules/test/sia-r119/rule.spec.tsx b/packages/alfa-rules/test/sia-r119/rule.spec.tsx
index 41e77c23dd..2ffa8aa59c 100644
--- a/packages/alfa-rules/test/sia-r119/rule.spec.tsx
+++ b/packages/alfa-rules/test/sia-r119/rule.spec.tsx
@@ -1,4 +1,4 @@
-import { h } from "@siteimprove/alfa-dom";
+import { h, Namespace } from "@siteimprove/alfa-dom";
 import { test } from "@siteimprove/alfa-test";
 
 import R119, { Outcomes } from "../../src/sia-r119/rule.ts";
@@ -92,6 +92,23 @@ test(`evaluate() fails a <ul> whose items carry the listitem role without being
   ]);
 });
 
+test(`evaluate() fails a <ul> with an SVG-namespaced <li> child`, async (t) => {
+  // Content models are written in terms of HTML elements, so sharing a local
+  // name is not enough. No HTML syntax produces this; it has to be built with
+  // createElementNS or moved out of an inline SVG.
+  const error = h.element("li", [], ["Foo"], [], Namespace.SVG);
+
+  const target = <ul>{error}</ul>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, {
+      1: Outcomes.HasDisallowedElements([error]),
+    }),
+  ]);
+});
+
 /* <dl> with groups written out directly */
 
 test(`evaluate() passes a <dl> with a single name-value group`, async (t) => {

From f6e32cecb9309ed8327f1dc1d6ad58ab5e8def53 Mon Sep 17 00:00:00 2001
From: pooya-si <pahm@siteimprove.com>
Date: Mon, 14 Sep 2026 22:07:30 -0400
Subject: [PATCH 03/10] [11Y-12317] Update based on code review.

---
 packages/alfa-rules/src/sia-r119/rule.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/alfa-rules/src/sia-r119/rule.ts b/packages/alfa-rules/src/sia-r119/rule.ts
index c85fa13cd4..71c1e6693e 100644
--- a/packages/alfa-rules/src/sia-r119/rule.ts
+++ b/packages/alfa-rules/src/sia-r119/rule.ts
@@ -86,7 +86,7 @@ function elementChildren(element: Element): Sequence<Element> {
 
 function hasTextContent(element: Element): boolean {
   return element
-    .children(Node.fullTree)
+    .children()
     .filter(isText)
     .some((text) => !String.isWhitespace(text.data));
 }
@@ -168,7 +168,7 @@ export namespace Outcomes {
   );
 
   export const HasDisallowedText = Err.of(
-    Diagnostic.of(`The element contains text outside of any list item.`),
+    Diagnostic.of(`The element contains text that its content model does not allow.`),
   );
 
   export const HasDisallowedElements = (errors: Iterable<Element>) =>

From aaa6f0c79532ade9ad9604e3e62c905a0bd9da4c Mon Sep 17 00:00:00 2001
From: pooya-si <pahm@siteimprove.com>
Date: Wed, 16 Sep 2026 14:42:36 -0400
Subject: [PATCH 04/10] [11Y-12317] Support slots.

---
 packages/alfa-rules/src/sia-r119/rule.ts      |  44 ++++--
 .../alfa-rules/test/sia-r119/rule.spec.tsx    | 131 ++++++++++++++++++
 2 files changed, 167 insertions(+), 8 deletions(-)

diff --git a/packages/alfa-rules/src/sia-r119/rule.ts b/packages/alfa-rules/src/sia-r119/rule.ts
index 71c1e6693e..18884612d7 100644
--- a/packages/alfa-rules/src/sia-r119/rule.ts
+++ b/packages/alfa-rules/src/sia-r119/rule.ts
@@ -1,5 +1,12 @@
 import { Diagnostic, Rule } from "@siteimprove/alfa-act";
-import { Element, Namespace, Node, Query, Text } from "@siteimprove/alfa-dom";
+import {
+  Element,
+  Namespace,
+  Node,
+  Query,
+  Shadow,
+  Text,
+} from "@siteimprove/alfa-dom";
 import { EAA } from "@siteimprove/alfa-eaa";
 import { Refinement } from "@siteimprove/alfa-refinement";
 import type { Result } from "@siteimprove/alfa-result";
@@ -15,7 +22,7 @@ import { WithBadElements } from "../common/diagnostic/with-bad-elements.ts";
 
 import { Scope, Stability } from "../tags/index.ts";
 
-const { hasName, hasNamespace, isElement } = Element;
+const { hasName, hasNamespace, isElement, isSlot } = Element;
 const { and } = Refinement;
 const { isRendered } = Style;
 const { isText } = Text;
@@ -77,22 +84,36 @@ function hasHtmlName<N extends string>(name: N, ...rest: Array<N>) {
 
 const isScriptSupporting = hasHtmlName("script", "template");
 
-function elementChildren(element: Element): Sequence<Element> {
+// A <slot> only slots inside a shadow tree. Anywhere else no assignment
+// algorithm reaches it, so it is an inert element in a position the content
+// model forbids. The flat tree replaces it with nothing, which is why this is
+// the one check that has to read the node tree.
+function straySlots(element: Element): Sequence<Element> {
   return element
     .children()
     .filter(isElement)
+    .filter(isSlot)
+    .reject((slot) => Shadow.isShadow(slot.root()));
+}
+
+function elementChildren(element: Element): Sequence<Element> {
+  return element
+    .children(Node.fullTree)
+    .filter(isElement)
     .reject(isScriptSupporting);
 }
 
 function hasTextContent(element: Element): boolean {
   return element
-    .children()
+    .children(Node.fullTree)
     .filter(isText)
     .some((text) => !String.isWhitespace(text.data));
 }
 
 function listContent(target: Element): Result<Diagnostic> {
-  const disallowed = elementChildren(target).reject(hasHtmlName("li"));
+  const disallowed = elementChildren(target)
+    .reject(hasHtmlName("li"))
+    .concat(straySlots(target));
 
   return disallowed.isEmpty()
     ? Outcomes.HasValidContent
@@ -101,7 +122,9 @@ function listContent(target: Element): Result<Diagnostic> {
 
 function descriptionListContent(target: Element): Result<Diagnostic> {
   const children = elementChildren(target);
-  const disallowed = children.reject(hasHtmlName("div", "dt", "dd"));
+  const disallowed = children
+    .reject(hasHtmlName("div", "dt", "dd"))
+    .concat(straySlots(target));
 
   if (!disallowed.isEmpty()) {
     return Outcomes.HasDisallowedElements(disallowed);
@@ -136,7 +159,10 @@ function isWellFormedGroup(wrapper: Element): boolean {
 
   const children = elementChildren(wrapper);
 
-  if (!children.reject(hasHtmlName("dt", "dd")).isEmpty()) {
+  if (
+    !children.reject(hasHtmlName("dt", "dd")).isEmpty() ||
+    !straySlots(wrapper).isEmpty()
+  ) {
     return false;
   }
 
@@ -168,7 +194,9 @@ export namespace Outcomes {
   );
 
   export const HasDisallowedText = Err.of(
-    Diagnostic.of(`The element contains text that its content model does not allow.`),
+    Diagnostic.of(
+      `The element contains text that its content model does not allow.`,
+    ),
   );
 
   export const HasDisallowedElements = (errors: Iterable<Element>) =>
diff --git a/packages/alfa-rules/test/sia-r119/rule.spec.tsx b/packages/alfa-rules/test/sia-r119/rule.spec.tsx
index 2ffa8aa59c..1130d153ea 100644
--- a/packages/alfa-rules/test/sia-r119/rule.spec.tsx
+++ b/packages/alfa-rules/test/sia-r119/rule.spec.tsx
@@ -109,6 +109,97 @@ test(`evaluate() fails a <ul> with an SVG-namespaced <li> child`, async (t) => {
   ]);
 });
 
+/*
+ * Children are read from the flat tree, so a slot is replaced by whatever is
+ * assigned to it. The first two cases below are the benefit: a list assembled by
+ * a web component passes, and text slotted into one is still reported as text
+ * outside a list item rather than being blamed on the slot.
+ *
+ * The third case is the one the flat tree cannot see on its own. A slot outside
+ * any shadow tree is never assigned anything, so flattening replaces it with
+ * nothing and the list looks empty. `straySlots` reads the node tree for exactly
+ * that case, which is why it is reported without the first two being affected.
+ */
+
+test(`evaluate() passes a list whose items are slotted in from light DOM`, async (t) => {
+  const target = (
+    <ul>
+      <slot></slot>
+    </ul>
+  );
+
+  const document = h.document([
+    h.element("my-list", [], [h.shadow([target]), <li>One</li>, <li>Two</li>]),
+  ]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() fails a list with a stray <slot> outside any shadow tree`, async (t) => {
+  const error = <slot></slot>;
+
+  const target = <ul>{error}</ul>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, {
+      1: Outcomes.HasDisallowedElements([error]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a list with a stray <slot> beside a valid item`, async (t) => {
+  const error = <slot></slot>;
+
+  const target = (
+    <ul>
+      {error}
+      <li>One</li>
+    </ul>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, {
+      1: Outcomes.HasDisallowedElements([error]),
+    }),
+  ]);
+});
+
+test(`evaluate() passes an unassigned <slot> inside a shadow tree`, async (t) => {
+  const target = (
+    <ul>
+      <slot></slot>
+    </ul>
+  );
+
+  const document = h.document([h.element("my-list", [], [h.shadow([target])])]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() fails a list containing text slotted in from light DOM`, async (t) => {
+  const target = (
+    <ul>
+      <slot></slot>
+    </ul>
+  );
+
+  const document = h.document([
+    h.element("my-list", [], [h.shadow([target]), "Loose text", <li>One</li>]),
+  ]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, { 1: Outcomes.HasDisallowedText }),
+  ]);
+});
+
 /* <dl> with groups written out directly */
 
 test(`evaluate() passes a <dl> with a single name-value group`, async (t) => {
@@ -265,6 +356,26 @@ test(`every malformed group in a <dl> is evaluated, not only the first`, async (
   ]);
 });
 
+test(`evaluate() fails a <dl> with a stray <slot>`, async (t) => {
+  const error = <slot></slot>;
+
+  const target = (
+    <dl>
+      {error}
+      <dt>Foo</dt>
+      <dd>Bar</dd>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, {
+      1: Outcomes.HasDisallowedElements([error]),
+    }),
+  ]);
+});
+
 test(`evaluate() fails a <dl> with a child that is neither <dt>, <dd> nor <div>`, async (t) => {
   const error = <p>Foo</p>;
 
@@ -446,6 +557,26 @@ test(`evaluate() fails a <dl> with a wrapper that holds more than one group`, as
   ]);
 });
 
+test(`evaluate() fails a <dl> with a wrapper holding a stray <slot>`, async (t) => {
+  const error = (
+    <div>
+      <slot></slot>
+      <dt>Foo</dt>
+      <dd>Bar</dd>
+    </div>
+  );
+
+  const target = <dl>{error}</dl>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R119, { document }), [
+    failed(R119, target, {
+      1: Outcomes.HasMalformedGroups([error]),
+    }),
+  ]);
+});
+
 test(`evaluate() fails a <dl> with a wrapper that holds a disallowed element`, async (t) => {
   const error = (
     <div>

From ce28f9eb3d85a168ce0441e91fa87e924d81c703 Mon Sep 17 00:00:00 2001
From: pooya-si <pahm@siteimprove.com>
Date: Wed, 16 Sep 2026 15:50:29 -0400
Subject: [PATCH 05/10] [11Y-12317] Update requirements.

---
 packages/alfa-rules/src/sia-r119/rule.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/alfa-rules/src/sia-r119/rule.ts b/packages/alfa-rules/src/sia-r119/rule.ts
index 18884612d7..b6193f68ec 100644
--- a/packages/alfa-rules/src/sia-r119/rule.ts
+++ b/packages/alfa-rules/src/sia-r119/rule.ts
@@ -14,7 +14,7 @@ import { Err, Ok } from "@siteimprove/alfa-result";
 import type { Sequence } from "@siteimprove/alfa-sequence";
 import { String } from "@siteimprove/alfa-string";
 import { Style } from "@siteimprove/alfa-style";
-import { Criterion } from "@siteimprove/alfa-wcag";
+import { Criterion, Technique } from "@siteimprove/alfa-wcag";
 import type { Page } from "@siteimprove/alfa-web";
 
 import { expectation } from "../common/act/index.ts";
@@ -47,7 +47,7 @@ const { getElementDescendants } = Query;
  */
 export default Rule.Atomic.of<Page, Element>({
   uri: "https://alfa.siteimprove.com/rules/sia-r119",
-  requirements: [Criterion.of("1.3.1"), EAA.of("9.1.3.1")],
+  requirements: [Criterion.of("1.3.1"), EAA.of("9.1.3.1"), Technique.of("H40")],
   tags: [Scope.Component, Stability.Stable],
   evaluate({ device, document }) {
     return {

From 6a57c6b0ca49127e3113b2475ab1f6ab548dd6b1 Mon Sep 17 00:00:00 2001
From: pooya-si <pahm@siteimprove.com>
Date: Wed, 23 Sep 2026 17:30:40 -0400
Subject: [PATCH 06/10] [A11Y-12318] Add SIA-R120. (#2175)

* [11Y-12318] Add R120.
---
 .changeset/lucky-keys-listen.md               |  11 +
 packages/alfa-rules/src/rules.ts              |   2 +
 packages/alfa-rules/src/sia-r120/rule.ts      | 178 +++++++
 packages/alfa-rules/src/tsconfig.json         |   1 +
 .../alfa-rules/test/sia-r120/rule.spec.tsx    | 448 ++++++++++++++++++
 packages/alfa-rules/test/tsconfig.json        |   3 +-
 6 files changed, 642 insertions(+), 1 deletion(-)
 create mode 100644 .changeset/lucky-keys-listen.md
 create mode 100644 packages/alfa-rules/src/sia-r120/rule.ts
 create mode 100644 packages/alfa-rules/test/sia-r120/rule.spec.tsx

diff --git a/.changeset/lucky-keys-listen.md b/.changeset/lucky-keys-listen.md
new file mode 100644
index 0000000000..32a98e8476
--- /dev/null
+++ b/.changeset/lucky-keys-listen.md
@@ -0,0 +1,11 @@
+---
+"@siteimprove/alfa-rules": minor
+---
+
+**Added:** The new rule R120 checks that the access keys an element declares are usable.
+
+It makes three checks. No other element may declare the same key, since two elements competing for one key means at most one of them can be reached and which one wins is left to the user agent. Each key must be a single character, since anything longer is not a key a user can press. And an element may not declare the same key twice.
+
+Case is folded throughout, so `A` and `a` are the same key. Two elements declaring them compete, and `accesskey="a A"` on one element declares that key twice and is reported for the repeat. That is stricter than the W3C checker, which compares the tokens of a single value literally and accepts it.
+
+The attribute holds a set of space-separated tokens, so `accesskey="a b"` declares two keys and each is checked separately.
diff --git a/packages/alfa-rules/src/rules.ts b/packages/alfa-rules/src/rules.ts
index 253cbdc7d7..a70c2b8f4b 100644
--- a/packages/alfa-rules/src/rules.ts
+++ b/packages/alfa-rules/src/rules.ts
@@ -88,6 +88,7 @@ import R111 from "./sia-r111/rule.ts";
 import R113 from "./sia-r113/rule.ts";
 import R116 from "./sia-r116/rule.ts";
 import R119 from "./sia-r119/rule.ts";
+import R120 from "./sia-r120/rule.ts";
 
 export {
   R1,
@@ -180,4 +181,5 @@ export {
   R113,
   R116,
   R119,
+  R120,
 };
diff --git a/packages/alfa-rules/src/sia-r120/rule.ts b/packages/alfa-rules/src/sia-r120/rule.ts
new file mode 100644
index 0000000000..e97a400b73
--- /dev/null
+++ b/packages/alfa-rules/src/sia-r120/rule.ts
@@ -0,0 +1,178 @@
+import { Diagnostic, Rule } from "@siteimprove/alfa-act";
+import { Element, Namespace, Node, Query } from "@siteimprove/alfa-dom";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Err, Ok } from "@siteimprove/alfa-result";
+import { Sequence } from "@siteimprove/alfa-sequence";
+import { Style } from "@siteimprove/alfa-style";
+import type { Page } from "@siteimprove/alfa-web";
+
+import { expectation } from "../common/act/index.ts";
+import { BestPractice } from "../requirements/index.ts";
+
+import { Scope, Stability } from "../tags/index.ts";
+
+const { hasNamespace } = Element;
+const { and } = Predicate;
+const { isRendered } = Style;
+const { getElementDescendants } = Query;
+
+/**
+ * This rule checks that the access keys an element declares are usable: that no
+ * other element declares the same key, that each key is a single character, and
+ * that the element does not declare the same key twice.
+ *
+ * Two elements competing for one key means at most one of them can be reached
+ * by it, and which one wins is left to the user agent.
+ *
+ * Case is folded throughout, since `A` and `a` reach the same physical key, so
+ * `accesskey="a A"` declares one key twice and is reported for the repeat. That
+ * is stricter than the specification, which asks only that the tokens not be
+ * "identical to another token", a literal comparison the W3C checker
+ * implements with a case-sensitive equality.
+ *
+ * Elements that are not rendered are left out, since their access keys cannot
+ * be activated, and a key declared only on such an element competes with
+ * nothing.
+ *
+ * {@link https://html.spec.whatwg.org/multipage/interaction.html#the-accesskey-attribute}
+ */
+export default Rule.Atomic.of<Page, Element>({
+  uri: "https://alfa.siteimprove.com/rules/sia-r120",
+  requirements: [BestPractice.of("accesskey-unique")],
+  tags: [Scope.Page, Stability.Stable],
+  evaluate({ device, document }) {
+    const elements = getElementDescendants(document, Node.fullTree)
+      .filter(and(hasNamespace(Namespace.HTML), declaresAccesskey))
+      .filter(isRendered(device));
+
+    const accessKeyElementPairs = new Map<string, Array<Element>>();
+
+    for (const element of elements) {
+      for (const key of accesskeys(element)) {
+        const elementsForKey = accessKeyElementPairs.get(key) ?? [];
+
+        elementsForKey.push(element);
+        accessKeyElementPairs.set(key, elementsForKey);
+      }
+    }
+
+    return {
+      applicability() {
+        return elements;
+      },
+
+      expectations(target) {
+        const contested = accesskeys(target).filter(
+          (key) => (accessKeyElementPairs.get(key)?.length ?? 0) > 1,
+        );
+        const tooLong = tokens(target).reject((token) => token.length === 1);
+
+        const duplicated = repeatedTokens(target);
+
+        return {
+          1: expectation(
+            contested.isEmpty(),
+            () => Outcomes.HasUniqueAccesskeys,
+            () => Outcomes.HasNonUniqueAccesskeys(contested),
+          ),
+          2: expectation(
+            tooLong.isEmpty(),
+            () => Outcomes.HasSingleCharacterAccesskeys,
+            () => Outcomes.HasMultiCharacterAccesskeys(tooLong),
+          ),
+          3: expectation(
+            duplicated.isEmpty(),
+            () => Outcomes.HasDistinctAccesskeys,
+            () => Outcomes.HasRepeatedAccesskeys(duplicated),
+          ),
+        };
+      },
+    };
+  },
+});
+
+function tokens(element: Element): Sequence<string> {
+  return Sequence.from(element.attribute("accesskey")).flatMap((attribute) =>
+    attribute.tokens(),
+  );
+}
+
+function accesskeys(element: Element): Sequence<string> {
+  return tokens(element)
+    .map((token) => token.toLowerCase())
+    .distinct();
+}
+
+function repeatedTokens(element: Element): Sequence<string> {
+  const seen = new Set<string>();
+  const repeated = new Set<string>();
+
+  for (const token of tokens(element).map((token) => token.toLowerCase())) {
+    if (seen.has(token)) {
+      repeated.add(token);
+    } else {
+      seen.add(token);
+    }
+  }
+
+  return Sequence.from(repeated);
+}
+
+const declaresAccesskey: Predicate<Element> = (element) =>
+  !tokens(element).isEmpty();
+
+/**
+ * @public
+ */
+export namespace Outcomes {
+  export const HasUniqueAccesskeys = Ok.of(
+    Diagnostic.of(
+      `No access key of the element is declared by another element.`,
+    ),
+  );
+
+  export const HasNonUniqueAccesskeys = (keys: Iterable<string>) =>
+    Err.of(
+      Diagnostic.of(
+        many(keys)
+          ? `More than one element declares the access keys ${list(keys)}.`
+          : `More than one element declares the access key ${list(keys)}.`,
+      ),
+    );
+
+  export const HasSingleCharacterAccesskeys = Ok.of(
+    Diagnostic.of(`Every access key of the element is a single character.`),
+  );
+
+  export const HasMultiCharacterAccesskeys = (keys: Iterable<string>) =>
+    Err.of(
+      Diagnostic.of(
+        many(keys)
+          ? `The access keys ${list(keys)} are not single characters.`
+          : `The access key ${list(keys)} is not a single character.`,
+      ),
+    );
+
+  export const HasDistinctAccesskeys = Ok.of(
+    Diagnostic.of(`The element declares each of its access keys once.`),
+  );
+
+  export const HasRepeatedAccesskeys = (keys: Iterable<string>) =>
+    Err.of(
+      Diagnostic.of(
+        many(keys)
+          ? `The element declares the access keys ${list(keys)} more than once.`
+          : `The element declares the access key ${list(keys)} more than once.`,
+      ),
+    );
+}
+
+function list(keys: Iterable<string>): string {
+  return Sequence.from(keys)
+    .map((key) => `"${key}"`)
+    .join(", ");
+}
+
+function many(keys: Iterable<string>): boolean {
+  return Sequence.from(keys).size > 1;
+}
diff --git a/packages/alfa-rules/src/tsconfig.json b/packages/alfa-rules/src/tsconfig.json
index a9ec491b73..3a2885773d 100644
--- a/packages/alfa-rules/src/tsconfig.json
+++ b/packages/alfa-rules/src/tsconfig.json
@@ -166,6 +166,7 @@
     "./sia-r117/rule.ts",
     "./sia-r118/rule.ts",
     "./sia-r119/rule.ts",
+    "./sia-r120/rule.ts",
     "./tags/index.ts",
     "./tags/stability.ts",
     "./tags/scope.ts",
diff --git a/packages/alfa-rules/test/sia-r120/rule.spec.tsx b/packages/alfa-rules/test/sia-r120/rule.spec.tsx
new file mode 100644
index 0000000000..af0ab10437
--- /dev/null
+++ b/packages/alfa-rules/test/sia-r120/rule.spec.tsx
@@ -0,0 +1,448 @@
+import { h } from "@siteimprove/alfa-dom";
+import { test } from "@siteimprove/alfa-test";
+
+import R120, { Outcomes } from "../../src/sia-r120/rule.ts";
+
+import { evaluate } from "../common/evaluate.ts";
+import { failed, inapplicable, passed } from "../common/outcome.ts";
+
+test(`evaluate() passes elements with distinct access keys`, async (t) => {
+  const first = <button accesskey="a">Foo</button>;
+  const second = <button accesskey="b">Bar</button>;
+
+  const document = h.document([first, second]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    passed(R120, first, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    passed(R120, second, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() fails both elements sharing an access key`, async (t) => {
+  const first = <button accesskey="a">Foo</button>;
+  const second = <button accesskey="a">Bar</button>;
+
+  const document = h.document([first, second]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    failed(R120, first, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R120, second, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() compares access keys without regard to case`, async (t) => {
+  const first = <button accesskey="a">Foo</button>;
+  const second = <button accesskey="A">Bar</button>;
+
+  const document = h.document([first, second]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    failed(R120, first, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R120, second, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() compares access keys with surrounding whitespace removed`, async (t) => {
+  const first = <button accesskey="a">Foo</button>;
+  const second = <button accesskey=" a ">Bar</button>;
+
+  const document = h.document([first, second]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    failed(R120, first, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R120, second, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() names only the contested key of a multi-token access key`, async (t) => {
+  const both = <button accesskey="a b">Foo</button>;
+  const other = <button accesskey="b">Bar</button>;
+
+  const document = h.document([both, other]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    failed(R120, both, {
+      1: Outcomes.HasNonUniqueAccesskeys(["b"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R120, other, {
+      1: Outcomes.HasNonUniqueAccesskeys(["b"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() names every contested key of a multi-token access key`, async (t) => {
+  const both = <button accesskey="a b">Foo</button>;
+  const first = <button accesskey="a">Bar</button>;
+  const second = <button accesskey="b">Baz</button>;
+
+  const document = h.document([both, first, second]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    failed(R120, both, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a", "b"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R120, first, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R120, second, {
+      1: Outcomes.HasNonUniqueAccesskeys(["b"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() passes multi-token access keys that share no token`, async (t) => {
+  const first = <button accesskey="a b">Foo</button>;
+  const second = <button accesskey="c d">Bar</button>;
+
+  const document = h.document([first, second]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    passed(R120, first, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    passed(R120, second, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() reports a key the element declares twice`, async (t) => {
+  const target = <button accesskey="a a">Foo</button>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    failed(R120, target, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasRepeatedAccesskeys(["a"]),
+    }),
+  ]);
+});
+
+test(`evaluate() reports a key declared twice in different cases`, async (t) => {
+  // `A` and `a` reach the same physical key, so this element declares one key
+  // twice. Stricter than the W3C checker, which compares the tokens literally
+  // and accepts this value.
+  const target = <button accesskey="a A">Foo</button>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    failed(R120, target, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasRepeatedAccesskeys(["a"]),
+    }),
+  ]);
+});
+
+test(`evaluate() reports a multi-character key, which no user can press`, async (t) => {
+  const first = <button accesskey="aa">Foo</button>;
+  const second = <button accesskey="a">Bar</button>;
+
+  const document = h.document([first, second]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    failed(R120, first, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasMultiCharacterAccesskeys(["aa"]),
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    passed(R120, second, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() reports two elements sharing a multi-character key`, async (t) => {
+  const first = <button accesskey="aa">Foo</button>;
+  const second = <button accesskey="aa">Bar</button>;
+
+  const document = h.document([first, second]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    failed(R120, first, {
+      1: Outcomes.HasNonUniqueAccesskeys(["aa"]),
+      2: Outcomes.HasMultiCharacterAccesskeys(["aa"]),
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R120, second, {
+      1: Outcomes.HasNonUniqueAccesskeys(["aa"]),
+      2: Outcomes.HasMultiCharacterAccesskeys(["aa"]),
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() accepts a single Japanese character as a key`, async (t) => {
+  const target = <button accesskey="ぬ">Foo</button>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    passed(R120, target, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() accepts several Japanese characters as separate keys`, async (t) => {
+  const target = <button accesskey="ぬ め">Foo</button>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    passed(R120, target, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() reports two elements sharing a Japanese key`, async (t) => {
+  const first = <button accesskey="ぬ">Foo</button>;
+  const second = <button accesskey="ぬ">Bar</button>;
+
+  const document = h.document([first, second]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    failed(R120, first, {
+      1: Outcomes.HasNonUniqueAccesskeys(["ぬ"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R120, second, {
+      1: Outcomes.HasNonUniqueAccesskeys(["ぬ"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() reports a Japanese key an element declares twice`, async (t) => {
+  // Verbatim from the checker's duplicate-key-labels test case.
+  const target = <button accesskey="a b ぬ c ぬ">Foo</button>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    failed(R120, target, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasRepeatedAccesskeys(["ぬ"]),
+    }),
+  ]);
+});
+
+test(`evaluate() reports a multi-character Japanese key`, async (t) => {
+  // Adapted from the checker's multi-character-key-label test case, which uses
+  // `ほげ`. Both kana here sit directly on a JIS keyboard, ほ on the `-` key and
+  // す on the `R` key, so the value is plainly two keystrokes rather than one.
+  const target = <button accesskey="a b ほす">Foo</button>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    failed(R120, target, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasMultiCharacterAccesskeys(["ほす"]),
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() reports every multi-character key of one element`, async (t) => {
+  const target = <button accesskey="aa bb c">Foo</button>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    failed(R120, target, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasMultiCharacterAccesskeys(["aa", "bb"]),
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() reports every key an element declares twice`, async (t) => {
+  const target = <button accesskey="a a b b">Foo</button>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    failed(R120, target, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasRepeatedAccesskeys(["a", "b"]),
+    }),
+  ]);
+});
+
+test(`evaluate() passes an access key shared only with an element that is not rendered`, async (t) => {
+  const target = <button accesskey="a">Foo</button>;
+
+  const document = h.document([
+    target,
+    <button accesskey="a" style={{ display: "none" }}>
+      Bar
+    </button>,
+  ]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    passed(R120, target, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() reports a key shared across a frame boundary`, async (t) => {
+  // Access keys are treated as unique across the whole page, frames included,
+  // rather than per document.
+  const outer = <button accesskey="a">Parent</button>;
+  const inner = <button accesskey="a">Framed</button>;
+
+  const document = h.document([outer, <iframe>{h.document([inner])}</iframe>]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    failed(R120, outer, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R120, inner, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() passes distinct keys either side of a frame boundary`, async (t) => {
+  const outer = <button accesskey="a">Parent</button>;
+  const inner = <button accesskey="b">Framed</button>;
+
+  const document = h.document([outer, <iframe>{h.document([inner])}</iframe>]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    passed(R120, outer, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    passed(R120, inner, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() reports a key shared between two frames`, async (t) => {
+  const first = <button accesskey="a">First</button>;
+  const second = <button accesskey="a">Second</button>;
+
+  const document = h.document([
+    <iframe>{h.document([first])}</iframe>,
+    <iframe>{h.document([second])}</iframe>,
+  ]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    failed(R120, first, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R120, second, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() reports a key shared across a shadow boundary in one document`, async (t) => {
+  const light = <button accesskey="a">Light</button>;
+  const shadowed = <button accesskey="a">Shadowed</button>;
+
+  const document = h.document([light, <div>{h.shadow([shadowed])}</div>]);
+
+  t.deepEqual(await evaluate(R120, { document }), [
+    failed(R120, light, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R120, shadowed, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() is inapplicable to a document with no access key`, async (t) => {
+  const document = h.document([<button>Foo</button>]);
+
+  t.deepEqual(await evaluate(R120, { document }), [inapplicable(R120)]);
+});
+
+test(`evaluate() is inapplicable to an access key that is only whitespace`, async (t) => {
+  const document = h.document([<button accesskey=" ">Foo</button>]);
+
+  t.deepEqual(await evaluate(R120, { document }), [inapplicable(R120)]);
+});
diff --git a/packages/alfa-rules/test/tsconfig.json b/packages/alfa-rules/test/tsconfig.json
index 5612de8902..1046da1a46 100644
--- a/packages/alfa-rules/test/tsconfig.json
+++ b/packages/alfa-rules/test/tsconfig.json
@@ -124,7 +124,8 @@
     "./sia-r116/rule.spec.tsx",
     "./sia-r117/rule.spec.tsx",
     "./sia-r118/rule.spec.tsx",
-    "./sia-r119/rule.spec.tsx"
+    "./sia-r119/rule.spec.tsx",
+    "./sia-r120/rule.spec.tsx"
   ],
   "references": [
     { "path": "../src" },

From 55e807b047ba1da2bd647198b9da579fd38071fb Mon Sep 17 00:00:00 2001
From: pooya-si <pahm@siteimprove.com>
Date: Wed, 23 Sep 2026 17:35:21 -0400
Subject: [PATCH 07/10] [11Y-12318] Renumber the rules

---
 .changeset/brave-lists-gather.md              |   2 +-
 packages/alfa-rules/src/rules.ts              |   4 +-
 .../src/{sia-r119 => sia-r121}/rule.ts        |   2 +-
 packages/alfa-rules/src/tsconfig.json         |   2 +-
 .../test/{sia-r119 => sia-r121}/rule.spec.tsx | 138 +++++++++---------
 packages/alfa-rules/test/tsconfig.json        |   2 +-
 6 files changed, 75 insertions(+), 75 deletions(-)
 rename packages/alfa-rules/src/{sia-r119 => sia-r121}/rule.ts (99%)
 rename packages/alfa-rules/test/{sia-r119 => sia-r121}/rule.spec.tsx (76%)

diff --git a/.changeset/brave-lists-gather.md b/.changeset/brave-lists-gather.md
index 49a570fdb5..df48b7b40b 100644
--- a/.changeset/brave-lists-gather.md
+++ b/.changeset/brave-lists-gather.md
@@ -2,7 +2,7 @@
 "@siteimprove/alfa-rules": minor
 ---
 
-**Added:** The new rule R119 checks that `<ul>`, `<ol>` and `<dl>` elements only contain the children allowed by the HTML content model.
+**Added:** The new rule R121 checks that `<ul>`, `<ol>` and `<dl>` elements only contain the children allowed by the HTML content model.
 
 The rule follows the content model as the HTML specification states it, rather than a relaxed reading of it:
 
diff --git a/packages/alfa-rules/src/rules.ts b/packages/alfa-rules/src/rules.ts
index 253cbdc7d7..22ccf6a988 100644
--- a/packages/alfa-rules/src/rules.ts
+++ b/packages/alfa-rules/src/rules.ts
@@ -87,7 +87,7 @@ import R110 from "./sia-r110/rule.ts";
 import R111 from "./sia-r111/rule.ts";
 import R113 from "./sia-r113/rule.ts";
 import R116 from "./sia-r116/rule.ts";
-import R119 from "./sia-r119/rule.ts";
+import R121 from "./sia-r121/rule.ts";
 
 export {
   R1,
@@ -179,5 +179,5 @@ export {
   R111,
   R113,
   R116,
-  R119,
+  R121,
 };
diff --git a/packages/alfa-rules/src/sia-r119/rule.ts b/packages/alfa-rules/src/sia-r121/rule.ts
similarity index 99%
rename from packages/alfa-rules/src/sia-r119/rule.ts
rename to packages/alfa-rules/src/sia-r121/rule.ts
index b6193f68ec..3f1adac1cf 100644
--- a/packages/alfa-rules/src/sia-r119/rule.ts
+++ b/packages/alfa-rules/src/sia-r121/rule.ts
@@ -46,7 +46,7 @@ const { getElementDescendants } = Query;
  * {@link https://html.spec.whatwg.org/multipage/grouping-content.html#the-dl-element}
  */
 export default Rule.Atomic.of<Page, Element>({
-  uri: "https://alfa.siteimprove.com/rules/sia-r119",
+  uri: "https://alfa.siteimprove.com/rules/sia-r121",
   requirements: [Criterion.of("1.3.1"), EAA.of("9.1.3.1"), Technique.of("H40")],
   tags: [Scope.Component, Stability.Stable],
   evaluate({ device, document }) {
diff --git a/packages/alfa-rules/src/tsconfig.json b/packages/alfa-rules/src/tsconfig.json
index a9ec491b73..b1f0284084 100644
--- a/packages/alfa-rules/src/tsconfig.json
+++ b/packages/alfa-rules/src/tsconfig.json
@@ -165,7 +165,7 @@
     "./sia-r116/rule.ts",
     "./sia-r117/rule.ts",
     "./sia-r118/rule.ts",
-    "./sia-r119/rule.ts",
+    "./sia-r121/rule.ts",
     "./tags/index.ts",
     "./tags/stability.ts",
     "./tags/scope.ts",
diff --git a/packages/alfa-rules/test/sia-r119/rule.spec.tsx b/packages/alfa-rules/test/sia-r121/rule.spec.tsx
similarity index 76%
rename from packages/alfa-rules/test/sia-r119/rule.spec.tsx
rename to packages/alfa-rules/test/sia-r121/rule.spec.tsx
index 1130d153ea..e098c91e16 100644
--- a/packages/alfa-rules/test/sia-r119/rule.spec.tsx
+++ b/packages/alfa-rules/test/sia-r121/rule.spec.tsx
@@ -1,7 +1,7 @@
 import { h, Namespace } from "@siteimprove/alfa-dom";
 import { test } from "@siteimprove/alfa-test";
 
-import R119, { Outcomes } from "../../src/sia-r119/rule.ts";
+import R121, { Outcomes } from "../../src/sia-r121/rule.ts";
 
 import { evaluate } from "../common/evaluate.ts";
 import { failed, inapplicable, passed } from "../common/outcome.ts";
@@ -18,8 +18,8 @@ test(`evaluate() passes a <ul> whose children are all <li>`, async (t) => {
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
   ]);
 });
 
@@ -34,8 +34,8 @@ test(`evaluate() passes an <ol> that intermixes script-supporting elements`, asy
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
   ]);
 });
 
@@ -44,8 +44,8 @@ test(`evaluate() passes an empty <ul>`, async (t) => {
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
   ]);
 });
 
@@ -56,8 +56,8 @@ test(`evaluate() fails a <ul> with a <div> child`, async (t) => {
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, {
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
       1: Outcomes.HasDisallowedElements([error]),
     }),
   ]);
@@ -73,8 +73,8 @@ test(`evaluate() fails a <ul> containing text outside of a list item`, async (t)
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, { 1: Outcomes.HasDisallowedText }),
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, { 1: Outcomes.HasDisallowedText }),
   ]);
 });
 
@@ -85,8 +85,8 @@ test(`evaluate() fails a <ul> whose items carry the listitem role without being
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, {
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
       1: Outcomes.HasDisallowedElements([error]),
     }),
   ]);
@@ -102,8 +102,8 @@ test(`evaluate() fails a <ul> with an SVG-namespaced <li> child`, async (t) => {
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, {
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
       1: Outcomes.HasDisallowedElements([error]),
     }),
   ]);
@@ -132,8 +132,8 @@ test(`evaluate() passes a list whose items are slotted in from light DOM`, async
     h.element("my-list", [], [h.shadow([target]), <li>One</li>, <li>Two</li>]),
   ]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
   ]);
 });
 
@@ -144,8 +144,8 @@ test(`evaluate() fails a list with a stray <slot> outside any shadow tree`, asyn
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, {
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
       1: Outcomes.HasDisallowedElements([error]),
     }),
   ]);
@@ -163,8 +163,8 @@ test(`evaluate() fails a list with a stray <slot> beside a valid item`, async (t
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, {
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
       1: Outcomes.HasDisallowedElements([error]),
     }),
   ]);
@@ -179,8 +179,8 @@ test(`evaluate() passes an unassigned <slot> inside a shadow tree`, async (t) =>
 
   const document = h.document([h.element("my-list", [], [h.shadow([target])])]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
   ]);
 });
 
@@ -195,8 +195,8 @@ test(`evaluate() fails a list containing text slotted in from light DOM`, async
     h.element("my-list", [], [h.shadow([target]), "Loose text", <li>One</li>]),
   ]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, { 1: Outcomes.HasDisallowedText }),
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, { 1: Outcomes.HasDisallowedText }),
   ]);
 });
 
@@ -212,8 +212,8 @@ test(`evaluate() passes a <dl> with a single name-value group`, async (t) => {
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
   ]);
 });
 
@@ -229,8 +229,8 @@ test(`evaluate() passes a <dl> with several names and values per group`, async (
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
   ]);
 });
 
@@ -246,8 +246,8 @@ test(`evaluate() passes a <dl> with consecutive name-value groups`, async (t) =>
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
   ]);
 });
 
@@ -256,8 +256,8 @@ test(`evaluate() passes an empty <dl>`, async (t) => {
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
   ]);
 });
 
@@ -274,8 +274,8 @@ test(`evaluate() passes a <dl> that intermixes script-supporting elements`, asyn
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
   ]);
 });
 
@@ -289,8 +289,8 @@ test(`evaluate() passes a <dl> that contains only script-supporting elements`, a
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
   ]);
 });
 
@@ -307,8 +307,8 @@ test(`evaluate() fails a <dl> with a description without a term`, async (t) => {
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, {
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
       1: Outcomes.HasMalformedGroups([error]),
     }),
   ]);
@@ -327,8 +327,8 @@ test(`evaluate() fails a <dl> with a trailing term that is given no description`
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, {
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
       1: Outcomes.HasMalformedGroups([error]),
     }),
   ]);
@@ -349,8 +349,8 @@ test(`every malformed group in a <dl> is evaluated, not only the first`, async (
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, {
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
       1: Outcomes.HasMalformedGroups([first, last]),
     }),
   ]);
@@ -369,8 +369,8 @@ test(`evaluate() fails a <dl> with a stray <slot>`, async (t) => {
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, {
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
       1: Outcomes.HasDisallowedElements([error]),
     }),
   ]);
@@ -389,8 +389,8 @@ test(`evaluate() fails a <dl> with a child that is neither <dt>, <dd> nor <div>`
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, {
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
       1: Outcomes.HasDisallowedElements([error]),
     }),
   ]);
@@ -407,8 +407,8 @@ test(`evaluate() fails a <dl> containing text outside of a name or value`, async
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, { 1: Outcomes.HasDisallowedText }),
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, { 1: Outcomes.HasDisallowedText }),
   ]);
 });
 
@@ -430,8 +430,8 @@ test(`evaluate() passes a <dl> whose groups are each wrapped in a <div>`, async
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
   ]);
 });
 
@@ -452,8 +452,8 @@ test(`evaluate() passes a <dl> with a script-supporting element between wrappers
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
   ]);
 });
 
@@ -470,8 +470,8 @@ test(`evaluate() passes a <dl> with a script-supporting element inside a wrapper
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    passed(R119, target, { 1: Outcomes.HasValidContent }),
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
   ]);
 });
 
@@ -492,8 +492,8 @@ test(`evaluate() fails a <dl> that mixes wrapped and unwrapped groups`, async (t
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, {
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
       1: Outcomes.HasMixedGroups([name, value]),
     }),
   ]);
@@ -510,8 +510,8 @@ test(`evaluate() fails a <dl> with a wrapper that holds a name and no value`, as
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, {
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
       1: Outcomes.HasMalformedGroups([error]),
     }),
   ]);
@@ -529,8 +529,8 @@ test(`a <dl> with a wrapper with wrong order of elements`, async (t) => {
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, {
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
       1: Outcomes.HasMalformedGroups([error]),
     }),
   ]);
@@ -550,8 +550,8 @@ test(`evaluate() fails a <dl> with a wrapper that holds more than one group`, as
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, {
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
       1: Outcomes.HasMalformedGroups([error]),
     }),
   ]);
@@ -570,8 +570,8 @@ test(`evaluate() fails a <dl> with a wrapper holding a stray <slot>`, async (t)
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, {
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
       1: Outcomes.HasMalformedGroups([error]),
     }),
   ]);
@@ -590,8 +590,8 @@ test(`evaluate() fails a <dl> with a wrapper that holds a disallowed element`, a
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R119, { document }), [
-    failed(R119, target, {
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
       1: Outcomes.HasMalformedGroups([error]),
     }),
   ]);
@@ -606,7 +606,7 @@ test(`evaluate() is inapplicable to a document with no list`, async (t) => {
     </div>,
   ]);
 
-  t.deepEqual(await evaluate(R119, { document }), [inapplicable(R119)]);
+  t.deepEqual(await evaluate(R121, { document }), [inapplicable(R121)]);
 });
 
 test(`evaluate() is inapplicable to a list that is not rendered`, async (t) => {
@@ -616,5 +616,5 @@ test(`evaluate() is inapplicable to a list that is not rendered`, async (t) => {
     </ul>,
   ]);
 
-  t.deepEqual(await evaluate(R119, { document }), [inapplicable(R119)]);
+  t.deepEqual(await evaluate(R121, { document }), [inapplicable(R121)]);
 });
diff --git a/packages/alfa-rules/test/tsconfig.json b/packages/alfa-rules/test/tsconfig.json
index 5612de8902..c2bb404ca2 100644
--- a/packages/alfa-rules/test/tsconfig.json
+++ b/packages/alfa-rules/test/tsconfig.json
@@ -124,7 +124,7 @@
     "./sia-r116/rule.spec.tsx",
     "./sia-r117/rule.spec.tsx",
     "./sia-r118/rule.spec.tsx",
-    "./sia-r119/rule.spec.tsx"
+    "./sia-r121/rule.spec.tsx"
   ],
   "references": [
     { "path": "../src" },

From 680bf20429049019c41b2ac1fb46b0e2e34b0059 Mon Sep 17 00:00:00 2001
From: pooya-si <pahm@siteimprove.com>
Date: Thu, 24 Sep 2026 10:50:22 -0400
Subject: [PATCH 08/10] [11Y-12317] [11Y-12318] Correct the numbers

---
 .changeset/lucky-keys-listen.md               |   2 +-
 packages/alfa-rules/src/rules.ts              |   2 +
 .../src/{sia-r120 => sia-r122}/rule.ts        |   2 +-
 packages/alfa-rules/src/tsconfig.json         |   1 +
 .../test/{sia-r120 => sia-r122}/rule.spec.tsx | 128 +++++++++---------
 packages/alfa-rules/test/tsconfig.json        |   3 +-
 6 files changed, 71 insertions(+), 67 deletions(-)
 rename packages/alfa-rules/src/{sia-r120 => sia-r122}/rule.ts (99%)
 rename packages/alfa-rules/test/{sia-r120 => sia-r122}/rule.spec.tsx (83%)

diff --git a/.changeset/lucky-keys-listen.md b/.changeset/lucky-keys-listen.md
index 32a98e8476..fb4503cd7f 100644
--- a/.changeset/lucky-keys-listen.md
+++ b/.changeset/lucky-keys-listen.md
@@ -2,7 +2,7 @@
 "@siteimprove/alfa-rules": minor
 ---
 
-**Added:** The new rule R120 checks that the access keys an element declares are usable.
+**Added:** The new rule R122 checks that the access keys an element declares are usable.
 
 It makes three checks. No other element may declare the same key, since two elements competing for one key means at most one of them can be reached and which one wins is left to the user agent. Each key must be a single character, since anything longer is not a key a user can press. And an element may not declare the same key twice.
 
diff --git a/packages/alfa-rules/src/rules.ts b/packages/alfa-rules/src/rules.ts
index 22ccf6a988..388aeb5023 100644
--- a/packages/alfa-rules/src/rules.ts
+++ b/packages/alfa-rules/src/rules.ts
@@ -88,6 +88,7 @@ import R111 from "./sia-r111/rule.ts";
 import R113 from "./sia-r113/rule.ts";
 import R116 from "./sia-r116/rule.ts";
 import R121 from "./sia-r121/rule.ts";
+import R122 from "./sia-r122/rule.ts";
 
 export {
   R1,
@@ -180,4 +181,5 @@ export {
   R113,
   R116,
   R121,
+  R122,
 };
diff --git a/packages/alfa-rules/src/sia-r120/rule.ts b/packages/alfa-rules/src/sia-r122/rule.ts
similarity index 99%
rename from packages/alfa-rules/src/sia-r120/rule.ts
rename to packages/alfa-rules/src/sia-r122/rule.ts
index e97a400b73..af7ab09aac 100644
--- a/packages/alfa-rules/src/sia-r120/rule.ts
+++ b/packages/alfa-rules/src/sia-r122/rule.ts
@@ -37,7 +37,7 @@ const { getElementDescendants } = Query;
  * {@link https://html.spec.whatwg.org/multipage/interaction.html#the-accesskey-attribute}
  */
 export default Rule.Atomic.of<Page, Element>({
-  uri: "https://alfa.siteimprove.com/rules/sia-r120",
+  uri: "https://alfa.siteimprove.com/rules/sia-r122",
   requirements: [BestPractice.of("accesskey-unique")],
   tags: [Scope.Page, Stability.Stable],
   evaluate({ device, document }) {
diff --git a/packages/alfa-rules/src/tsconfig.json b/packages/alfa-rules/src/tsconfig.json
index b1f0284084..4d6f8e10fb 100644
--- a/packages/alfa-rules/src/tsconfig.json
+++ b/packages/alfa-rules/src/tsconfig.json
@@ -166,6 +166,7 @@
     "./sia-r117/rule.ts",
     "./sia-r118/rule.ts",
     "./sia-r121/rule.ts",
+    "./sia-r122/rule.ts",
     "./tags/index.ts",
     "./tags/stability.ts",
     "./tags/scope.ts",
diff --git a/packages/alfa-rules/test/sia-r120/rule.spec.tsx b/packages/alfa-rules/test/sia-r122/rule.spec.tsx
similarity index 83%
rename from packages/alfa-rules/test/sia-r120/rule.spec.tsx
rename to packages/alfa-rules/test/sia-r122/rule.spec.tsx
index af0ab10437..4b8cc04545 100644
--- a/packages/alfa-rules/test/sia-r120/rule.spec.tsx
+++ b/packages/alfa-rules/test/sia-r122/rule.spec.tsx
@@ -1,7 +1,7 @@
 import { h } from "@siteimprove/alfa-dom";
 import { test } from "@siteimprove/alfa-test";
 
-import R120, { Outcomes } from "../../src/sia-r120/rule.ts";
+import R122, { Outcomes } from "../../src/sia-r122/rule.ts";
 
 import { evaluate } from "../common/evaluate.ts";
 import { failed, inapplicable, passed } from "../common/outcome.ts";
@@ -12,13 +12,13 @@ test(`evaluate() passes elements with distinct access keys`, async (t) => {
 
   const document = h.document([first, second]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    passed(R120, first, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    passed(R122, first, {
       1: Outcomes.HasUniqueAccesskeys,
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
     }),
-    passed(R120, second, {
+    passed(R122, second, {
       1: Outcomes.HasUniqueAccesskeys,
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
@@ -32,13 +32,13 @@ test(`evaluate() fails both elements sharing an access key`, async (t) => {
 
   const document = h.document([first, second]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    failed(R120, first, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, first, {
       1: Outcomes.HasNonUniqueAccesskeys(["a"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
     }),
-    failed(R120, second, {
+    failed(R122, second, {
       1: Outcomes.HasNonUniqueAccesskeys(["a"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
@@ -52,13 +52,13 @@ test(`evaluate() compares access keys without regard to case`, async (t) => {
 
   const document = h.document([first, second]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    failed(R120, first, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, first, {
       1: Outcomes.HasNonUniqueAccesskeys(["a"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
     }),
-    failed(R120, second, {
+    failed(R122, second, {
       1: Outcomes.HasNonUniqueAccesskeys(["a"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
@@ -72,13 +72,13 @@ test(`evaluate() compares access keys with surrounding whitespace removed`, asyn
 
   const document = h.document([first, second]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    failed(R120, first, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, first, {
       1: Outcomes.HasNonUniqueAccesskeys(["a"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
     }),
-    failed(R120, second, {
+    failed(R122, second, {
       1: Outcomes.HasNonUniqueAccesskeys(["a"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
@@ -92,13 +92,13 @@ test(`evaluate() names only the contested key of a multi-token access key`, asyn
 
   const document = h.document([both, other]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    failed(R120, both, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, both, {
       1: Outcomes.HasNonUniqueAccesskeys(["b"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
     }),
-    failed(R120, other, {
+    failed(R122, other, {
       1: Outcomes.HasNonUniqueAccesskeys(["b"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
@@ -113,18 +113,18 @@ test(`evaluate() names every contested key of a multi-token access key`, async (
 
   const document = h.document([both, first, second]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    failed(R120, both, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, both, {
       1: Outcomes.HasNonUniqueAccesskeys(["a", "b"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
     }),
-    failed(R120, first, {
+    failed(R122, first, {
       1: Outcomes.HasNonUniqueAccesskeys(["a"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
     }),
-    failed(R120, second, {
+    failed(R122, second, {
       1: Outcomes.HasNonUniqueAccesskeys(["b"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
@@ -138,13 +138,13 @@ test(`evaluate() passes multi-token access keys that share no token`, async (t)
 
   const document = h.document([first, second]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    passed(R120, first, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    passed(R122, first, {
       1: Outcomes.HasUniqueAccesskeys,
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
     }),
-    passed(R120, second, {
+    passed(R122, second, {
       1: Outcomes.HasUniqueAccesskeys,
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
@@ -157,8 +157,8 @@ test(`evaluate() reports a key the element declares twice`, async (t) => {
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    failed(R120, target, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, target, {
       1: Outcomes.HasUniqueAccesskeys,
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasRepeatedAccesskeys(["a"]),
@@ -174,8 +174,8 @@ test(`evaluate() reports a key declared twice in different cases`, async (t) =>
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    failed(R120, target, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, target, {
       1: Outcomes.HasUniqueAccesskeys,
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasRepeatedAccesskeys(["a"]),
@@ -189,13 +189,13 @@ test(`evaluate() reports a multi-character key, which no user can press`, async
 
   const document = h.document([first, second]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    failed(R120, first, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, first, {
       1: Outcomes.HasUniqueAccesskeys,
       2: Outcomes.HasMultiCharacterAccesskeys(["aa"]),
       3: Outcomes.HasDistinctAccesskeys,
     }),
-    passed(R120, second, {
+    passed(R122, second, {
       1: Outcomes.HasUniqueAccesskeys,
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
@@ -209,13 +209,13 @@ test(`evaluate() reports two elements sharing a multi-character key`, async (t)
 
   const document = h.document([first, second]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    failed(R120, first, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, first, {
       1: Outcomes.HasNonUniqueAccesskeys(["aa"]),
       2: Outcomes.HasMultiCharacterAccesskeys(["aa"]),
       3: Outcomes.HasDistinctAccesskeys,
     }),
-    failed(R120, second, {
+    failed(R122, second, {
       1: Outcomes.HasNonUniqueAccesskeys(["aa"]),
       2: Outcomes.HasMultiCharacterAccesskeys(["aa"]),
       3: Outcomes.HasDistinctAccesskeys,
@@ -228,8 +228,8 @@ test(`evaluate() accepts a single Japanese character as a key`, async (t) => {
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    passed(R120, target, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    passed(R122, target, {
       1: Outcomes.HasUniqueAccesskeys,
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
@@ -242,8 +242,8 @@ test(`evaluate() accepts several Japanese characters as separate keys`, async (t
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    passed(R120, target, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    passed(R122, target, {
       1: Outcomes.HasUniqueAccesskeys,
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
@@ -257,13 +257,13 @@ test(`evaluate() reports two elements sharing a Japanese key`, async (t) => {
 
   const document = h.document([first, second]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    failed(R120, first, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, first, {
       1: Outcomes.HasNonUniqueAccesskeys(["ぬ"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
     }),
-    failed(R120, second, {
+    failed(R122, second, {
       1: Outcomes.HasNonUniqueAccesskeys(["ぬ"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
@@ -277,8 +277,8 @@ test(`evaluate() reports a Japanese key an element declares twice`, async (t) =>
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    failed(R120, target, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, target, {
       1: Outcomes.HasUniqueAccesskeys,
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasRepeatedAccesskeys(["ぬ"]),
@@ -294,8 +294,8 @@ test(`evaluate() reports a multi-character Japanese key`, async (t) => {
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    failed(R120, target, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, target, {
       1: Outcomes.HasUniqueAccesskeys,
       2: Outcomes.HasMultiCharacterAccesskeys(["ほす"]),
       3: Outcomes.HasDistinctAccesskeys,
@@ -308,8 +308,8 @@ test(`evaluate() reports every multi-character key of one element`, async (t) =>
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    failed(R120, target, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, target, {
       1: Outcomes.HasUniqueAccesskeys,
       2: Outcomes.HasMultiCharacterAccesskeys(["aa", "bb"]),
       3: Outcomes.HasDistinctAccesskeys,
@@ -322,8 +322,8 @@ test(`evaluate() reports every key an element declares twice`, async (t) => {
 
   const document = h.document([target]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    failed(R120, target, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, target, {
       1: Outcomes.HasUniqueAccesskeys,
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasRepeatedAccesskeys(["a", "b"]),
@@ -341,8 +341,8 @@ test(`evaluate() passes an access key shared only with an element that is not re
     </button>,
   ]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    passed(R120, target, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    passed(R122, target, {
       1: Outcomes.HasUniqueAccesskeys,
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
@@ -358,13 +358,13 @@ test(`evaluate() reports a key shared across a frame boundary`, async (t) => {
 
   const document = h.document([outer, <iframe>{h.document([inner])}</iframe>]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    failed(R120, outer, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, outer, {
       1: Outcomes.HasNonUniqueAccesskeys(["a"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
     }),
-    failed(R120, inner, {
+    failed(R122, inner, {
       1: Outcomes.HasNonUniqueAccesskeys(["a"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
@@ -378,13 +378,13 @@ test(`evaluate() passes distinct keys either side of a frame boundary`, async (t
 
   const document = h.document([outer, <iframe>{h.document([inner])}</iframe>]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    passed(R120, outer, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    passed(R122, outer, {
       1: Outcomes.HasUniqueAccesskeys,
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
     }),
-    passed(R120, inner, {
+    passed(R122, inner, {
       1: Outcomes.HasUniqueAccesskeys,
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
@@ -401,13 +401,13 @@ test(`evaluate() reports a key shared between two frames`, async (t) => {
     <iframe>{h.document([second])}</iframe>,
   ]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    failed(R120, first, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, first, {
       1: Outcomes.HasNonUniqueAccesskeys(["a"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
     }),
-    failed(R120, second, {
+    failed(R122, second, {
       1: Outcomes.HasNonUniqueAccesskeys(["a"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
@@ -421,13 +421,13 @@ test(`evaluate() reports a key shared across a shadow boundary in one document`,
 
   const document = h.document([light, <div>{h.shadow([shadowed])}</div>]);
 
-  t.deepEqual(await evaluate(R120, { document }), [
-    failed(R120, light, {
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, light, {
       1: Outcomes.HasNonUniqueAccesskeys(["a"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
     }),
-    failed(R120, shadowed, {
+    failed(R122, shadowed, {
       1: Outcomes.HasNonUniqueAccesskeys(["a"]),
       2: Outcomes.HasSingleCharacterAccesskeys,
       3: Outcomes.HasDistinctAccesskeys,
@@ -438,11 +438,11 @@ test(`evaluate() reports a key shared across a shadow boundary in one document`,
 test(`evaluate() is inapplicable to a document with no access key`, async (t) => {
   const document = h.document([<button>Foo</button>]);
 
-  t.deepEqual(await evaluate(R120, { document }), [inapplicable(R120)]);
+  t.deepEqual(await evaluate(R122, { document }), [inapplicable(R122)]);
 });
 
 test(`evaluate() is inapplicable to an access key that is only whitespace`, async (t) => {
   const document = h.document([<button accesskey=" ">Foo</button>]);
 
-  t.deepEqual(await evaluate(R120, { document }), [inapplicable(R120)]);
+  t.deepEqual(await evaluate(R122, { document }), [inapplicable(R122)]);
 });
diff --git a/packages/alfa-rules/test/tsconfig.json b/packages/alfa-rules/test/tsconfig.json
index c2bb404ca2..5fbc024dce 100644
--- a/packages/alfa-rules/test/tsconfig.json
+++ b/packages/alfa-rules/test/tsconfig.json
@@ -124,7 +124,8 @@
     "./sia-r116/rule.spec.tsx",
     "./sia-r117/rule.spec.tsx",
     "./sia-r118/rule.spec.tsx",
-    "./sia-r121/rule.spec.tsx"
+    "./sia-r121/rule.spec.tsx",
+    "./sia-r122/rule.spec.tsx"
   ],
   "references": [
     { "path": "../src" },

From 021f1f11bcbdb8e3d8721e142c6bd1dc983dacf1 Mon Sep 17 00:00:00 2001
From: pooya-si <pahm@siteimprove.com>
Date: Thu, 24 Sep 2026 11:15:30 -0400
Subject: [PATCH 09/10] [11Y-12317] [11Y-12318] Make experimental

---
 .changeset/brave-lists-gather.md         |  2 +-
 .changeset/lucky-keys-listen.md          |  2 +-
 packages/alfa-rules/src/experimental.ts  | 17 ++++++++++++++++-
 packages/alfa-rules/src/rules.ts         |  4 ----
 packages/alfa-rules/src/sia-r121/rule.ts |  2 +-
 packages/alfa-rules/src/sia-r122/rule.ts |  2 +-
 6 files changed, 20 insertions(+), 9 deletions(-)

diff --git a/.changeset/brave-lists-gather.md b/.changeset/brave-lists-gather.md
index df48b7b40b..dcdfe1bcf6 100644
--- a/.changeset/brave-lists-gather.md
+++ b/.changeset/brave-lists-gather.md
@@ -2,7 +2,7 @@
 "@siteimprove/alfa-rules": minor
 ---
 
-**Added:** The new rule R121 checks that `<ul>`, `<ol>` and `<dl>` elements only contain the children allowed by the HTML content model.
+**Added:** A new experimental rule SIA-R121 is available. It checks that `<ul>`, `<ol>` and `<dl>` elements only contain the children allowed by the HTML content model.
 
 The rule follows the content model as the HTML specification states it, rather than a relaxed reading of it:
 
diff --git a/.changeset/lucky-keys-listen.md b/.changeset/lucky-keys-listen.md
index fb4503cd7f..74d6f0ccbd 100644
--- a/.changeset/lucky-keys-listen.md
+++ b/.changeset/lucky-keys-listen.md
@@ -2,7 +2,7 @@
 "@siteimprove/alfa-rules": minor
 ---
 
-**Added:** The new rule R122 checks that the access keys an element declares are usable.
+**Added:** A new experimental rule SIA-R122 is available. It checks that the access keys an element declares are usable.
 
 It makes three checks. No other element may declare the same key, since two elements competing for one key means at most one of them can be reached and which one wins is left to the user agent. Each key must be a single character, since anything longer is not a key a user can press. And an element may not declare the same key twice.
 
diff --git a/packages/alfa-rules/src/experimental.ts b/packages/alfa-rules/src/experimental.ts
index f1b4062fcf..d1e3fd427f 100755
--- a/packages/alfa-rules/src/experimental.ts
+++ b/packages/alfa-rules/src/experimental.ts
@@ -9,5 +9,20 @@ import R114 from "./sia-r114/rule.ts";
 import R115 from "./sia-r115/rule.ts";
 import R117 from "./sia-r117/rule.ts";
 import R118 from "./sia-r118/rule.ts";
+import R121 from "./sia-r121/rule.ts";
+import R122 from "./sia-r122/rule.ts";
 
-export { ER8, ER87, R82, R98, R101, R109, R114, R115, R117, R118 };
\ No newline at end of file
+export {
+  ER8,
+  ER87,
+  R82,
+  R98,
+  R101,
+  R109,
+  R114,
+  R115,
+  R117,
+  R118,
+  R121,
+  R122,
+};
diff --git a/packages/alfa-rules/src/rules.ts b/packages/alfa-rules/src/rules.ts
index 388aeb5023..ede4741e9a 100644
--- a/packages/alfa-rules/src/rules.ts
+++ b/packages/alfa-rules/src/rules.ts
@@ -87,8 +87,6 @@ import R110 from "./sia-r110/rule.ts";
 import R111 from "./sia-r111/rule.ts";
 import R113 from "./sia-r113/rule.ts";
 import R116 from "./sia-r116/rule.ts";
-import R121 from "./sia-r121/rule.ts";
-import R122 from "./sia-r122/rule.ts";
 
 export {
   R1,
@@ -180,6 +178,4 @@ export {
   R111,
   R113,
   R116,
-  R121,
-  R122,
 };
diff --git a/packages/alfa-rules/src/sia-r121/rule.ts b/packages/alfa-rules/src/sia-r121/rule.ts
index 3f1adac1cf..42ce6fc345 100644
--- a/packages/alfa-rules/src/sia-r121/rule.ts
+++ b/packages/alfa-rules/src/sia-r121/rule.ts
@@ -48,7 +48,7 @@ const { getElementDescendants } = Query;
 export default Rule.Atomic.of<Page, Element>({
   uri: "https://alfa.siteimprove.com/rules/sia-r121",
   requirements: [Criterion.of("1.3.1"), EAA.of("9.1.3.1"), Technique.of("H40")],
-  tags: [Scope.Component, Stability.Stable],
+  tags: [Scope.Component, Stability.Experimental],
   evaluate({ device, document }) {
     return {
       applicability() {
diff --git a/packages/alfa-rules/src/sia-r122/rule.ts b/packages/alfa-rules/src/sia-r122/rule.ts
index af7ab09aac..65b10aa09f 100644
--- a/packages/alfa-rules/src/sia-r122/rule.ts
+++ b/packages/alfa-rules/src/sia-r122/rule.ts
@@ -39,7 +39,7 @@ const { getElementDescendants } = Query;
 export default Rule.Atomic.of<Page, Element>({
   uri: "https://alfa.siteimprove.com/rules/sia-r122",
   requirements: [BestPractice.of("accesskey-unique")],
-  tags: [Scope.Page, Stability.Stable],
+  tags: [Scope.Page, Stability.Experimental],
   evaluate({ device, document }) {
     const elements = getElementDescendants(document, Node.fullTree)
       .filter(and(hasNamespace(Namespace.HTML), declaresAccesskey))

From d7be32a97b130a4a119a44408c8037d8c644d487 Mon Sep 17 00:00:00 2001
From: pooya-si <pahm@siteimprove.com>
Date: Thu, 24 Sep 2026 17:12:48 -0400
Subject: [PATCH 10/10] [11Y-12317] [11Y-12318] update md file.

---
 docs/review/api/alfa-rules.api.md        | 30 +++++++++++++++---------
 packages/alfa-rules/src/sia-r121/rule.ts |  7 +++++-
 2 files changed, 25 insertions(+), 12 deletions(-)

diff --git a/docs/review/api/alfa-rules.api.md b/docs/review/api/alfa-rules.api.md
index fd61503c0f..f4a989046e 100644
--- a/docs/review/api/alfa-rules.api.md
+++ b/docs/review/api/alfa-rules.api.md
@@ -71,20 +71,26 @@ const _default: Rule.Atomic<Page, Element_2<string>, {}, Element_2<string>>;
 // @public
 const _default_10: Rule.Atomic<Page, Element_2<string>, Question.Metadata, Element_2<string>>;
 
-// @public @deprecated (undocumented)
+// @public
 const _default_11: Rule.Atomic<Page, Element_2<string>, {}, Element_2<string>>;
 
-// @public @deprecated (undocumented)
+// @public
 const _default_12: Rule.Atomic<Page, Element_2<string>, {}, Element_2<string>>;
 
 // @public @deprecated (undocumented)
-const _default_13: Rule.Atomic<Page, Element_2<string>, Question.Metadata, Element_2<string>>;
+const _default_13: Rule.Atomic<Page, Element_2<string>, {}, Element_2<string>>;
+
+// @public @deprecated (undocumented)
+const _default_14: Rule.Atomic<Page, Element_2<string>, {}, Element_2<string>>;
+
+// @public @deprecated (undocumented)
+const _default_15: Rule.Atomic<Page, Element_2<string>, Question.Metadata, Element_2<string>>;
 
 // @public @deprecated (undocumented)
-const _default_14: Rule.Atomic<Page, Element_2<string>, Question.Metadata, Element_2<string>>;
+const _default_16: Rule.Atomic<Page, Element_2<string>, Question.Metadata, Element_2<string>>;
 
 // @public @deprecated (undocumented)
-const _default_15: Rule.Atomic<Page, Text_2, {}, Text_2>;
+const _default_17: Rule.Atomic<Page, Text_2, {}, Text_2>;
 
 // @public
 const _default_2: Rule.Atomic<Page, Document_2, Question.Metadata, Element_2<string>>;
@@ -112,11 +118,11 @@ const _default_9: Rule.Atomic<Page, Element_2<string>, Question.Metadata, Elemen
 
 declare namespace deprecatedRules {
     export {
-        _default_11 as DR3,
-        _default_12 as DR6,
-        _default_13 as DR34,
-        _default_14 as DR36,
-        _default_15 as DR83
+        _default_13 as DR3,
+        _default_14 as DR6,
+        _default_15 as DR34,
+        _default_16 as DR36,
+        _default_17 as DR83
     }
 }
 export { deprecatedRules }
@@ -156,7 +162,9 @@ declare namespace experimentalRules {
         _default_7 as R114,
         _default_8 as R115,
         _default_9 as R117,
-        _default_10 as R118
+        _default_10 as R118,
+        _default_11 as R121,
+        _default_12 as R122
     }
 }
 export { experimentalRules }
diff --git a/packages/alfa-rules/src/sia-r121/rule.ts b/packages/alfa-rules/src/sia-r121/rule.ts
index 42ce6fc345..70df51f90c 100644
--- a/packages/alfa-rules/src/sia-r121/rule.ts
+++ b/packages/alfa-rules/src/sia-r121/rule.ts
@@ -47,7 +47,12 @@ const { getElementDescendants } = Query;
  */
 export default Rule.Atomic.of<Page, Element>({
   uri: "https://alfa.siteimprove.com/rules/sia-r121",
-  requirements: [Criterion.of("1.3.1"), EAA.of("9.1.3.1"), Technique.of("H40")],
+  requirements: [
+    Criterion.of("1.3.1"),
+    EAA.of("9.1.3.1"),
+    Technique.of("H40"),
+    Technique.of("H48"),
+  ],
   tags: [Scope.Component, Stability.Experimental],
   evaluate({ device, document }) {
     return {
