Testland
Browse all skills & agents

ibm-equal-access-a11y

Authors and runs IBM Equal Access accessibility-checker scans - IBM's open-source a11y engine with WCAG 2.0 / 2.1 / 2.2 + US Section 508 rule sets, integrating with Node / Selenium / Puppeteer / Playwright / Karma / Cypress test runners. Distinguished by IBM's enterprise-tier rule coverage and Section 508 specificity. Use when the project ships to US federal / public-sector customers (Section 508 mandate) or when the team values IBM-branded a11y reporting.

Install with skills.sh (any agent)

npx skills add testland/qa --skill ibm-equal-access-a11y
View source

ibm-equal-access-a11y

Overview

IBM Equal Access provides an accessibility-checker as part of the broader Equal Access Toolkit, supporting a11y across "planning, design, development, and verification phases" (equal-access (opens in new window)).

The differentiator vs. axe-core / pa11y / Lighthouse is US Section 508 specificity (federal-procurement compliance for US agencies) and IBM-branded enterprise rule sets.

When to use

  • The project ships to US federal / public-sector customers under Section 508 procurement requirements.
  • An enterprise compliance program mandates IBM-branded reports.
  • The team uses Selenium / Puppeteer / Playwright and wants an alternative to axe-core for cross-checking.
  • Rule sets beyond WCAG (e.g. IBM's internal accessibility guidelines) are required.

For most projects without Section 508 / enterprise-IBM constraints, axe-a11y is the standard recommendation - larger ecosystem, simpler integration. IBM Equal Access becomes the right choice when the constraints above apply.

Install

npm install --save-dev accessibility-checker

(Per equal-access (opens in new window).)

For framework-specific wrappers:

FrameworkPackage
Cypresscypress-accessibility-checker
Karmabundled in accessibility-checker
Selenium / Puppeteer / Playwrightbundled in accessibility-checker

Authoring scans

Node / Puppeteer example

const { ace, getCompliance } = require('accessibility-checker');

(async () => {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.goto('https://example.com');

  const results = await getCompliance(page, 'My scan label');

  if (results.report.fail.length > 0) {
    console.error('a11y violations:', results.report.fail);
    process.exit(1);
  }

  await browser.close();
})();

(Adapted from equal-access (opens in new window).)

Configuration

.achecker.yml at the project root sets project-wide options:

ruleArchive: latest                  # or a specific version
policies:
  - WCAG_2_2                         # primary; enable per project's compliance target
  - WCAG_2_1
  - IBM_Accessibility_2_2_2          # IBM's superset
failLevels:
  - violation
  - potentialviolation
reportLevels:
  - violation
  - potentialviolation
  - recommendation
  - potentialrecommendation
captureScreenshots: false
outputFormat:
  - json
  - html
outputFolder: a11y-reports

Rule sets / policies

Per equal-access (opens in new window), available policies include:

PolicyCoverage
WCAG_2_0WCAG 2.0 baseline.
WCAG_2_1WCAG 2.1 (adds mobile / vision-related SCs).
WCAG_2_2WCAG 2.2 (adds auth + drag + target-size SCs).
IBM_AccessibilityIBM's superset including beyond-WCAG rules.
IBM_Accessibility_2_2_2IBM's WCAG-2.2-aligned set.

US Section 508 alignment is via the IBM-branded policies (the toolkit's compliance documentation maps Section 508 to specific rule combinations).

Results structure

getCompliance() returns:

{
  "label": "My scan label",
  "report": {
    "scanID": "abc-123",
    "toolID": "accessibility-checker-v3.0.0",
    "summary": {
      "URL": "https://example.com/",
      "counts": {
        "violation": 5,
        "potentialviolation": 3,
        "recommendation": 12,
        "potentialrecommendation": 8,
        "manual": 2,
        "pass": 1843
      },
      "scanTime": 2341,
      "ruleArchive": "..."
    },
    "results": [
      {
        "ruleId": "WCAG20_Img_HasAlt",
        "level": "violation",
        "value": ["VIOLATION", "FAIL"],
        "message": "Image is missing alternative text.",
        "snippet": "<img src='...'>",
        "path": { "dom": "html/body/main[1]/img[2]" }
      }
    ]
  }
}
LevelSeverity
violationDefinite WCAG failure.
potentialviolationLikely failure; needs manual review.
recommendationBest-practice improvement.
potentialrecommendationLikely improvement.
manualIssues requiring manual review.

For CI gating, fail on violation (and optionally potentialviolation); aggregate the rest at the gate.

Test framework integration

Playwright

const { test } = require('@playwright/test');
const { getCompliance } = require('accessibility-checker');

test('checkout passes IBM Equal Access', async ({ page }) => {
  await page.goto('/checkout');
  const results = await getCompliance(page, 'checkout-page');

  const violations = results.report.results.filter(r => r.level === 'violation');
  expect(violations).toHaveLength(0);
});

Cypress (via wrapper)

import 'cypress-accessibility-checker';

it('checkout passes IBM Equal Access', () => {
  cy.visit('/checkout');
  cy.getCompliance().then(results => {
    expect(results.report.results.filter(r => r.level === 'violation')).to.have.length(0);
  });
});

CI integration

# .github/workflows/ibm-a11y.yml
name: ibm-a11y

on:
  pull_request:
  push:
    branches: [main]

jobs:
  ibm-equal-access:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5

      - uses: actions/setup-node@v4
        with:
          node-version: '20'

      - run: npm ci
      - run: npx playwright install --with-deps

      - name: Run a11y tests
        run: npx playwright test tests/a11y/ibm-equal-access/

      - name: Upload reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: ibm-a11y-reports
          path: a11y-reports/
          retention-days: 14

For the ratchet pattern (block only on net-new violations), pipe the JSON output to a11y-violation-gate.

Anti-patterns

Anti-patternWhy it failsFix
Asserting only violation count is 0Existing legacy debt blocks every PR.Use a11y-violation-gate ratchet.
Mixing IBM Equal Access with axe-core in the same gateSame issue can be flagged twice with different rule IDs; noise.Run IBM separately; cross-check at audit time, not at gate time.
Using IBM_Accessibility policy without justificationAdds rules beyond WCAG; CI fails on issues that aren't actual conformance failures.Default to WCAG_2_2; add IBM_Accessibility only when the team has explicit IBM-branded compliance requirements.
Skipping the manual levelItems needing human review go unreviewed.Track manual count; require sign-off from a human reviewer at release time.

Limitations

  • Smaller community than axe-core. Fewer Stack Overflow answers, fewer third-party integrations.
  • Heavier integration. The toolkit is comprehensive but the setup is more involved than axe-core's drop-in.
  • Section 508 specificity. This is also the strength - but for non-US-public-sector projects, the extra coverage may not be load-bearing.

References

  • equal-access (opens in new window) - main repo: install, supported test frameworks, rule archives.
  • IBM Equal Access Toolkit - https://www.ibm.com/able/toolkit/
  • US Section 508 - https://www.section508.gov/
  • axe-a11y, pa11y-a11y, lighthouse-a11y, wave-a11y - alternative scanners.
  • a11y-violation-gate - CI gate for ratchet-pattern blocking.

Related skills

a11y-violation-gate

Builds a CI gate that fails the build on **new** WCAG / a11y violations introduced by a PR while grandfathering pre-existing violations on a per-rule / per-page baseline. Aggregates verdicts from axe-core / pa11y / Lighthouse a11y / WAVE / IBM Equal Access scans. Use when a project has accumulated a11y debt and a strict "zero violations" gate would block every PR - the ratchet pattern lets the team ship while preventing regressions.

aria-authoring-patterns

Reference for the W3C ARIA Authoring Practices Guide (APG) - covers the 31 canonical interactive-widget patterns (Combobox, Dialog, Menu, Tabs, Tree, etc.), their required ARIA roles and states, the keyboard-interaction model per pattern, and the canonical-violations to watch for. Use when authoring a custom interactive widget that doesn't have a native HTML equivalent, or when reviewing one for ARIA correctness.

axe-a11y

Authors and runs axe-core accessibility scans - the most-deployed open-source a11y engine - via the `axe.run()` JavaScript API or the @axe-core/playwright / @axe-core/cli wrappers, parses the `violations[]` results into per-rule severity (critical / serious / moderate / minor), configures rule disable / disable-by-tag patterns, and emits JUnit-shaped output for CI gating. Use when the project ships UI tests in JavaScript / TypeScript and wants automated a11y coverage on every PR.

lighthouse-a11y

Configures Lighthouse CI's Accessibility category for automated accessibility testing (a11y / WCAG coverage) - `categories:accessibility` audits backed by axe-core (axe) - with per-URL minimum-score assertions (fail a build when a page's score drops below a threshold) and per-audit overrides, distinct from the Performance category that `lighthouse-perf` covers. Use when the project already runs Lighthouse CI for Web Vitals and the team wants to add accessibility coverage in the same pipeline rather than spinning up a separate scanner.

pa11y-a11y

Authors and runs pa11y accessibility scans - a CLI / Node.js tool that wraps HTML CodeSniffer (htmlcs) and / or axe-core engines - with `pa11y {url}` invocation, reporter selection (cli / csv / json / html / tsv), WCAG standard selection (WCAG2A / WCAG2AA / WCAG2AAA), and rule ignoring. Use when the project needs scriptable a11y scans without a full test framework, or when a Node-stack project wants an alternative to direct axe-core use.

screen-reader-test-author

Builds a screen-reader test narrative - a step-by-step manual test script for NVDA (Windows), JAWS (Windows), VoiceOver (macOS / iOS), or TalkBack (Android) - that exercises a specific user flow through a component or page and captures the expected announcement at each step. Use when authoring an accessibility-acceptance test the team will run before sign-off, OR when scripting a manual a11y audit.

wave-a11y

Runs WebAIM WAVE accessibility scans via the WAVE API or the browser-extension UI - produces visual overlay of errors / alerts / structural elements directly on the page, plus categorized JSON output for CI use. Use when the team values manual-review-friendly visual feedback (the WAVE overlay) alongside automated CI scans, or when a regulatory audit requires WebAIM-branded reports.

wcag-checklist-builder

Builds a per-component WCAG 2.2 accessibility checklist from a component spec - covers focus management, color contrast, ARIA roles & states, keyboard interaction, error handling, and live-region announcements - emitting a markdown checklist or YAML test plan that pairs with screen-reader-test-author for manual verification and the violation gate for automated scans. Use during component-spec review or pre-implementation acceptance.

wcag-color-contrast

Reference for WCAG 2.2 color-contrast conformance - covers SC 1.4.3 Contrast (Minimum, AA), 1.4.6 Contrast (Enhanced, AAA), 1.4.11 Non-text Contrast (AA), and 1.4.13 Content on Hover or Focus (AA) - with the canonical contrast ratios (4.5:1 normal text, 3:1 large text and UI components), measurement formula references, and bulk design-token checking patterns. Use when designing a color palette, reviewing a component for accessibility, or auditing existing CSS for contrast violations.

wcag-compliance-reporter

Builds a per-page WCAG 2.2 compliance score report by aggregating output from one or more accessibility scanners (axe-core / pa11y / lighthouse / WAVE / IBM Equal Access), pivoting violations by Success Criterion (1.4.3 contrast, 2.4.7 focus visible, etc.), grouping by conformance level (A / AA / AAA), reporting per-page coverage gaps explicitly (the "this page wasn't scanned" failure mode), and emitting both an executive summary and a per-page drill-down. Use after a multi-page accessibility scan - pa11y-ci, axe across a sitemap, lighthouse-batch - when the team needs a shareable conformance report rather than a per-page tool dump.

wcag-focus-trap

Reference for **intentional** focus management in modal / dialog / drawer / popover components - the canonical pattern that satisfies WCAG SC 2.4.3 (Focus Order) without violating SC 2.1.2 (No Keyboard Trap). Covers focus-on-open, focus-cycle-within-container, Escape-closes-and-restores, return-to-trigger, and inert-the-rest-of-the-page. Use when authoring or reviewing any component that displays content over the page (modals, drawers, popovers, command palettes).

wcag-keyboard-navigation

Reference catalog for WCAG 2.2 keyboard-navigation conformance - covers SC 2.1.1 (Keyboard), 2.1.2 (No Keyboard Trap), 2.1.4 (Character Key Shortcuts), 2.4.3 (Focus Order), 2.4.7 (Focus Visible), 2.4.11/2.4.12 (Focus Not Obscured) - with conformance levels (A/AA), test scripts, and per-criterion failure patterns. Use when authoring or reviewing keyboard-only interaction support.

widget-a11y-test-matrix

Per-widget manual accessibility test matrices where every row pairs one keystroke with the expected focus behavior, the expected NVDA announcement, the expected VoiceOver announcement, and the WCAG 2.2 success criterion that row verifies. Covers button, toggle button, checkbox, text input, modal dialog, menu button, and combobox archetypes, plus universal Tab traversal. Use when a rendered widget has cleared automated scanning and a tester needs a fill-in pass/fail sheet to run by hand against NVDA and VoiceOver.