pour-engine 1.19.0 → 1.20.0

package/engine/COVERAGE.md

@@ -12,7 +12,7 @@ meaning that only a person can settle, even where a rule decides most real pages
 
 | SC | Name | Level | Coverage | Rules |
 |---|---|---|---|---|
-| 1.1.1 | [Non-text Content](https://www.w3.org/WAI/WCAG22/Understanding/non-text-content.html) | A | Partially automated | area-alt, image-alt, input-image-alt, object-alt, svg-img-alt |
+| 1.1.1 | [Non-text Content](https://www.w3.org/WAI/WCAG22/Understanding/non-text-content.html) | A | Partially automated | area-alt, canvas-alt, embed-alt, image-alt, input-image-alt, object-alt, svg-img-alt |
 | 1.2.1 | [Audio-only and Video-only (Prerecorded)](https://www.w3.org/WAI/WCAG22/Understanding/audio-only-and-video-only-prerecorded.html) | A | Manual review | — |
 | 1.2.2 | [Captions (Prerecorded)](https://www.w3.org/WAI/WCAG22/Understanding/captions-prerecorded.html) | A | Partially automated | media-captions |
 | 1.2.3 | [Audio Description or Media Alternative (Prerecorded)](https://www.w3.org/WAI/WCAG22/Understanding/audio-description-or-media-alternative-prerecorded.html) | A | Manual review | — |
@@ -51,7 +51,7 @@ meaning that only a person can settle, even where a rule decides most real pages
 | 2.1.3 | [Keyboard (No Exception)](https://www.w3.org/WAI/WCAG22/Understanding/keyboard-no-exception.html) | AAA | Partially automated | scrollable-region-focusable |
 | 2.1.4 | [Character Key Shortcuts](https://www.w3.org/WAI/WCAG22/Understanding/character-key-shortcuts.html) | A | Manual review | — |
 | 2.2.1 | [Timing Adjustable](https://www.w3.org/WAI/WCAG22/Understanding/timing-adjustable.html) | A | Partially automated | meta-refresh |
-| 2.2.2 | [Pause, Stop, Hide](https://www.w3.org/WAI/WCAG22/Understanding/pause-stop-hide.html) | A | Partially automated | pause-stop-hide |
+| 2.2.2 | [Pause, Stop, Hide](https://www.w3.org/WAI/WCAG22/Understanding/pause-stop-hide.html) | A | Partially automated | pause-stop-hide, video-loop-motion |
 | 2.2.3 | [No Timing](https://www.w3.org/WAI/WCAG22/Understanding/no-timing.html) | AAA | Manual review | — |
 | 2.2.4 | [Interruptions](https://www.w3.org/WAI/WCAG22/Understanding/interruptions.html) | AAA | Manual review | — |
 | 2.2.5 | [Re-authenticating](https://www.w3.org/WAI/WCAG22/Understanding/re-authenticating.html) | AAA | Manual review | — |
@@ -61,7 +61,7 @@ meaning that only a person can settle, even where a rule decides most real pages
 | 2.3.3 | [Animation from Interactions](https://www.w3.org/WAI/WCAG22/Understanding/animation-from-interactions.html) | AAA | Manual review | — |
 | 2.4.1 | [Bypass Blocks](https://www.w3.org/WAI/WCAG22/Understanding/bypass-blocks.html) | A | Partially automated | bypass-blocks |
 | 2.4.2 | [Page Titled](https://www.w3.org/WAI/WCAG22/Understanding/page-titled.html) | A | Partially automated | document-title |
-| 2.4.3 | [Focus Order](https://www.w3.org/WAI/WCAG22/Understanding/focus-order.html) | A | Manual review | — |
+| 2.4.3 | [Focus Order](https://www.w3.org/WAI/WCAG22/Understanding/focus-order.html) | A | Partially automated | visual-order-divergence |
 | 2.4.4 | [Link Purpose (In Context)](https://www.w3.org/WAI/WCAG22/Understanding/link-purpose-in-context.html) | A | Partially automated | area-alt, link-name, link-text-generic |
 | 2.4.5 | [Multiple Ways](https://www.w3.org/WAI/WCAG22/Understanding/multiple-ways.html) | AA | Manual review | — |
 | 2.4.6 | [Headings and Labels](https://www.w3.org/WAI/WCAG22/Understanding/headings-and-labels.html) | AA | Manual review | — |
@@ -91,13 +91,13 @@ meaning that only a person can settle, even where a rule decides most real pages
 | 3.1.4 | [Abbreviations](https://www.w3.org/WAI/WCAG22/Understanding/abbreviations.html) | AAA | Manual review | — |
 | 3.1.5 | [Reading Level](https://www.w3.org/WAI/WCAG22/Understanding/reading-level.html) | AAA | Manual review | — |
 | 3.1.6 | [Pronunciation](https://www.w3.org/WAI/WCAG22/Understanding/pronunciation.html) | AAA | Manual review | — |
-| 3.2.1 | [On Focus](https://www.w3.org/WAI/WCAG22/Understanding/on-focus.html) | A | Manual review | — |
-| 3.2.2 | [On Input](https://www.w3.org/WAI/WCAG22/Understanding/on-input.html) | A | Manual review | — |
+| 3.2.1 | [On Focus](https://www.w3.org/WAI/WCAG22/Understanding/on-focus.html) | A | Partially automated | on-input-navigation |
+| 3.2.2 | [On Input](https://www.w3.org/WAI/WCAG22/Understanding/on-input.html) | A | Partially automated | on-input-navigation |
 | 3.2.3 | [Consistent Navigation](https://www.w3.org/WAI/WCAG22/Understanding/consistent-navigation.html) | AA | Manual review | — |
 | 3.2.4 | [Consistent Identification](https://www.w3.org/WAI/WCAG22/Understanding/consistent-identification.html) | AA | Manual review | — |
 | 3.2.5 | [Change on Request](https://www.w3.org/WAI/WCAG22/Understanding/change-on-request.html) | AAA | Manual review | — |
 | 3.2.6 | [Consistent Help](https://www.w3.org/WAI/WCAG22/Understanding/consistent-help.html) | A | Manual review | — |
-| 3.3.1 | [Error Identification](https://www.w3.org/WAI/WCAG22/Understanding/error-identification.html) | A | Manual review | — |
+| 3.3.1 | [Error Identification](https://www.w3.org/WAI/WCAG22/Understanding/error-identification.html) | A | Partially automated | error-message-linkage |
 | 3.3.2 | [Labels or Instructions](https://www.w3.org/WAI/WCAG22/Understanding/labels-or-instructions.html) | A | Partially automated | form-label |
 | 3.3.3 | [Error Suggestion](https://www.w3.org/WAI/WCAG22/Understanding/error-suggestion.html) | AA | Manual review | — |
 | 3.3.4 | [Error Prevention (Legal, Financial, Data)](https://www.w3.org/WAI/WCAG22/Understanding/error-prevention-legal-financial-data.html) | AA | Manual review | — |
@@ -111,7 +111,7 @@ meaning that only a person can settle, even where a rule decides most real pages
 
 | SC | Name | Level | Coverage | Rules |
 |---|---|---|---|---|
-| 4.1.2 | [Name, Role, Value](https://www.w3.org/WAI/WCAG22/Understanding/name-role-value.html) | A | Partially automated | input-image-alt, form-label, link-name, aria-allowed-attr, aria-attr-valid, aria-field-name, aria-hidden-focus, aria-valid-refs, button-name, dialog-name, frame-title, label-for-valid, nested-interactive, role-required-aria, valid-role |
+| 4.1.2 | [Name, Role, Value](https://www.w3.org/WAI/WCAG22/Understanding/name-role-value.html) | A | Partially automated | input-image-alt, form-label, link-name, aria-allowed-attr, aria-attr-valid, aria-field-name, aria-hidden-focus, aria-label-misuse, aria-valid-refs, button-name, composite-widget-name, dialog-name, frame-title, label-for-valid, nested-interactive, role-required-aria, summary-name, valid-role |
 | 4.1.3 | [Status Messages](https://www.w3.org/WAI/WCAG22/Understanding/status-messages.html) | AA | Manual review | — |
 
-**Totals:** 30 partially automated · 56 manual — with 74 rules.
+**Totals:** 34 partially automated · 52 manual — with 82 rules.

package/engine/README.md

@@ -8,7 +8,11 @@ the product's only engine.
 Section 508, EN 301 549, or other standards. The full WCAG 2.2 catalog (all
 86 success criteria) lives in `wcag22.js`, and `COVERAGE.md` (generated by
 `node scripts/wcag-coverage.js`) shows exactly which criteria are automated,
-partially automated, or need human review.
+partially automated, or need human review. `AUDIT.html` is the latest full
+spec-sweep audit of every rule against the spec — over-violation,
+under-violation, and what the engine cannot test. It is a self-contained
+page: open it straight from disk in any browser. Regenerated by running
+the `spec-sweep` skill.
 
 ## Provenance
 

package/engine/rules/index.js

@@ -84,6 +84,16 @@ import reflow from './wcag/1.4.10-reflow.js';
 import focusVisible from './wcag/2.4.7-focus-visible.js';
 import focusNotObscured from './wcag/2.4.11-focus-not-obscured.js';
 import authFieldObstruction from './wcag/3.3.8-auth-field-obstruction.js';
+// 2026-08-10 spec-sweep batch: the six missing failure families plus the two
+// state-dependent heuristics the sweep judged automatable (see COVERAGE.md).
+import embedAlt from './wcag/1.1.1-embed-alt.js';
+import canvasAlt from './wcag/1.1.1-canvas-alt.js';
+import videoLoopMotion from './wcag/2.2.2-video-loop-motion.js';
+import visualOrderDivergence from './wcag/2.4.3-visual-order-divergence.js';
+import onInputNavigation from './wcag/3.2.2-on-input-navigation.js';
+import errorMessageLinkage from './wcag/3.3.1-error-message-linkage.js';
+import compositeWidgetName from './wcag/4.1.2-composite-widget-name.js';
+import summaryName from './wcag/4.1.2-summary-name.js';
 
 // --- Best practice ---
 import headingOrder from './best-practice/heading-order.js';
@@ -171,6 +181,14 @@ export default [
   focusVisible,
   focusNotObscured,
   authFieldObstruction,
+  embedAlt,
+  canvasAlt,
+  videoLoopMotion,
+  visualOrderDivergence,
+  onInputNavigation,
+  errorMessageLinkage,
+  compositeWidgetName,
+  summaryName,
   contrastEnhanced,
   targetSizeEnhanced,
   headingOrder,

package/engine/rules/wcag/1.1.1-canvas-alt.js

@@ -0,0 +1,43 @@
+// WCAG SC 1.1.1 Non-text Content (Level A)
+// A roleless <canvas> with no name and no fallback content is the default
+// output of every chart library, and it reaches assistive technology as
+// nothing at all. Whether that is a failure is exactly the question the
+// roleless-<svg> branch of svg-img-alt already models: a WebGL backdrop is
+// decorative, a revenue chart is the content of the page, and no static
+// pass can tell them apart. Same shape, same verdict — review, with the
+// same escape hatches (fallback content, a named enclosing control, or an
+// explicit decorative/labelled role).
+//
+// <canvas role="img"> without a name is already a hard fail via
+// svg-img-alt's [role="img"] arm; this rule only owns the silent default.
+// A size floor keeps sparkline-and-effect noise out: tiny canvases are
+// bullets and flourishes, and flagging them all would bury the chart that
+// matters.
+export default {
+  id: 'canvas-alt',
+  impact: 'moderate',
+  tags: ['wcag2a', 'wcag111'],
+  help: 'Meaningful <canvas> graphics need an accessible name or fallback',
+  helpUrl: 'https://www.w3.org/WAI/WCAG22/Understanding/non-text-content.html',
+  selector: 'canvas:not([role])',
+  evaluate(element, { accessibleName }) {
+    if (accessibleName(element)) return { status: 'pass' };
+    // Fallback content inside <canvas> is what AT reads — but chart
+    // libraries put their bootstrap <script> inside the canvas too, and
+    // script text is not fallback anyone hears.
+    const fallback = [...element.childNodes]
+      .filter((node) => !/^(SCRIPT|STYLE|TEMPLATE)$/.test(node.nodeName))
+      .map((node) => node.textContent).join('').trim();
+    if (fallback) return { status: 'pass' };
+    // Icon-work inside a control the name already covers.
+    const control = element.closest('a[href], button, [role="button"], [role="link"]');
+    if (control && accessibleName(control)) return { status: 'pass' };
+    const rect = element.getBoundingClientRect();
+    if (rect.width < 32 || rect.height < 32) return { status: 'pass' };
+    return {
+      status: 'incomplete',
+      message: 'This canvas has no accessible name, no fallback content, and is not marked decorative — if it draws a chart or diagram, screen reader users get nothing at all.',
+      fix: 'If decorative, add aria-hidden="true". If meaningful, add role="img" with aria-label="…", or put a text alternative inside the <canvas> as fallback content.',
+    };
+  },
+};

package/engine/rules/wcag/1.1.1-embed-alt.js

@@ -0,0 +1,42 @@
+// WCAG SC 1.1.1 Non-text Content (Level A)
+// <embed> is the last uncovered plugin-content element: img, svg, area,
+// object and input[type=image] all have name rules, and a nameless <embed>
+// is the same provable gap — assistive technology can tell users nothing
+// about what the plugin renders.
+//
+// One honest asymmetry with object-alt: an embed that declares TEXT content
+// (type="text/…") embeds a document, not non-text content, so 1.1.1's
+// applicability is itself in question there. That case asks instead of
+// asserting — the user still deserves to know what the embedded document
+// is, but no criterion provably fails.
+export default {
+  id: 'embed-alt',
+  impact: 'serious',
+  tags: ['wcag2a', 'wcag111'],
+  help: '<embed> needs an accessible name',
+  helpUrl: 'https://www.w3.org/WAI/WCAG22/Understanding/non-text-content.html',
+  selector: 'embed',
+  evaluate(element, { accessibleName }) {
+    if (accessibleName(element)) return { status: 'pass' };
+    const type = (element.getAttribute('type') ?? '').trim().toLowerCase();
+    const src = (element.getAttribute('src') ?? '').split(/[?#]/)[0].toLowerCase();
+    // Document formats: text/*, PDF, XHTML — and typeless embeds whose src
+    // extension says document. All carry text, so 1.1.1's applicability is
+    // the question, and the question goes to a human.
+    const isDocument = type.startsWith('text/')
+      || type === 'application/pdf' || type === 'application/xhtml+xml'
+      || (!type && /\.(html?|xhtml|pdf|txt)$/.test(src));
+    if (isDocument) {
+      return {
+        status: 'incomplete',
+        message: 'This <embed> renders a text document but has no accessible name — assistive technology users get no indication of what the embedded document is. Check it is identified in the surrounding context.',
+        fix: 'Add title="…" naming the embedded document.',
+      };
+    }
+    return {
+      status: 'fail',
+      message: 'This <embed> has no accessible name — screen readers cannot tell users what the embedded content is.',
+      fix: 'Add title="…" (or aria-label) describing what the embed shows.',
+    };
+  },
+};

package/engine/rules/wcag/2.2.2-video-loop-motion.js

@@ -0,0 +1,40 @@
+// WCAG SC 2.2.2 Pause, Stop, Hide (Level A)
+// The muted background hero video. audio-control (1.4.2) rightly passes it:
+// that criterion is about SOUND, and a muted element makes none. But
+// autoplay + loop is moving content that starts automatically and never
+// ends, which settles clauses 1 and 2 of 2.2.2 from the markup alone —
+// exactly as an infinite CSS animation does. Clause 3's pause mechanism may
+// be any control anywhere on the page (a hero often has one), so the
+// finding goes to a human with the evidence attached, never asserted: the
+// same verdict discipline as pause-stop-hide's ticker branch.
+//
+// A <video controls> ships its own pause button and is out of the selector.
+// Icon-scale playback (tiny inline previews) is left alone for the same
+// reason pause-stop-hide skips spinners: flagging every small moving
+// thumbnail would bury the full-bleed hero that matters. Silence there is
+// abstaining, not clearing.
+export default {
+  id: 'video-loop-motion',
+  impact: 'serious',
+  tags: ['wcag2a', 'wcag222'],
+  help: 'Looping autoplay video must be pausable',
+  helpUrl: 'https://www.w3.org/WAI/WCAG22/Understanding/pause-stop-hide.html',
+  selector: 'video[autoplay][loop]:not([controls])',
+  // Movement is a visual matter: an aria-hidden hero still moves on screen.
+  visibility: 'visual',
+  evaluate(element) {
+    // Icon scale means SMALL, not thin: a 1200×60 animated banner strip is
+    // a ticker, and only a video small on both axes is spinner-class.
+    const rect = element.getBoundingClientRect();
+    if (rect.width < 64 && rect.height < 64) return { status: 'pass' };
+    // Loaded but not playing: either the browser refused the autoplay or
+    // something on the page already paused it — in both cases nothing is
+    // moving, and a paused-by-a-control video is the mechanism working.
+    if (element.paused && element.readyState >= 2) return { status: 'pass' };
+    return {
+      status: 'incomplete',
+      message: 'This video auto-plays on a loop with no built-in controls: it starts by itself and never ends, so it runs well past the five seconds at which WCAG 2.2.2 requires a way to pause, stop or hide it. Check the page offers a pause control that reaches this video, or that the video is the only content presented.',
+      fix: 'Add controls, wire a visible pause button to it, or drop autoplay — and honour prefers-reduced-motion.',
+    };
+  },
+};

package/engine/rules/wcag/2.4.3-visual-order-divergence.js

@@ -0,0 +1,92 @@
+// WCAG SC 2.4.3 Focus Order (Level A) — the CSS-reordering slice
+// Whether a focus order "preserves meaning and operability" is a human
+// judgment over the whole page, and stays in the manual checklist. But one
+// documented failure shape is pure geometry: focusable siblings laid out by
+// flex/grid where CSS `order` or a reversed flow direction makes the VISUAL
+// order diverge from the DOM order that Tab actually follows. F44's
+// substance — sequences that jump against the layout — with the evidence
+// measurable.
+//
+// Deliberately narrow so it cannot fire on ordinary pages:
+//   - only siblings in the SAME flex/grid container are compared, so
+//     legitimate responsive reflow between separate regions never trips it;
+//   - only when the container/children actually use `order` or `*-reverse`
+//     — plain wrapping, floats and absolute positioning are not evidence;
+//   - the verdict is review, not violation: a reversed row of equivalent
+//     chips may preserve meaning perfectly well; that call is the human's.
+//
+// The narrowness has a known cost, accepted deliberately: focusables
+// wrapped one level deep (cards — flex container > div > a) never meet the
+// container as direct siblings and are not examined, and grid's native
+// reordering (explicit grid-row/column placement, grid-template-areas,
+// grid-auto-flow: dense) reorders without `order` or `*-reverse` and is not
+// treated as evidence. Both are honest gaps to widen later with measured
+// cases, not silently.
+const FLEXGRID = /^(inline-)?(flex|grid)$/;
+
+/** DOM-order focusable children grouped per flex/grid parent. */
+function tabbable(element) {
+  if (element.disabled || element.tabIndex < 0) return false;
+  return true;
+}
+
+/** Visual reading order of sibling rects: group into rows by vertical
+ *  overlap, rows top-to-bottom, within a row along the inline direction. */
+function visualSequence(entries, rightToLeft) {
+  const rows = [];
+  for (const entry of [...entries].sort((a, b) => a.rect.top - b.rect.top)) {
+    const row = rows.find((candidates) => {
+      const first = candidates[0].rect;
+      const overlap = Math.min(first.bottom, entry.rect.bottom) - Math.max(first.top, entry.rect.top);
+      return overlap > Math.min(first.height, entry.rect.height) / 2;
+    });
+    if (row) row.push(entry); else rows.push([entry]);
+  }
+  return rows.flatMap((row) => row.sort((a, b) =>
+    rightToLeft ? b.rect.right - a.rect.right : a.rect.left - b.rect.left));
+}
+
+export default {
+  id: 'visual-order-divergence',
+  impact: 'moderate',
+  tags: ['wcag2a', 'wcag243'],
+  help: 'CSS reordering should not make Tab jump against the visual order',
+  helpUrl: 'https://www.w3.org/WAI/WCAG22/Understanding/focus-order.html',
+  selector: 'a[href], button, input:not([type="hidden"]), select, textarea, summary, [tabindex]',
+  evaluateAll(elements) {
+    const outcomes = new Map();
+    const groups = new Map();
+    for (const element of elements) {
+      if (!tabbable(element)) continue;
+      const parent = element.parentElement;
+      if (!parent) continue;
+      if (!groups.has(parent)) groups.set(parent, []);
+      groups.get(parent).push(element);
+    }
+    for (const [parent, children] of groups) {
+      if (children.length < 2) continue;
+      const parentStyle = getComputedStyle(parent);
+      if (!FLEXGRID.test(parentStyle.display)) continue;
+      const reversed = /-reverse$/.test(parentStyle.flexDirection);
+      const entries = children
+        .map((element) => ({ element, style: getComputedStyle(element) }))
+        // Out-of-flow children have no place in the container's sequence.
+        .filter(({ style }) => style.position !== 'absolute' && style.position !== 'fixed')
+        .map((entry) => ({ ...entry, rect: entry.element.getBoundingClientRect() }))
+        .filter(({ rect }) => rect.width > 0 && rect.height > 0);
+      if (entries.length < 2) continue;
+      const usesOrder = entries.some(({ style }) => style.order !== '0');
+      if (!reversed && !usesOrder) continue;
+      const visual = visualSequence(entries, parentStyle.direction === 'rtl');
+      const diverges = visual.some((entry, i) => entry !== entries[i]);
+      if (!diverges) continue;
+      const cause = reversed ? `flex-direction: ${parentStyle.flexDirection}` : 'CSS order';
+      outcomes.set(entries[0].element, {
+        status: 'incomplete',
+        message: `Keyboard focus moves through these ${entries.length} controls in DOM order, but ${cause} arranges them differently on screen — Tab will jump against the visual layout. Check the focus sequence still preserves meaning and operability.`,
+        fix: 'Reorder the source to match the visual order instead of reordering with CSS, or confirm the divergence is harmless here.',
+      });
+    }
+    return elements.map((element) => outcomes.get(element) ?? { status: 'pass' });
+  },
+};

package/engine/rules/wcag/3.2.2-on-input-navigation.js

@@ -0,0 +1,47 @@
+// WCAG SC 3.2.2 On Input (Level A) — plus the inline slice of 3.2.1 On Focus
+// The classic jump menu: <select onchange="location.href=this.value">.
+// Changing a setting must not change the user's context unless they were
+// told beforehand (3.2.2), and merely receiving focus must never do so at
+// all (3.2.1).
+//
+// Only INLINE handlers are visible to a DOM audit — addEventListener
+// registrations can't be enumerated — and only a navigation-shaped handler
+// body is evidence. That makes this a rare, legacy, high-precision
+// signature: pages that never use inline handlers produce zero findings.
+// Both branches ask rather than assert: the handler string proves a
+// navigation call EXISTS in the code path, not that it runs unconditionally
+// (it may sit behind a confirm(), a flag, or a selected-value check), and
+// for 3.2.2 whether the user "has been advised beforehand" is text on the
+// page only a human can weigh.
+// Writes and calls only: reading location (analytics, hash checks) is not
+// navigation, so the pattern demands an assignment to location or one of
+// the navigating members/calls.
+const NAVIGATES = /\blocation\s*(=|\.\s*(href|assign|replace|reload))|\.(submit|requestSubmit)\s*\(|window\.open\s*\(/;
+
+export default {
+  id: 'on-input-navigation',
+  impact: 'serious',
+  tags: ['wcag2a', 'wcag322', 'wcag321'],
+  help: 'Changing or focusing a control must not unexpectedly change context',
+  helpUrl: 'https://www.w3.org/WAI/WCAG22/Understanding/on-input.html',
+  selector: 'select[onchange], input[onchange], textarea[onchange], select[oninput], input[oninput], textarea[oninput], [onfocus]',
+  evaluate(element) {
+    const onfocus = element.getAttribute('onfocus');
+    if (onfocus && NAVIGATES.test(onfocus)) {
+      return {
+        status: 'incomplete',
+        message: 'Focusing this element appears to navigate or submit (its onfocus handler reaches for location/submit). A change of context on focus alone fails WCAG 3.2.1 — check what the handler actually does when focus lands.',
+        fix: 'Trigger navigation from activation (click/Enter), never from focus.',
+      };
+    }
+    const onchange = element.getAttribute('onchange') ?? element.getAttribute('oninput');
+    if (onchange && NAVIGATES.test(onchange)) {
+      return {
+        status: 'incomplete',
+        message: 'Changing this control appears to navigate or submit (its onchange handler reaches for location/submit). WCAG 3.2.2 allows that only when users are told beforehand — check the page says so before the control.',
+        fix: 'Describe the behaviour before the control, or navigate from an explicit Go button instead of the change event.',
+      };
+    }
+    return { status: 'pass' };
+  },
+};

package/engine/rules/wcag/3.3.1-error-message-linkage.js

@@ -0,0 +1,69 @@
+// WCAG SC 3.3.1 Error Identification (Level A)
+// "If an input error is automatically detected, the item that is in error
+// is identified and the error is described to the user in text."
+//
+// A snapshot audit only ever sees this criterion in force when the page is
+// captured mid-error — a pristine form has no detected error and nothing to
+// judge. That makes the rule state-dependent and quiet by construction:
+// aria-invalid="true" IS the page saying "an error was detected here", and
+// from that admission two things become checkable.
+//
+//   - aria-errormessage must point at an element that exists, is visible,
+//     and says something (ARIA 1.2 requires the target to be displayed and
+//     pertinent while the field is invalid). A broken or empty target is a
+//     real authoring defect — the reference AT follows leads nowhere — but
+//     it is NOT a provable 3.3.1 failure: the Understanding document is
+//     explicit that programmatic association is not required, so adjacent
+//     visible text (which a machine cannot tie to the field) may satisfy
+//     the criterion on its own. Both shapes therefore go to review, with
+//     the broken reference named when present.
+//
+// aria-errormessage on a field that is NOT in an invalid state is inert:
+// user agents expose it only while the field is invalid, so a dangling
+// reference there breaks nothing a user receives (the engine's standing
+// inertness doctrine says pass, not assert). Invalid means any aria-invalid
+// value except false/undefined — "spelling" and "grammar" count.
+export default {
+  id: 'error-message-linkage',
+  impact: 'serious',
+  tags: ['wcag2a', 'wcag331'],
+  help: 'Fields marked invalid need their error described in text',
+  helpUrl: 'https://www.w3.org/WAI/WCAG22/Understanding/error-identification.html',
+  selector: '[aria-invalid="true"], [aria-invalid="spelling"], [aria-invalid="grammar"], [aria-errormessage]',
+  evaluate(element, { isVisible, accessibleName }) {
+    const root = element.getRootNode();
+    const state = element.getAttribute('aria-invalid');
+    const invalid = !!state && state !== 'false' && state !== 'undefined';
+    const targetsOf = (attribute) => (element.getAttribute(attribute) ?? '')
+      .trim().split(/\s+/).filter(Boolean)
+      .map((id) => root.getElementById?.(id))
+      .filter(Boolean);
+    // An image-of-text error message still describes the error; textContent
+    // alone would miss it, so fall back to the accessible-name walk.
+    const hasText = (targets) => targets.some((target) =>
+      isVisible(target) && (target.textContent.trim() || accessibleName(target)));
+
+    if (element.hasAttribute('aria-errormessage')) {
+      if (!invalid) return { status: 'pass' }; // inert until the field is invalid
+      const targets = targetsOf('aria-errormessage');
+      if (hasText(targets)) return { status: 'pass' };
+      return {
+        status: 'incomplete',
+        message: (targets.length
+          ? 'This field is marked invalid, but the element its aria-errormessage points at is empty or hidden — screen readers follow the reference and find no text.'
+          : 'This field is marked invalid, but its aria-errormessage points at nothing — screen readers follow the reference and find no text.')
+          + ' The error must be described in text: check a visible message exists, and fix the reference so it reaches assistive technology too.',
+        fix: 'Point aria-errormessage at the visible element containing the error text, and keep that element populated while the field is invalid.',
+      };
+    }
+    // aria-invalid="true" with no aria-errormessage: a described-by message
+    // satisfies the criterion; with no linkage at all, the error may still
+    // sit in adjacent text only a human can connect to the field.
+    if (hasText(targetsOf('aria-describedby'))) return { status: 'pass' };
+    return {
+      status: 'incomplete',
+      message: 'This field is marked invalid, but no error text is programmatically linked to it. The error must be described to the user in text — check a message exists, and associate it with aria-describedby or aria-errormessage so screen readers announce it with the field.',
+      fix: 'Add the error text near the field and reference it with aria-describedby (or aria-errormessage).',
+    };
+  },
+};

package/engine/rules/wcag/4.1.2-composite-widget-name.js

@@ -0,0 +1,32 @@
+// WCAG SC 4.1.2 Name, Role, Value (Level A)
+// The icon-only tab strip. Items of composite widgets — tabs, menu items,
+// options, tree items — take their name from their contents per ARIA 1.2,
+// and every one of these roles requires an accessible name. So an item
+// whose contents render no text and whose author supplied no label is
+// provably announced as an unnamed control: "tab", selected, of what?
+//
+// The container roles (tablist, menu, listbox, tree) are name-recommended
+// rather than required and are deliberately not judged here; the items are
+// where the binary, assertable failure lives.
+export default {
+  id: 'composite-widget-name',
+  impact: 'serious',
+  tags: ['wcag2a', 'wcag412'],
+  help: 'Tabs, menu items, options and tree items need an accessible name',
+  helpUrl: 'https://www.w3.org/WAI/WCAG22/Understanding/name-role-value.html',
+  selector: '[role="tab"], [role="menuitem"], [role="menuitemcheckbox"], [role="menuitemradio"], [role="option"], [role="treeitem"]',
+  evaluate(element, { accessibleName }) {
+    // <button role="tab"> and <a href role="tab"> are already selected by
+    // button-name/link-name (their selectors match the tag regardless of
+    // the role override) — one nameless control must not become two
+    // findings, so this rule owns only the div/span/li-style hosts.
+    if (element.matches('button, a[href], input, select, textarea, summary')) return { status: 'pass' };
+    if (accessibleName(element)) return { status: 'pass' };
+    const role = element.getAttribute('role');
+    return {
+      status: 'fail',
+      message: `This ${role} has no accessible name — a screen reader announces an unnamed ${role}, and users cannot tell what choosing it does.`,
+      fix: 'Put text inside the element, or add aria-label="…" for icon-only items.',
+    };
+  },
+};

package/engine/rules/wcag/4.1.2-summary-name.js

@@ -0,0 +1,31 @@
+// WCAG SC 4.1.2 Name, Role, Value (Level A)
+// <summary> is the interactive disclosure control of <details> — focusable,
+// activatable, exposed to AT as a button-like widget — and button-name's
+// selector never reaches it. An icon-only summary (chevron glyph, no text,
+// no label) announces as an unnamed control.
+//
+// Only the FIRST summary child of a <details> is the control: the HTML spec
+// gives any further summary elements, and summaries outside <details>, no
+// special behaviour — they are plain content and owe no name. A <details>
+// with no summary at all also passes: the browser supplies its own default
+// label ("Details").
+export default {
+  id: 'summary-name',
+  impact: 'serious',
+  tags: ['wcag2a', 'wcag412'],
+  help: 'Disclosure controls (<summary>) need an accessible name',
+  helpUrl: 'https://www.w3.org/WAI/WCAG22/Understanding/name-role-value.html',
+  selector: 'summary',
+  evaluate(element, { accessibleName }) {
+    const details = element.parentElement;
+    const isControl = details?.tagName === 'DETAILS'
+      && details.querySelector(':scope > summary') === element;
+    if (!isControl) return { status: 'pass' };
+    if (accessibleName(element)) return { status: 'pass' };
+    return {
+      status: 'fail',
+      message: 'This disclosure control has no accessible name — a screen reader announces an unnamed button, and users cannot tell what it expands.',
+      fix: 'Put text inside the <summary>, or add aria-label="…" for icon-only disclosures.',
+    };
+  },
+};

package/engine/wcag22.js

@@ -69,7 +69,7 @@ export default [
   sc('2.3.3', 'Animation from Interactions', 'AAA', 'manual', '2.1'),
   sc('2.4.1', 'Bypass Blocks', 'A', 'partial'), // partial: "repeated across pages" can't be established from one page
   sc('2.4.2', 'Page Titled', 'A', 'partial'), // partial: document-title proves a title exists and catches known placeholders; whether a real one DESCRIBES the page needs a reader
-  sc('2.4.3', 'Focus Order', 'A', 'manual'), // no rule automates this yet; order judgment needs humans
+  sc('2.4.3', 'Focus Order', 'A', 'partial'), // visual-order-divergence flags CSS order/*-reverse against DOM order; whether an order preserves MEANING stays human
   sc('2.4.4', 'Link Purpose (In Context)', 'A', 'partial'),
   sc('2.4.5', 'Multiple Ways', 'AA', 'manual'),
   sc('2.4.6', 'Headings and Labels', 'AA', 'manual'),
@@ -95,13 +95,13 @@ export default [
   sc('3.1.4', 'Abbreviations', 'AAA', 'manual'),
   sc('3.1.5', 'Reading Level', 'AAA', 'manual'),
   sc('3.1.6', 'Pronunciation', 'AAA', 'manual'),
-  sc('3.2.1', 'On Focus', 'A', 'manual'),
-  sc('3.2.2', 'On Input', 'A', 'manual'),
+  sc('3.2.1', 'On Focus', 'A', 'partial'), // on-input-navigation flags inline onfocus handlers that navigate; addEventListener handlers are invisible to a DOM audit
+  sc('3.2.2', 'On Input', 'A', 'partial'), // on-input-navigation flags the inline jump-menu signature; "advised beforehand" stays a human call
   sc('3.2.3', 'Consistent Navigation', 'AA', 'manual'),
   sc('3.2.4', 'Consistent Identification', 'AA', 'manual'),
   sc('3.2.5', 'Change on Request', 'AAA', 'manual'),
   sc('3.2.6', 'Consistent Help', 'A', 'manual', '2.2'),
-  sc('3.3.1', 'Error Identification', 'A', 'manual'),
+  sc('3.3.1', 'Error Identification', 'A', 'partial'), // error-message-linkage proves broken aria-errormessage targets; only in force when the page is captured mid-error
   sc('3.3.2', 'Labels or Instructions', 'A', 'partial'),
   sc('3.3.3', 'Error Suggestion', 'AA', 'manual'),
   sc('3.3.4', 'Error Prevention (Legal, Financial, Data)', 'AA', 'manual'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pour-engine",
-  "version": "1.19.0",
+  "version": "1.20.0",
   "description": "Accessibility (WCAG 2.2) audit engine written from the W3C specifications — runs entirely in the browser, no dependencies.",
   "type": "module",
   "main": "engine/index.js",