npm - @a11y-skills/audit - Versions diffs - 0.2.0 → 0.3.1 - Mend

@a11y-skills/audit 0.2.0 → 0.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (35) hide show

package/CHANGELOG.md +54 -0
package/README.ja.md +52 -4
package/README.md +53 -4
package/dist/constants.d.ts +4 -0
package/dist/constants.js +104 -21
package/dist/index.d.ts +3 -1
package/dist/index.js +3 -1
package/dist/playwright/index.d.ts +1 -1
package/dist/playwright/index.js +1 -1
package/dist/playwright/runAutoPlayDetection.js +15 -4
package/dist/playwright/runAutocompleteAudit.js +46 -11
package/dist/playwright/runAxeAudit.d.ts +4 -0
package/dist/playwright/runAxeAudit.js +26 -30
package/dist/playwright/runFocusIndicatorCheck.d.ts +7 -0
package/dist/playwright/runFocusIndicatorCheck.js +98 -31
package/dist/playwright/runOrientationCheck.js +13 -7
package/dist/playwright/runReflowCheck.js +22 -12
package/dist/playwright/runTargetSizeCheck.js +49 -12
package/dist/playwright/runTextSpacingCheck.js +64 -10
package/dist/playwright/runTimeLimitDetector.js +56 -25
package/dist/playwright/runZoomCheck.js +46 -15
package/dist/schemas/index.d.ts +8 -1
package/dist/schemas/index.js +397 -292
package/dist/types.d.ts +137 -53
package/dist/types.js +9 -0
package/dist/utils/axe-format.d.ts +88 -0
package/dist/utils/axe-format.js +370 -0
package/dist/utils/layout.d.ts +2 -0
package/dist/utils/layout.js +26 -2
package/dist/utils/recommendations.js +2 -2
package/dist/utils/rule-registry.d.ts +216 -0
package/dist/utils/rule-registry.js +220 -0
package/dist/utils/test-harness.d.ts +2 -2
package/dist/utils/test-harness.js +5 -6
package/package.json +2 -1

package/dist/utils/axe-format.js ADDED Viewed

@@ -0,0 +1,370 @@
+/**
+ * Pure mappers from check-specific `details` to the axe-style buckets
+ * (`violations` / `incomplete` / `passes` / `inapplicable`), plus the envelope
+ * assembler and the opt-in cross-check merge.
+ *
+ * Everything here is browser-independent: the runners gather evidence into a
+ * details object, and these functions derive the normalized view from it.
+ * Because the details objects are part of the saved JSON, the buckets can be
+ * re-derived from a result file at any time.
+ */
+import { AUDIT_DISCLAIMER, HTML_SNIPPET_MAX_LENGTH } from '../constants.js';
+import { getRule } from './rule-registry.js';
+function emptyBuckets() {
+    return { violations: [], incomplete: [], passes: [], inapplicable: [] };
+}
+function ruleResult(key, nodes) {
+    const meta = getRule(key);
+    return {
+        id: meta.id,
+        impact: meta.impact,
+        description: meta.description,
+        help: meta.help,
+        helpUrl: meta.helpUrl,
+        tags: [...meta.tags],
+        nodes,
+    };
+}
+/**
+ * Route a rule's findings into the right bucket:
+ * not applicable → `inapplicable`, no findings → `passes`, findings →
+ * the registry's classification (or an explicit override).
+ */
+function bucketize(buckets, key, nodes, applicable, override) {
+    if (!applicable) {
+        buckets.inapplicable.push(ruleResult(key, []));
+        return;
+    }
+    if (nodes.length === 0) {
+        buckets.passes.push(ruleResult(key, []));
+        return;
+    }
+    const classification = override ?? getRule(key).classification;
+    (classification === 'violation'
+        ? buckets.violations
+        : buckets.incomplete).push(ruleResult(key, nodes));
+}
+/** Build a node from element evidence, synthesizing `html` when missing. */
+function toNode(el, failureSummary) {
+    const tag = (el.tagName ?? el.tag ?? 'element').toLowerCase();
+    const html = el.html && el.html.length > 0 ? el.html : `<${tag}>`;
+    return {
+        target: [el.selector],
+        html,
+        htmlTruncated: el.htmlTruncated ?? false,
+        failureSummary,
+    };
+}
+/** Build a page-level node (`target: ['html']`). */
+function pageNode(failureSummary) {
+    return {
+        target: ['html'],
+        html: '<html>',
+        htmlTruncated: false,
+        failureSummary,
+    };
+}
+function describeElement(ref) {
+    return `<${ref.tag.toLowerCase()}> "${ref.name}"`;
+}
+// =============================================================================
+// Envelope assembly
+// =============================================================================
+/** Assemble the common envelope from a check's details and buckets. */
+export function buildAuditResult(args) {
+    const { source, url, details, buckets, timestamp } = args;
+    const summary = {
+        violationCount: buckets.violations.length,
+        incompleteCount: buckets.incomplete.length,
+        passCount: buckets.passes.length,
+    };
+    if (buckets.checkedNodes !== undefined) {
+        summary.checkedNodes = buckets.checkedNodes;
+    }
+    return {
+        source,
+        url,
+        timestamp: timestamp ?? new Date().toISOString(),
+        violations: buckets.violations,
+        incomplete: buckets.incomplete,
+        passes: buckets.passes,
+        inapplicable: buckets.inapplicable,
+        summary,
+        details,
+        disclaimer: AUDIT_DISCLAIMER,
+    };
+}
+// =============================================================================
+// Per-check normalizers
+// =============================================================================
+export function normalizeFocusCheck(details) {
+    const buckets = emptyBuckets();
+    const applicable = details.totalFocusableElements > 0;
+    buckets.checkedNodes = details.totalFocusableElements;
+    bucketize(buckets, 'focus-visible', details.issues.map((el) => toNode(el, `${describeElement(el)} shows no computed-style change on focus ` +
+        '(outline, box-shadow, background-color). Verify manually whether a ' +
+        'visual focus indicator exists (pseudo-elements, canvas, or parent ' +
+        'changes are not detected).')), applicable);
+    bucketize(buckets, 'no-context-change-on-focus', details.onFocusViolations.map((v) => toNode(v.element, `Focusing ${describeElement(v.element)} triggered a ${v.changeType} ` +
+        `from ${v.fromUrl} to ${v.toUrl}.`)), applicable);
+    bucketize(buckets, 'focus-not-obscured', details.focusObscuredIssues.map((issue) => toNode(issue.element, `${describeElement(issue.element)} is ${(issue.obscuredRatio * 100).toFixed(0)}% ` +
+        `obscured when focused (by ${issue.overlaps
+            .map((o) => `<${o.obscuredBy.tag.toLowerCase()}>`)
+            .join(', ')}). Verify whether the focused element is hidden.`)), applicable);
+    return buckets;
+}
+export function normalizeReflowCheck(details) {
+    const buckets = emptyBuckets();
+    const overflowNodes = details.overflowingElements.map((el) => toNode(el, `<${el.tagName}> extends to ${el.rect.right}px in a ${el.viewportWidth}px ` +
+        `viewport (${el.reason}). Verify whether a two-dimensional layout ` +
+        'exception (table, map, diagram, ...) applies.'));
+    if (details.hasHorizontalScroll && overflowNodes.length === 0) {
+        overflowNodes.push(pageNode(`Document scrolls horizontally at ${details.viewport.width}px ` +
+            `(scrollWidth ${details.documentScrollWidth}px > clientWidth ` +
+            `${details.documentClientWidth}px). Verify whether an exception applies.`));
+    }
+    bucketize(buckets, 'reflow-overflow', overflowNodes, true);
+    bucketize(buckets, 'reflow-clipped-text', details.clippedTextElements.map((el) => toNode(el, `<${el.tagName}> clips its text at ${details.viewport.width}px ` +
+        `(scrollWidth ${el.scrollWidth}px > clientWidth ${el.clientWidth}px, ` +
+        `overflow: ${el.overflow}). Verify whether content is lost.`)), true);
+    return buckets;
+}
+export function normalizeTargetSizeCheck(details) {
+    const buckets = emptyBuckets();
+    const applicable = details.totalTargetsChecked > 0;
+    buckets.checkedNodes = details.totalTargetsChecked;
+    const minimumFailureSummary = (issue) => {
+        const base = `Target is ${issue.width}x${issue.height}px ` +
+            `(min dimension ${issue.minDimension}px, requirement 24px).`;
+        if (issue.exception) {
+            return (`${base} Possible '${issue.exception}' exception: ` +
+                `${issue.exceptionDetails ?? 'see manual review notes'}. Confirm manually.`);
+        }
+        return `${base} No exception detected, but the essential exception cannot be ruled out automatically.`;
+    };
+    // Minimum (2.5.8 AA): findings are fail-aa targets, with and without
+    // detected exceptions. Only 'ruled-out' assessments are confirmed violations.
+    const minimumIssues = [...details.failAA, ...details.exceptedTargets].filter((issue) => issue.level === 'fail-aa');
+    const confirmed = minimumIssues.filter((i) => i.exceptionAssessment === 'ruled-out');
+    const needsReview = minimumIssues.filter((i) => i.exceptionAssessment !== 'ruled-out');
+    if (!applicable) {
+        buckets.inapplicable.push(ruleResult('target-size-minimum', []));
+    }
+    else if (minimumIssues.length === 0) {
+        buckets.passes.push(ruleResult('target-size-minimum', []));
+    }
+    else {
+        if (confirmed.length > 0) {
+            buckets.violations.push(ruleResult('target-size-minimum', confirmed.map((i) => toNode(i, minimumFailureSummary(i)))));
+        }
+        if (needsReview.length > 0) {
+            buckets.incomplete.push(ruleResult('target-size-minimum', needsReview.map((i) => toNode(i, minimumFailureSummary(i)))));
+        }
+    }
+    // Enhanced (2.5.5 AAA): targets that pass AA but miss the 44px requirement.
+    // Targets already failing AA are reported under target-size-minimum only.
+    bucketize(buckets, 'target-size-enhanced', details.failAAAOnly.map((issue) => toNode(issue, `Target is ${issue.width}x${issue.height}px ` +
+        `(min dimension ${issue.minDimension}px, AAA requirement 44px). ` +
+        'Verify whether an SC 2.5.5 exception applies.')), applicable);
+    return buckets;
+}
+export function normalizeTextSpacingCheck(details) {
+    const buckets = emptyBuckets();
+    buckets.checkedNodes = details.totalElementsChecked;
+    bucketize(buckets, 'text-spacing', details.clippedElements.map((el) => toNode(el, `<${el.tagName}> clips its content (${el.issueType}) when WCAG 1.4.12 ` +
+        `text spacing is applied: ${el.afterMetrics.scrollWidth}x${el.afterMetrics.scrollHeight}px ` +
+        `content in a ${el.afterMetrics.clientWidth}x${el.afterMetrics.clientHeight}px box.`)), details.totalElementsChecked > 0);
+    return buckets;
+}
+export function normalizeZoomCheck(details) {
+    const buckets = emptyBuckets();
+    const nodes = details.clippedElements.map((el) => toNode(el, `<${el.tagName}> ${el.issueType === 'horizontal-scroll' ? 'overflows horizontally' : 'clips its content'} ` +
+        `at ${details.zoomFactor * 100}% zoom (scrollWidth ${el.scrollWidth}px > ` +
+        `clientWidth ${el.clientWidth}px). Verify whether content or ` +
+        'functionality is lost.'));
+    if (details.hasHorizontalScroll && nodes.length === 0) {
+        nodes.push(pageNode(`Document scrolls horizontally at ${details.zoomFactor * 100}% zoom ` +
+            `(scrollWidth ${details.documentScrollWidth}px > clientWidth ` +
+            `${details.documentClientWidth}px). Horizontal scrolling alone does ` +
+            'not fail SC 1.4.4 — verify whether text becomes unusable.'));
+    }
+    bucketize(buckets, 'resize-text', nodes, true);
+    return buckets;
+}
+export function normalizeOrientationCheck(details) {
+    const buckets = emptyBuckets();
+    const nodes = [];
+    if (details.hasOrientationLock) {
+        const state = details.lockDetectedIn === 'landscape'
+            ? details.landscape
+            : details.portrait;
+        const messagePart = state.lockMessageText
+            ? ` Lock message found: "${state.lockMessageText}".`
+            : '';
+        nodes.push(pageNode(`Content appears restricted to a single orientation ` +
+            `(detected in: ${details.lockDetectedIn}).${messagePart} Verify ` +
+            'whether the essential exception (SC 1.3.4) applies.'));
+    }
+    bucketize(buckets, 'orientation-lock', nodes, true);
+    return buckets;
+}
+export function normalizeAutocompleteAudit(details) {
+    const buckets = emptyBuckets();
+    const applicable = details.totalFieldsChecked > 0;
+    buckets.checkedNodes = details.totalFieldsChecked;
+    bucketize(buckets, 'autocomplete-invalid', details.invalidAutocomplete.map((field) => toNode(field, `autocomplete="${field.currentAutocomplete}" is not a valid token. ` +
+        `Expected "${field.expectedToken}" (purpose matched by ${field.matchedBy}).`)), applicable);
+    bucketize(buckets, 'autocomplete-missing', details.missingAutocomplete.map((field) => toNode(field, `Field appears to collect "${field.expectedToken}" (matched by ` +
+        `${field.matchedBy}) but has ${field.currentAutocomplete === null
+            ? 'no autocomplete attribute'
+            : `autocomplete="${field.currentAutocomplete}"`}. Confirm the field purpose manually.`)), applicable);
+    return buckets;
+}
+export function normalizeTimeLimitDetector(details) {
+    const buckets = emptyBuckets();
+    bucketize(buckets, 'meta-refresh', details.metaRefresh.map((meta) => ({
+        target: ['meta[http-equiv="refresh"]'],
+        html: meta.html || `<meta http-equiv="refresh" content="${meta.content}">`,
+        htmlTruncated: meta.htmlTruncated ?? false,
+        failureSummary: `Page refreshes${meta.url ? ` to ${meta.url}` : ''} after ${meta.seconds}s. ` +
+            'Verify whether the time limit can be turned off, adjusted, or extended, ' +
+            'or whether an SC 2.2.1 exception (e.g. over 20 hours) applies.',
+    })), true);
+    bucketize(buckets, 'time-limit-timer', details.timers.map((timer) => pageNode(`${timer.type} with a ${timer.delayMs}ms delay detected` +
+        `${timer.callStack ? ` (${timer.callStack.split('\n')[0]?.trim()})` : ''}. ` +
+        'Verify whether it implements a time limit and is adjustable.')), true);
+    bucketize(buckets, 'time-limit-countdown', details.countdownIndicators.map((indicator) => toNode(indicator, `Countdown/timeout wording found: "${indicator.text.slice(0, 80)}". ` +
+        'Verify whether it indicates an adjustable time limit.')), true);
+    return buckets;
+}
+export function normalizeAutoPlayDetection(details) {
+    const buckets = emptyBuckets();
+    const nodes = [];
+    if (details.hasAutoPlayContent && !details.stopsWithin5Seconds) {
+        const controlsPart = details.pauseControls.found
+            ? `Pause controls found (${details.pauseControls.controls.length}); ` +
+                `pause verified working: ${details.pauseVerification.pauseWorked ?? 'unknown'}.`
+            : 'No pause controls found.';
+        nodes.push(pageNode(`Moving content continues past 5 seconds (pixel-diff detection). ` +
+            `${controlsPart} ${details.recommendation} Verify the content type ` +
+            'and audio manually.'));
+    }
+    bucketize(buckets, 'auto-play', nodes, true);
+    return buckets;
+}
+function normalizeAxeRule(rule, includeNodes) {
+    return {
+        id: rule.id,
+        impact: (rule.impact ?? null),
+        description: rule.description,
+        help: rule.help,
+        helpUrl: rule.helpUrl,
+        tags: [...rule.tags],
+        nodes: includeNodes
+            ? rule.nodes.map((n) => {
+                const truncated = n.html.length > HTML_SNIPPET_MAX_LENGTH;
+                return {
+                    target: n.target.map((t) => String(t)),
+                    html: truncated ? n.html.slice(0, HTML_SNIPPET_MAX_LENGTH) : n.html,
+                    htmlTruncated: truncated,
+                    failureSummary: n.failureSummary ?? '',
+                };
+            })
+            : [],
+    };
+}
+/**
+ * Normalize raw axe-core results into the common buckets. Must be fed the RAW
+ * `AxeResults` (before any reduction) — pass/incomplete details are not
+ * recoverable afterwards. Node lists are kept for violations and incomplete;
+ * passes/inapplicable carry rule metadata only.
+ */
+export function normalizeAxeResults(raw) {
+    return {
+        violations: raw.violations.map((r) => normalizeAxeRule(r, true)),
+        incomplete: raw.incomplete.map((r) => normalizeAxeRule(r, true)),
+        passes: raw.passes.map((r) => normalizeAxeRule(r, false)),
+        inapplicable: raw.inapplicable.map((r) => normalizeAxeRule(r, false)),
+    };
+}
+const BUCKETS = ['violations', 'incomplete', 'passes', 'inapplicable'];
+/**
+ * Merge several check results for the same URL into one normalized view.
+ *
+ * - Results with differing URLs are rejected (throws).
+ * - The same rule id is merged into one entry; nodes are deduplicated by
+ *   `target` + `failureSummary`. Identical selectors inside different frames
+ *   or shadow roots are NOT distinguished.
+ * - A rule appearing in several buckets is placed in the highest-priority one:
+ *   violations > incomplete > passes > inapplicable.
+ */
+export function mergeNormalizedResults(results) {
+    if (results.length === 0) {
+        throw new Error('mergeNormalizedResults requires at least one result.');
+    }
+    const first = results[0];
+    const mismatch = results.find((r) => r.url !== first.url);
+    if (mismatch) {
+        throw new Error(`mergeNormalizedResults: URL mismatch — "${first.url}" vs "${mismatch.url}". ` +
+            'Merge only results for the same page.');
+    }
+    const byId = new Map();
+    const nodeKey = (n) => `${JSON.stringify(n.target)}|${n.failureSummary}`;
+    for (const result of results) {
+        BUCKETS.forEach((bucket, bucketIndex) => {
+            for (const rule of result[bucket]) {
+                let entry = byId.get(rule.id);
+                if (!entry) {
+                    entry = {
+                        bucketIndex,
+                        rule: { ...rule, nodes: [] },
+                        nodeKeys: new Set(),
+                    };
+                    byId.set(rule.id, entry);
+                }
+                entry.bucketIndex = Math.min(entry.bucketIndex, bucketIndex);
+                for (const node of rule.nodes) {
+                    const key = nodeKey(node);
+                    if (!entry.nodeKeys.has(key)) {
+                        entry.nodeKeys.add(key);
+                        entry.rule.nodes.push(node);
+                    }
+                }
+            }
+        });
+    }
+    const merged = {
+        violations: [],
+        incomplete: [],
+        passes: [],
+        inapplicable: [],
+    };
+    for (const entry of byId.values()) {
+        merged[BUCKETS[entry.bucketIndex]].push(entry.rule);
+    }
+    const latestTimestamp = results
+        .map((r) => r.timestamp)
+        .sort()
+        .at(-1);
+    const checkedNodes = results.reduce((sum, r) => {
+        if (r.summary.checkedNodes === undefined)
+            return sum;
+        return (sum ?? 0) + r.summary.checkedNodes;
+    }, undefined);
+    const summary = {
+        violationCount: merged.violations.length,
+        incompleteCount: merged.incomplete.length,
+        passCount: merged.passes.length,
+    };
+    if (checkedNodes !== undefined) {
+        summary.checkedNodes = checkedNodes;
+    }
+    return {
+        url: first.url,
+        timestamp: latestTimestamp,
+        sources: [...new Set(results.map((r) => r.source))],
+        ...merged,
+        summary,
+        disclaimer: AUDIT_DISCLAIMER,
+    };
+}

package/dist/utils/layout.d.ts CHANGED Viewed

@@ -8,6 +8,8 @@ export interface LayoutCheckOptions {
     overflowTolerance: number;
     checkSelector: string;
     allowedOverflowSelectors: readonly string[];
+    /** Maximum length of captured outerHTML snippets. */
+    htmlSnippetMaxLength: number;
 }
 export interface LayoutCheckResult {
     hasHorizontalScroll: boolean;

package/dist/utils/layout.js CHANGED Viewed

@@ -7,7 +7,26 @@
  * This is serialized and executed in the browser context.
  */
 export function createLayoutChecker(options) {
-    const { viewportWidth, overflowTolerance, checkSelector, allowedOverflowSelectors, } = options;
+    const { viewportWidth, overflowTolerance, checkSelector, allowedOverflowSelectors, htmlSnippetMaxLength, } = options;
+    function getHtmlSnippet(element) {
+        let html = '';
+        try {
+            html = element.outerHTML || '';
+        }
+        catch {
+            html = '';
+        }
+        if (!html) {
+            return {
+                html: `<${element.tagName.toLowerCase()}>`,
+                htmlTruncated: false,
+            };
+        }
+        if (html.length > htmlSnippetMaxLength) {
+            return { html: html.slice(0, htmlSnippetMaxLength), htmlTruncated: true };
+        }
+        return { html, htmlTruncated: false };
+    }
     // Helper functions (must be defined inside for browser context)
     /**
      * Generate a unique CSS selector for an element using index-based approach
@@ -31,7 +50,9 @@ export function createLayoutChecker(options) {
             current = parent;
         }
         // Append element index as fallback for guaranteed uniqueness
-        return path.length > 0 ? path.join(' > ') : `[data-index="${elementIndex}"]`;
+        return path.length > 0
+            ? path.join(' > ')
+            : `[data-index="${elementIndex}"]`;
     }
     function isAllowedOverflow(element) {
         return allowedOverflowSelectors.some((selector) => {
@@ -76,6 +97,7 @@ export function createLayoutChecker(options) {
             overflowingElements.push({
                 selector,
                 tagName: element.tagName.toLowerCase(),
+                ...getHtmlSnippet(element),
                 rect: {
                     left: Math.round(rect.left),
                     right: Math.round(rect.right),
@@ -91,6 +113,7 @@ export function createLayoutChecker(options) {
             overflowingElements.push({
                 selector,
                 tagName: element.tagName.toLowerCase(),
+                ...getHtmlSnippet(element),
                 rect: {
                     left: Math.round(rect.left),
                     right: Math.round(rect.right),
@@ -123,6 +146,7 @@ export function createLayoutChecker(options) {
                     clippedTextElements.push({
                         selector,
                         tagName: element.tagName.toLowerCase(),
+                        ...getHtmlSnippet(element),
                         scrollWidth,
                         clientWidth,
                         scrollHeight,

package/dist/utils/recommendations.js CHANGED Viewed

@@ -5,7 +5,7 @@
  * Generate a recommendation based on detection results.
  */
 export function generateRecommendation(ctx) {
-    const { hasAutoPlayContent, stopsWithin5Seconds, pauseControls, pauseVerification } = ctx;
+    const { hasAutoPlayContent, stopsWithin5Seconds, pauseControls, pauseVerification, } = ctx;
     if (!hasAutoPlayContent) {
         return 'No auto-playing content detected in viewport.';
     }
@@ -32,7 +32,7 @@ export function generateRecommendation(ctx) {
  * Print summary to console.
  */
 export function printSummary(ctx, outputDir) {
-    const { hasAutoPlayContent, stopsWithin5Seconds, pauseControls, pauseVerification } = ctx;
+    const { hasAutoPlayContent, stopsWithin5Seconds, pauseControls, pauseVerification, } = ctx;
     console.log('\n--- Summary ---');
     if (!hasAutoPlayContent) {
         console.log('✓ No auto-playing content detected in viewport');

package/dist/utils/rule-registry.d.ts ADDED Viewed

@@ -0,0 +1,216 @@
+/**
+ * Rule metadata registry for the custom (non-axe) checks.
+ *
+ * Single source of truth for rule ids, WCAG mapping, severity, and the
+ * violation/incomplete classification. The mappers in `axe-format.ts` read
+ * from here so that classification policy is reviewable in one place.
+ *
+ * Classification policy: `'violation'` is reserved for rules whose detection
+ * has no blind spot AND where no WCAG exception can apply to a finding.
+ * Heuristic detections and findings with possible exceptions are
+ * `'incomplete'` (the manual-review queue). impact is NOT derived from the
+ * WCAG conformance level; it is assigned per rule, conservatively defaulting
+ * to `moderate`.
+ */
+import type { NormalizedImpact } from '../types.js';
+export interface RuleMeta {
+    /** Namespaced rule id, e.g. `a11y-skills/focus-visible`. */
+    id: string;
+    /** WCAG success criteria, e.g. `['2.4.7']`. */
+    sc: string[];
+    /**
+     * axe-style tags. The version+level tag reflects the WCAG version that
+     * introduced the SC (2.4.7 → `wcag2aa`, 1.4.10 → `wcag21aa`, ...).
+     */
+    tags: string[];
+    impact: NormalizedImpact;
+    /** Whether findings refer to specific elements or the page as a whole. */
+    scope: 'node' | 'page';
+    description: string;
+    help: string;
+    /** W3C Understanding document URL. */
+    helpUrl: string;
+    /** Default bucket for findings of this rule. */
+    classification: 'violation' | 'incomplete';
+}
+export declare const RULES: {
+    readonly 'focus-visible': {
+        readonly id: "a11y-skills/focus-visible";
+        readonly sc: ["2.4.7"];
+        readonly tags: ["a11y-skills", "wcag2aa", "wcag247"];
+        readonly impact: "serious";
+        readonly scope: "node";
+        readonly description: "Ensure keyboard focus produces a visible indicator on focusable elements";
+        readonly help: "Focusable elements should have a visible focus indicator";
+        readonly helpUrl: "https://www.w3.org/WAI/WCAG22/Understanding/focus-visible.html";
+        readonly classification: "incomplete";
+    };
+    readonly 'no-context-change-on-focus': {
+        readonly id: "a11y-skills/no-context-change-on-focus";
+        readonly sc: ["3.2.1"];
+        readonly tags: ["a11y-skills", "wcag2a", "wcag321"];
+        readonly impact: "serious";
+        readonly scope: "node";
+        readonly description: "Ensure receiving focus does not trigger a change of context (navigation, new window)";
+        readonly help: "Focusing an element must not trigger a context change";
+        readonly helpUrl: "https://www.w3.org/WAI/WCAG22/Understanding/on-focus.html";
+        readonly classification: "violation";
+    };
+    readonly 'focus-not-obscured': {
+        readonly id: "a11y-skills/focus-not-obscured";
+        readonly sc: ["2.4.11", "2.4.12"];
+        readonly tags: ["a11y-skills", "wcag22aa", "wcag2411"];
+        readonly impact: "moderate";
+        readonly scope: "node";
+        readonly description: "Ensure the focused element is not hidden by fixed or sticky content";
+        readonly help: "Focused elements should not be obscured by author-created content";
+        readonly helpUrl: "https://www.w3.org/WAI/WCAG22/Understanding/focus-not-obscured-minimum.html";
+        readonly classification: "incomplete";
+    };
+    readonly 'reflow-overflow': {
+        readonly id: "a11y-skills/reflow-overflow";
+        readonly sc: ["1.4.10"];
+        readonly tags: ["a11y-skills", "wcag21aa", "wcag1410"];
+        readonly impact: "serious";
+        readonly scope: "node";
+        readonly description: "Ensure content reflows at 320 CSS px width without horizontal scrolling";
+        readonly help: "Content should not require horizontal scrolling at 320px width";
+        readonly helpUrl: "https://www.w3.org/WAI/WCAG22/Understanding/reflow.html";
+        readonly classification: "incomplete";
+    };
+    readonly 'reflow-clipped-text': {
+        readonly id: "a11y-skills/reflow-clipped-text";
+        readonly sc: ["1.4.10"];
+        readonly tags: ["a11y-skills", "wcag21aa", "wcag1410"];
+        readonly impact: "moderate";
+        readonly scope: "node";
+        readonly description: "Ensure text is not clipped when content reflows at 320 CSS px";
+        readonly help: "Text should remain readable at 320px width";
+        readonly helpUrl: "https://www.w3.org/WAI/WCAG22/Understanding/reflow.html";
+        readonly classification: "incomplete";
+    };
+    readonly 'target-size-minimum': {
+        readonly id: "a11y-skills/target-size-minimum";
+        readonly sc: ["2.5.8"];
+        readonly tags: ["a11y-skills", "wcag22aa", "wcag258"];
+        readonly impact: "serious";
+        readonly scope: "node";
+        readonly description: "Ensure pointer targets are at least 24x24 CSS px (WCAG 2.5.8 AA)";
+        readonly help: "Pointer targets should be at least 24x24 CSS px";
+        readonly helpUrl: "https://www.w3.org/WAI/WCAG22/Understanding/target-size-minimum.html";
+        readonly classification: "incomplete";
+    };
+    readonly 'target-size-enhanced': {
+        readonly id: "a11y-skills/target-size-enhanced";
+        readonly sc: ["2.5.5"];
+        readonly tags: ["a11y-skills", "wcag21aaa", "wcag255"];
+        readonly impact: "moderate";
+        readonly scope: "node";
+        readonly description: "Ensure pointer targets are at least 44x44 CSS px (WCAG 2.5.5 AAA)";
+        readonly help: "Pointer targets should be at least 44x44 CSS px";
+        readonly helpUrl: "https://www.w3.org/WAI/WCAG22/Understanding/target-size-enhanced.html";
+        readonly classification: "incomplete";
+    };
+    readonly 'text-spacing': {
+        readonly id: "a11y-skills/text-spacing";
+        readonly sc: ["1.4.12"];
+        readonly tags: ["a11y-skills", "wcag21aa", "wcag1412"];
+        readonly impact: "moderate";
+        readonly scope: "node";
+        readonly description: "Ensure no loss of content when WCAG 1.4.12 text spacing overrides are applied";
+        readonly help: "Text must not be clipped under increased text spacing";
+        readonly helpUrl: "https://www.w3.org/WAI/WCAG22/Understanding/text-spacing.html";
+        readonly classification: "violation";
+    };
+    readonly 'resize-text': {
+        readonly id: "a11y-skills/resize-text";
+        readonly sc: ["1.4.4"];
+        readonly tags: ["a11y-skills", "wcag2aa", "wcag144"];
+        readonly impact: "moderate";
+        readonly scope: "node";
+        readonly description: "Ensure content remains usable when text is resized to 200%";
+        readonly help: "Content should not be lost or clipped at 200% zoom";
+        readonly helpUrl: "https://www.w3.org/WAI/WCAG22/Understanding/resize-text.html";
+        readonly classification: "incomplete";
+    };
+    readonly 'orientation-lock': {
+        readonly id: "a11y-skills/orientation-lock";
+        readonly sc: ["1.3.4"];
+        readonly tags: ["a11y-skills", "wcag21aa", "wcag134"];
+        readonly impact: "serious";
+        readonly scope: "page";
+        readonly description: "Ensure content does not restrict its view to a single display orientation";
+        readonly help: "Content should work in both portrait and landscape orientation";
+        readonly helpUrl: "https://www.w3.org/WAI/WCAG22/Understanding/orientation.html";
+        readonly classification: "incomplete";
+    };
+    readonly 'autocomplete-invalid': {
+        readonly id: "a11y-skills/autocomplete-invalid";
+        readonly sc: ["1.3.5"];
+        readonly tags: ["a11y-skills", "wcag21aa", "wcag135"];
+        readonly impact: "moderate";
+        readonly scope: "node";
+        readonly description: "Ensure autocomplete attribute values are valid tokens";
+        readonly help: "autocomplete attributes must use valid token values";
+        readonly helpUrl: "https://www.w3.org/WAI/WCAG22/Understanding/identify-input-purpose.html";
+        readonly classification: "violation";
+    };
+    readonly 'autocomplete-missing': {
+        readonly id: "a11y-skills/autocomplete-missing";
+        readonly sc: ["1.3.5"];
+        readonly tags: ["a11y-skills", "wcag21aa", "wcag135"];
+        readonly impact: "moderate";
+        readonly scope: "node";
+        readonly description: "Ensure fields collecting user information declare their purpose via autocomplete";
+        readonly help: "Add an autocomplete attribute matching the field purpose";
+        readonly helpUrl: "https://www.w3.org/WAI/WCAG22/Understanding/identify-input-purpose.html";
+        readonly classification: "incomplete";
+    };
+    readonly 'meta-refresh': {
+        readonly id: "a11y-skills/meta-refresh";
+        readonly sc: ["2.2.1"];
+        readonly tags: ["a11y-skills", "wcag2a", "wcag221"];
+        readonly impact: "serious";
+        readonly scope: "node";
+        readonly description: "Ensure meta refresh time limits can be turned off, adjusted, or extended";
+        readonly help: "Verify the meta refresh satisfies an SC 2.2.1 exception or is adjustable";
+        readonly helpUrl: "https://www.w3.org/WAI/WCAG22/Understanding/timing-adjustable.html";
+        readonly classification: "incomplete";
+    };
+    readonly 'time-limit-timer': {
+        readonly id: "a11y-skills/time-limit-timer";
+        readonly sc: ["2.2.1"];
+        readonly tags: ["a11y-skills", "wcag2a", "wcag221"];
+        readonly impact: "moderate";
+        readonly scope: "page";
+        readonly description: "Detect JavaScript timers that may implement a time limit";
+        readonly help: "Verify whether detected timers implement an adjustable time limit";
+        readonly helpUrl: "https://www.w3.org/WAI/WCAG22/Understanding/timing-adjustable.html";
+        readonly classification: "incomplete";
+    };
+    readonly 'time-limit-countdown': {
+        readonly id: "a11y-skills/time-limit-countdown";
+        readonly sc: ["2.2.1"];
+        readonly tags: ["a11y-skills", "wcag2a", "wcag221"];
+        readonly impact: "moderate";
+        readonly scope: "node";
+        readonly description: "Detect countdown/timeout wording in visible text";
+        readonly help: "Verify whether the countdown text indicates an adjustable time limit";
+        readonly helpUrl: "https://www.w3.org/WAI/WCAG22/Understanding/timing-adjustable.html";
+        readonly classification: "incomplete";
+    };
+    readonly 'auto-play': {
+        readonly id: "a11y-skills/auto-play";
+        readonly sc: ["2.2.2", "1.4.2"];
+        readonly tags: ["a11y-skills", "wcag2a", "wcag222", "wcag142"];
+        readonly impact: "moderate";
+        readonly scope: "page";
+        readonly description: "Detect auto-playing/moving content lasting longer than 5 seconds without a working pause control";
+        readonly help: "Moving content over 5 seconds needs a pause, stop, or hide mechanism";
+        readonly helpUrl: "https://www.w3.org/WAI/WCAG22/Understanding/pause-stop-hide.html";
+        readonly classification: "incomplete";
+    };
+};
+export type RuleKey = keyof typeof RULES;
+/** Look up a rule's metadata. */
+export declare function getRule(key: RuleKey): RuleMeta;