# @devframes/plugin-a11y > [!WARNING] Experimental > This devframe is experimental and may change without a major version bump until > it stabilizes. An accessibility inspector built on [devframe](../../packages/devframe). It runs [axe-core](https://github.com/dequelabs/axe-core) against a user app and surfaces the violations in a [Solid](https://www.solidjs.com/) panel: - **Route-aware tracking**: buckets violations by `location.pathname` and tracks them as you navigate the user app (History-API patched, framework-neutral), persisted in `sessionStorage` so history survives reloads within a tab session. - **Dashboard + grouped violations**: a Dashboard tab (totals, severity breakdown, per-route inventory, scan controls) and a Violations tab listing every tracked route, grouped, with the active route marked. - **Select + highlight**: hover previews the offending element; ticking a violation's checkbox selects it, giving the card a distinct state and drawing globally-numbered badges over all its elements in the page. ``/`
` targets get a corner notice instead of a viewport-filling ring. - **Generate fix prompts**: a nav button gathers the selected violations (rule metadata, WCAG tags, docs, and each element's selector/markup/failure summary, grouped by route) into one paste-ready AI prompt in a dialog. - **Constant scanning**: a DOM `MutationObserver` plus debounced mouse/keyboard/touch rescans, toggleable from the Dashboard. - **WCAG 2.0–2.2 + best-practice**: the broadened axe tag set, with best-practice rules tagged and filterable. - **Console logging**: newly-appeared violations are logged (deduped) to the browser console. The scan + highlight loop works the same whether the devframe runs as a live dev server or as a baked static build. ## How it works Three pieces, two of them browser-side: | Piece | Runs in | Role | |-------|---------|------| | **Page script** (`src/inject`) | the user app's page | runs axe-core, tracks routes, owns the aggregate state, draws the preview + pinned rings | | **Panel** (`src/spa`) | the devtools iframe | Solid SPA: Dashboard + grouped violations, fires preview/pin/rescan | | **Node** (`src/index.ts`, `src/node`, `src/rpc`) | the node side | `get-config` RPC (impact taxonomy + runtime config): live in dev, baked in a static build | The page script and panel talk over devframe's in-page channel ([`devframe/in-page-channel`](../../packages/devframe/src/in-page-channel/index.ts), contract in [`src/shared/protocol.ts`](src/shared/protocol.ts)), not the devframe RPC backend. That is what keeps the live loop working in **both modes**: neither half needs a server to reach the other, only a same-origin handshake in the same tab. The page script owns the authoritative route → report map as the channel's shared state, which is replayed to late-joining panels and streamed as patches on every change, so the panel stays a pure render of it. devframe RPC carries the data model on top; `get-config` is a `static` function, so it resolves over WebSocket in dev and from the baked dump in a static build; the panel forwards its runtime-config slice to the page script over the channel, keeping the page script itself free of any RPC dependency. devframe deliberately provides no access to the user app's DOM, so the page script is the author-provided bridge into the user app's page. In a hub, the page script is the a11y dock's **client script**, and the definition declares it by path, so the hub serves it same-origin and `devframes: ['@devframes/plugin-a11y']` works with no host wiring. The hub's client runtime (`createDevframeClientRuntime` from `@devframes/hub/client`) then imports it into the host page and calls its default export with the client-script context. A host can also serve the module itself (e.g. via `/@fs/…` under Vite) by attaching `a11yClientScriptBundlePath` as a per-mount `clientScript`. Booted that way, the page script also mirrors the active route's scan into the hub's **messages feed**: a summary entry driven through the loading → idle lifecycle plus one entry per violated rule, carrying the impact-mapped level, WCAG tags as labels, and the first offending element's selector and bounding box (rendered by `@devframes/plugin-messages` when the hub mounts it). Each entry also carries a **navigation action**: clicking it in the messages panel activates the a11y dock (`hub:docks:activate`) deep-linked to the rule + route (or the Dashboard, for the summary). Both minimal hub examples do exactly this. Outside a hub, one `