@a11y-skills/audit 0.1.0 → 0.2.0

package/dist/playwright/runZoomCheck.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Zoom 200% Check — WCAG 1.4.4 (Resize Text)
+ *
+ * Sets a standard viewport (default 1280x720), applies 200% zoom via the CSS
+ * `zoom` property, then detects horizontal scrolling and elements whose content
+ * becomes clipped (overflow:hidden) under zoom.
+ *
+ * If a `targetUrl` (or the `TEST_PAGE` env var) is available, this function
+ * owns navigation: it sets the base viewport BEFORE navigating (matching the
+ * legacy script, so pages that read the viewport at load time behave the same).
+ * Otherwise it operates on the already-navigated page (just sets the viewport).
+ *
+ * Limitations:
+ * - CSS zoom is engine-specific; actual browser zoom may behave differently
+ * - Does not verify responsive breakpoint behavior
+ * - Manual verification needed for complex interactions at zoom
+ */
+import type { Page } from '@playwright/test';
+import type { ZoomCheckResult } from '../types.js';
+import { type OutputLocationOptions } from '../utils/test-harness.js';
+export interface RunZoomCheckOptions extends OutputLocationOptions {
+    /** Page to run the check on (navigated by this function if `targetUrl`/`TEST_PAGE` is set). */
+    page: Page;
+    /**
+     * Target URL. If provided (or `TEST_PAGE` is set), the function sets the base
+     * viewport then navigates, for results identical to the legacy script. If
+     * omitted, the page is assumed already navigated.
+     */
+    targetUrl?: string;
+    /** Base viewport applied before zoom (default: 1280x720). */
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    /** Whether to capture a screenshot next to the result file (default: false). */
+    screenshot?: boolean;
+}
+/**
+ * Run the zoom 200% check against the current page, write the result JSON
+ * (and optionally a screenshot), and return the parsed result.
+ */
+export declare function runZoomCheck(options: RunZoomCheckOptions): Promise<ZoomCheckResult>;

package/dist/playwright/runZoomCheck.js

@@ -0,0 +1,150 @@
+/**
+ * Zoom 200% Check — WCAG 1.4.4 (Resize Text)
+ *
+ * Sets a standard viewport (default 1280x720), applies 200% zoom via the CSS
+ * `zoom` property, then detects horizontal scrolling and elements whose content
+ * becomes clipped (overflow:hidden) under zoom.
+ *
+ * If a `targetUrl` (or the `TEST_PAGE` env var) is available, this function
+ * owns navigation: it sets the base viewport BEFORE navigating (matching the
+ * legacy script, so pages that read the viewport at load time behave the same).
+ * Otherwise it operates on the already-navigated page (just sets the viewport).
+ *
+ * Limitations:
+ * - CSS zoom is engine-specific; actual browser zoom may behave differently
+ * - Does not verify responsive breakpoint behavior
+ * - Manual verification needed for complex interactions at zoom
+ */
+import { ZOOM_FACTOR, ZOOM_BASE_VIEWPORT, ZOOM_CLIP_TOLERANCE, REFLOW_CHECK_SELECTOR, DEFAULT_ZOOM_RESULT_FILE, DEFAULT_ZOOM_SCREENSHOT_FILE, } from '../constants.js';
+import { saveAuditResult, takeAuditScreenshot, resolveScreenshotPath, logAuditHeader, logSummary, logIssueList, logOutputPaths, } from '../utils/test-harness.js';
+/** Apply zoom and detect issues in browser context. */
+function applyZoomAndCheck(args) {
+    const { checkSelector, tolerance } = args;
+    // Apply CSS zoom
+    document.documentElement.style.zoom =
+        '200%';
+    // Force reflow
+    void document.body.offsetHeight;
+    function getUniqueSelector(element, elementIndex) {
+        if (element.id) {
+            return `#${element.id}`;
+        }
+        const path = [];
+        let current = element;
+        while (current && current !== document.body) {
+            let selector = current.tagName.toLowerCase();
+            const parent = current.parentElement;
+            if (parent) {
+                const childIndex = Array.from(parent.children).indexOf(current) + 1;
+                selector += `:nth-child(${childIndex})`;
+            }
+            path.unshift(selector);
+            current = parent;
+        }
+        return path.length > 0 ? path.join(' > ') : `[data-index="${elementIndex}"]`;
+    }
+    function isVisible(element) {
+        const style = window.getComputedStyle(element);
+        return (style.display !== 'none' &&
+            style.visibility !== 'hidden' &&
+            parseFloat(style.opacity) > 0);
+    }
+    function hasHiddenOverflow(style) {
+        return (style.overflow === 'hidden' ||
+            style.overflow === 'clip' ||
+            style.overflowX === 'hidden' ||
+            style.overflowX === 'clip');
+    }
+    // Check document-level horizontal scroll
+    const scrollEl = document.scrollingElement || document.documentElement;
+    const documentScrollWidth = scrollEl.scrollWidth;
+    const documentClientWidth = scrollEl.clientWidth;
+    const hasHorizontalScroll = documentScrollWidth > documentClientWidth + tolerance;
+    // Find clipped elements
+    const clippedElements = [];
+    const seenElements = new WeakSet();
+    const elements = document.querySelectorAll(checkSelector);
+    elements.forEach((element, index) => {
+        if (!isVisible(element) || seenElements.has(element)) {
+            return;
+        }
+        const style = window.getComputedStyle(element);
+        if (!hasHiddenOverflow(style)) {
+            return;
+        }
+        const scrollWidth = element.scrollWidth;
+        const clientWidth = element.clientWidth;
+        const scrollHeight = element.scrollHeight;
+        const clientHeight = element.clientHeight;
+        const hasHorizontalClip = scrollWidth > clientWidth + tolerance;
+        const hasVerticalClip = scrollHeight > clientHeight + tolerance;
+        if ((hasHorizontalClip || hasVerticalClip) && element.textContent?.trim()) {
+            seenElements.add(element);
+            clippedElements.push({
+                selector: getUniqueSelector(element, index),
+                tagName: element.tagName.toLowerCase(),
+                scrollWidth,
+                clientWidth,
+                scrollHeight,
+                clientHeight,
+                issueType: hasHorizontalClip ? 'horizontal-scroll' : 'clipped-content',
+            });
+        }
+    });
+    return {
+        hasHorizontalScroll,
+        documentScrollWidth,
+        documentClientWidth,
+        clippedElements,
+    };
+}
+/**
+ * Run the zoom 200% check against the current page, write the result JSON
+ * (and optionally a screenshot), and return the parsed result.
+ */
+export async function runZoomCheck(options) {
+    const { page, targetUrl: targetUrlOption, viewport = ZOOM_BASE_VIEWPORT, screenshot = false, ...location } = options;
+    await page.setViewportSize({ width: viewport.width, height: viewport.height });
+    // If a URL is available, navigate at the base viewport (legacy ordering).
+    const targetUrl = targetUrlOption ?? process.env.TEST_PAGE;
+    if (targetUrl) {
+        await page.goto(targetUrl, { waitUntil: 'networkidle' });
+    }
+    const zoomResult = await page.evaluate(applyZoomAndCheck, {
+        checkSelector: REFLOW_CHECK_SELECTOR,
+        tolerance: ZOOM_CLIP_TOLERANCE,
+    });
+    const result = {
+        url: page.url(),
+        zoomFactor: ZOOM_FACTOR,
+        viewport: { width: viewport.width, height: viewport.height },
+        ...zoomResult,
+    };
+    // Output results
+    logAuditHeader('Zoom 200% Check Results', 'WCAG 1.4.4', result.url);
+    logSummary({
+        'Zoom factor': `${result.zoomFactor}x`,
+        'Base viewport': `${result.viewport.width}x${result.viewport.height}`,
+        'Document scroll width': `${result.documentScrollWidth}px`,
+        'Document client width': `${result.documentClientWidth}px`,
+        'Horizontal scroll': result.hasHorizontalScroll,
+        'Clipped elements': result.clippedElements.length,
+    });
+    logIssueList('Clipped Elements', result.clippedElements, (el, i) => [
+        `${i + 1}. <${el.tagName}> "${el.selector}"`,
+        `   scrollWidth: ${el.scrollWidth}px, clientWidth: ${el.clientWidth}px`,
+        `   Issue: ${el.issueType}`,
+    ]);
+    const resolvedPath = saveAuditResult(result, {
+        ...location,
+        defaultFile: DEFAULT_ZOOM_RESULT_FILE,
+    });
+    let screenshotPath;
+    if (screenshot) {
+        screenshotPath = await takeAuditScreenshot(page, {
+            path: resolveScreenshotPath(resolvedPath, DEFAULT_ZOOM_SCREENSHOT_FILE),
+        });
+    }
+    logOutputPaths(resolvedPath, screenshotPath);
+    return result;
+}

package/dist/schemas/index.d.ts

@@ -7,7 +7,7 @@
  * permissive (no `additionalProperties: false`) so that additive changes to a
  * result shape do not break downstream validation.
  */
-export type { AxeViolationNode, AxeViolation, AxeAuditResult, FocusRecord, OnFocusViolation, FocusCheckResult, BoundingRect, FocusObscuredOverlap, FocusObscuredIssue, ReflowIssue, ClippedTextElement, ReflowCheckResult, TargetSizeException, TargetSizeIssue, TargetSizeSummary, TargetSizeCheckResult, } from '../types.js';
+export type { AxeViolationNode, AxeViolation, AxeAuditResult, FocusRecord, OnFocusViolation, FocusCheckResult, BoundingRect, FocusObscuredOverlap, FocusObscuredIssue, ReflowIssue, ClippedTextElement, ReflowCheckResult, TargetSizeException, TargetSizeIssue, TargetSizeSummary, TargetSizeCheckResult, TextSpacingIssue, TextSpacingCheckResult, ZoomIssue, ZoomCheckResult, OrientationState, OrientationCheckResult, AutocompleteIssue, AutocompleteAuditResult, MetaRefreshInfo, TimerInfo, CountdownIndicator, TimeLimitDetectorResult, ScreenshotRecord, ComparisonResult, ImageDiffResult, PauseControl, CarouselIndicator, PauseControlInfo, PauseVerificationResult, AutoPlayDetectionResult, } from '../types.js';
 /** Minimal JSON Schema object shape (Draft 2020-12 compatible subset). */
 export interface JsonSchema {
     $schema?: string;
@@ -25,10 +25,22 @@ export declare const AXE_AUDIT_RESULT_SCHEMA: JsonSchema;
 export declare const FOCUS_CHECK_RESULT_SCHEMA: JsonSchema;
 export declare const REFLOW_CHECK_RESULT_SCHEMA: JsonSchema;
 export declare const TARGET_SIZE_CHECK_RESULT_SCHEMA: JsonSchema;
+export declare const TEXT_SPACING_CHECK_RESULT_SCHEMA: JsonSchema;
+export declare const ZOOM_CHECK_RESULT_SCHEMA: JsonSchema;
+export declare const ORIENTATION_CHECK_RESULT_SCHEMA: JsonSchema;
+export declare const AUTOCOMPLETE_AUDIT_RESULT_SCHEMA: JsonSchema;
+export declare const TIME_LIMIT_DETECTOR_RESULT_SCHEMA: JsonSchema;
+export declare const AUTO_PLAY_DETECTION_RESULT_SCHEMA: JsonSchema;
 /** All result schemas keyed by check id. */
 export declare const RESULT_SCHEMAS: {
     readonly 'axe-audit': JsonSchema;
     readonly 'focus-indicator-check': JsonSchema;
     readonly 'reflow-check': JsonSchema;
     readonly 'target-size-check': JsonSchema;
+    readonly 'text-spacing-check': JsonSchema;
+    readonly 'zoom-200-check': JsonSchema;
+    readonly 'orientation-check': JsonSchema;
+    readonly 'autocomplete-audit': JsonSchema;
+    readonly 'time-limit-detector': JsonSchema;
+    readonly 'auto-play-detection': JsonSchema;
 };

package/dist/schemas/index.js

@@ -236,10 +236,132 @@ export const TARGET_SIZE_CHECK_RESULT_SCHEMA = {
         disclaimer: DISCLAIMER_SCHEMA,
     },
 };
+export const TEXT_SPACING_CHECK_RESULT_SCHEMA = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $id: 'https://masup9.github.io/a11y-audit/schemas/text-spacing-check-result.json',
+    title: 'TextSpacingCheckResult',
+    type: 'object',
+    required: ['url', 'clippedElements', 'totalElementsChecked'],
+    properties: {
+        url: { type: 'string' },
+        clippedElements: { type: 'array', items: { type: 'object' } },
+        totalElementsChecked: { type: 'number' },
+        disclaimer: DISCLAIMER_SCHEMA,
+    },
+};
+export const ZOOM_CHECK_RESULT_SCHEMA = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $id: 'https://masup9.github.io/a11y-audit/schemas/zoom-check-result.json',
+    title: 'ZoomCheckResult',
+    type: 'object',
+    required: [
+        'url',
+        'zoomFactor',
+        'viewport',
+        'hasHorizontalScroll',
+        'documentScrollWidth',
+        'documentClientWidth',
+        'clippedElements',
+    ],
+    properties: {
+        url: { type: 'string' },
+        zoomFactor: { type: 'number' },
+        viewport: { type: 'object' },
+        hasHorizontalScroll: { type: 'boolean' },
+        documentScrollWidth: { type: 'number' },
+        documentClientWidth: { type: 'number' },
+        clippedElements: { type: 'array', items: { type: 'object' } },
+        disclaimer: DISCLAIMER_SCHEMA,
+    },
+};
+export const ORIENTATION_CHECK_RESULT_SCHEMA = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $id: 'https://masup9.github.io/a11y-audit/schemas/orientation-check-result.json',
+    title: 'OrientationCheckResult',
+    type: 'object',
+    required: ['url', 'portrait', 'landscape', 'hasOrientationLock', 'lockDetectedIn'],
+    properties: {
+        url: { type: 'string' },
+        portrait: { type: 'object' },
+        landscape: { type: 'object' },
+        hasOrientationLock: { type: 'boolean' },
+        lockDetectedIn: {
+            type: 'string',
+            enum: ['portrait', 'landscape', 'both', 'none'],
+        },
+        disclaimer: DISCLAIMER_SCHEMA,
+    },
+};
+export const AUTOCOMPLETE_AUDIT_RESULT_SCHEMA = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $id: 'https://masup9.github.io/a11y-audit/schemas/autocomplete-audit-result.json',
+    title: 'AutocompleteAuditResult',
+    type: 'object',
+    required: [
+        'url',
+        'totalFieldsChecked',
+        'missingAutocomplete',
+        'invalidAutocomplete',
+    ],
+    properties: {
+        url: { type: 'string' },
+        totalFieldsChecked: { type: 'number' },
+        missingAutocomplete: { type: 'array', items: { type: 'object' } },
+        invalidAutocomplete: { type: 'array', items: { type: 'object' } },
+        disclaimer: DISCLAIMER_SCHEMA,
+    },
+};
+export const TIME_LIMIT_DETECTOR_RESULT_SCHEMA = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $id: 'https://masup9.github.io/a11y-audit/schemas/time-limit-detector-result.json',
+    title: 'TimeLimitDetectorResult',
+    type: 'object',
+    required: ['url', 'metaRefresh', 'timers', 'countdownIndicators', 'hasTimeLimits'],
+    properties: {
+        url: { type: 'string' },
+        metaRefresh: { type: 'array', items: { type: 'object' } },
+        timers: { type: 'array', items: { type: 'object' } },
+        countdownIndicators: { type: 'array', items: { type: 'object' } },
+        hasTimeLimits: { type: 'boolean' },
+        disclaimer: DISCLAIMER_SCHEMA,
+    },
+};
+export const AUTO_PLAY_DETECTION_RESULT_SCHEMA = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $id: 'https://masup9.github.io/a11y-audit/schemas/auto-play-detection-result.json',
+    title: 'AutoPlayDetectionResult',
+    type: 'object',
+    required: [
+        'url',
+        'screenshotRecords',
+        'comparisons',
+        'hasAutoPlayContent',
+        'stopsWithin5Seconds',
+        'pauseControls',
+        'pauseVerification',
+        'recommendation',
+    ],
+    properties: {
+        url: { type: 'string' },
+        screenshotRecords: { type: 'array', items: { type: 'object' } },
+        comparisons: { type: 'array', items: { type: 'object' } },
+        hasAutoPlayContent: { type: 'boolean' },
+        stopsWithin5Seconds: { type: 'boolean' },
+        pauseControls: { type: 'object' },
+        pauseVerification: { type: 'object' },
+        recommendation: { type: 'string' },
+    },
+};
 /** All result schemas keyed by check id. */
 export const RESULT_SCHEMAS = {
     'axe-audit': AXE_AUDIT_RESULT_SCHEMA,
     'focus-indicator-check': FOCUS_CHECK_RESULT_SCHEMA,
     'reflow-check': REFLOW_CHECK_RESULT_SCHEMA,
     'target-size-check': TARGET_SIZE_CHECK_RESULT_SCHEMA,
+    'text-spacing-check': TEXT_SPACING_CHECK_RESULT_SCHEMA,
+    'zoom-200-check': ZOOM_CHECK_RESULT_SCHEMA,
+    'orientation-check': ORIENTATION_CHECK_RESULT_SCHEMA,
+    'autocomplete-audit': AUTOCOMPLETE_AUDIT_RESULT_SCHEMA,
+    'time-limit-detector': TIME_LIMIT_DETECTOR_RESULT_SCHEMA,
+    'auto-play-detection': AUTO_PLAY_DETECTION_RESULT_SCHEMA,
 };

package/dist/test-entries/auto-play-detection.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Compatibility test entry for auto-play detection (WCAG 1.4.2 / 2.2.2).
+ * Run from a one-line local spec: `import "@a11y-skills/audit/test-entries/auto-play-detection";`
+ *
+ * Requires the optional `pixelmatch` + `pngjs` deps.
+ */
+export {};

package/dist/test-entries/auto-play-detection.js

@@ -0,0 +1,13 @@
+/**
+ * Compatibility test entry for auto-play detection (WCAG 1.4.2 / 2.2.2).
+ * Run from a one-line local spec: `import "@a11y-skills/audit/test-entries/auto-play-detection";`
+ *
+ * Requires the optional `pixelmatch` + `pngjs` deps.
+ */
+import { test } from '@playwright/test';
+import { runAutoPlayDetection } from '../playwright/runAutoPlayDetection.js';
+import { requireTargetUrl } from '../utils/test-harness.js';
+test('auto-play content detection', async ({ page }) => {
+    await page.goto(requireTargetUrl(), { waitUntil: 'networkidle' });
+    await runAutoPlayDetection({ page });
+});

package/dist/test-entries/autocomplete-audit.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Compatibility test entry for the autocomplete audit (WCAG 1.3.5).
+ * Run from a one-line local spec: `import "@a11y-skills/audit/test-entries/autocomplete-audit";`
+ */
+export {};

package/dist/test-entries/autocomplete-audit.js

@@ -0,0 +1,11 @@
+/**
+ * Compatibility test entry for the autocomplete audit (WCAG 1.3.5).
+ * Run from a one-line local spec: `import "@a11y-skills/audit/test-entries/autocomplete-audit";`
+ */
+import { test } from '@playwright/test';
+import { runAutocompleteAudit } from '../playwright/runAutocompleteAudit.js';
+import { requireTargetUrl } from '../utils/test-harness.js';
+test('autocomplete audit (WCAG 1.3.5)', async ({ page }) => {
+    await page.goto(requireTargetUrl(), { waitUntil: 'networkidle' });
+    await runAutocompleteAudit({ page });
+});

package/dist/test-entries/orientation-check.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Compatibility test entry for the orientation check (WCAG 1.3.4).
+ * Run from a one-line local spec: `import "@a11y-skills/audit/test-entries/orientation-check";`
+ *
+ * This check owns navigation (it loads the page at two viewports), so the
+ * target URL comes from `TEST_PAGE` via the function.
+ */
+export {};

package/dist/test-entries/orientation-check.js

@@ -0,0 +1,12 @@
+/**
+ * Compatibility test entry for the orientation check (WCAG 1.3.4).
+ * Run from a one-line local spec: `import "@a11y-skills/audit/test-entries/orientation-check";`
+ *
+ * This check owns navigation (it loads the page at two viewports), so the
+ * target URL comes from `TEST_PAGE` via the function.
+ */
+import { test } from '@playwright/test';
+import { runOrientationCheck } from '../playwright/runOrientationCheck.js';
+test('orientation check (WCAG 1.3.4)', async ({ page }) => {
+    await runOrientationCheck({ page, screenshot: true });
+});

package/dist/test-entries/text-spacing-check.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Compatibility test entry for the text spacing check (WCAG 1.4.12).
+ * Run from a one-line local spec: `import "@a11y-skills/audit/test-entries/text-spacing-check";`
+ */
+export {};

package/dist/test-entries/text-spacing-check.js

@@ -0,0 +1,11 @@
+/**
+ * Compatibility test entry for the text spacing check (WCAG 1.4.12).
+ * Run from a one-line local spec: `import "@a11y-skills/audit/test-entries/text-spacing-check";`
+ */
+import { test } from '@playwright/test';
+import { runTextSpacingCheck } from '../playwright/runTextSpacingCheck.js';
+import { requireTargetUrl } from '../utils/test-harness.js';
+test('text spacing check (WCAG 1.4.12)', async ({ page }) => {
+    await page.goto(requireTargetUrl(), { waitUntil: 'networkidle' });
+    await runTextSpacingCheck({ page, screenshot: true });
+});

package/dist/test-entries/time-limit-detector.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Compatibility test entry for the time limit detector (WCAG 2.2.1).
+ * Run from a one-line local spec: `import "@a11y-skills/audit/test-entries/time-limit-detector";`
+ *
+ * This check installs a timer hook before navigation, so it owns navigation;
+ * the target URL comes from `TEST_PAGE` via the function.
+ */
+export {};

package/dist/test-entries/time-limit-detector.js

@@ -0,0 +1,12 @@
+/**
+ * Compatibility test entry for the time limit detector (WCAG 2.2.1).
+ * Run from a one-line local spec: `import "@a11y-skills/audit/test-entries/time-limit-detector";`
+ *
+ * This check installs a timer hook before navigation, so it owns navigation;
+ * the target URL comes from `TEST_PAGE` via the function.
+ */
+import { test } from '@playwright/test';
+import { runTimeLimitDetector } from '../playwright/runTimeLimitDetector.js';
+test('time limit detector (WCAG 2.2.1)', async ({ page }) => {
+    await runTimeLimitDetector({ page });
+});

package/dist/test-entries/zoom-200-check.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Compatibility test entry for the zoom 200% check (WCAG 1.4.4).
+ * Run from a one-line local spec: `import "@a11y-skills/audit/test-entries/zoom-200-check";`
+ */
+export {};

package/dist/test-entries/zoom-200-check.js

@@ -0,0 +1,11 @@
+/**
+ * Compatibility test entry for the zoom 200% check (WCAG 1.4.4).
+ * Run from a one-line local spec: `import "@a11y-skills/audit/test-entries/zoom-200-check";`
+ */
+import { test } from '@playwright/test';
+import { runZoomCheck } from '../playwright/runZoomCheck.js';
+import { requireTargetUrl } from '../utils/test-harness.js';
+test('zoom 200% check (WCAG 1.4.4)', async ({ page }) => {
+    // Let runZoomCheck navigate so the base viewport is applied before load.
+    await runZoomCheck({ page, targetUrl: requireTargetUrl(), screenshot: true });
+});

package/dist/types.d.ts

@@ -213,3 +213,154 @@ export interface TargetSizeCheckResult {
     /** Summary counts */
     summary: TargetSizeSummary;
 }
+export interface TextSpacingIssue {
+    selector: string;
+    tagName: string;
+    beforeMetrics: {
+        scrollWidth: number;
+        scrollHeight: number;
+        clientWidth: number;
+        clientHeight: number;
+    };
+    afterMetrics: {
+        scrollWidth: number;
+        scrollHeight: number;
+        clientWidth: number;
+        clientHeight: number;
+    };
+    overflow: string;
+    overflowX: string;
+    overflowY: string;
+    issueType: 'horizontal-clip' | 'vertical-clip' | 'both';
+}
+export interface TextSpacingCheckResult {
+    url: string;
+    clippedElements: TextSpacingIssue[];
+    totalElementsChecked: number;
+}
+export interface ZoomIssue {
+    selector: string;
+    tagName: string;
+    scrollWidth: number;
+    clientWidth: number;
+    scrollHeight: number;
+    clientHeight: number;
+    issueType: 'horizontal-scroll' | 'clipped-content';
+}
+export interface ZoomCheckResult {
+    url: string;
+    zoomFactor: number;
+    viewport: {
+        width: number;
+        height: number;
+    };
+    hasHorizontalScroll: boolean;
+    documentScrollWidth: number;
+    documentClientWidth: number;
+    clippedElements: ZoomIssue[];
+}
+export interface OrientationState {
+    lockMessageFound: boolean;
+    lockMessageText: string | null;
+    mainContentHidden: boolean;
+    bodyWidth: number;
+    bodyHeight: number;
+    visibleTextLength: number;
+}
+export interface OrientationCheckResult {
+    url: string;
+    portrait: OrientationState;
+    landscape: OrientationState;
+    hasOrientationLock: boolean;
+    lockDetectedIn: 'portrait' | 'landscape' | 'both' | 'none';
+}
+export interface AutocompleteIssue {
+    selector: string;
+    tagName: string;
+    inputType: string;
+    name: string | null;
+    id: string | null;
+    labelText: string | null;
+    currentAutocomplete: string | null;
+    expectedToken: string;
+    matchedBy: 'name' | 'id' | 'label' | 'placeholder';
+    issueType: 'missing' | 'invalid';
+}
+export interface AutocompleteAuditResult {
+    url: string;
+    totalFieldsChecked: number;
+    missingAutocomplete: AutocompleteIssue[];
+    invalidAutocomplete: AutocompleteIssue[];
+}
+export interface MetaRefreshInfo {
+    content: string;
+    seconds: number;
+    url: string | null;
+}
+export interface TimerInfo {
+    type: 'setTimeout' | 'setInterval';
+    delayMs: number;
+    callStack: string | null;
+}
+export interface CountdownIndicator {
+    selector: string;
+    text: string;
+    tagName: string;
+}
+export interface TimeLimitDetectorResult {
+    url: string;
+    metaRefresh: MetaRefreshInfo[];
+    timers: TimerInfo[];
+    countdownIndicators: CountdownIndicator[];
+    hasTimeLimits: boolean;
+}
+export interface ScreenshotRecord {
+    time: string;
+    path: string;
+}
+export interface ComparisonResult {
+    compare: string;
+    diffPixels: number;
+    totalPixels: number;
+    diffPercent: string;
+    hasChange: boolean;
+}
+export interface ImageDiffResult {
+    diffPixels: number;
+    totalPixels: number;
+    diffPercent: number;
+}
+export interface PauseControl {
+    element: string;
+    name: string;
+    matchedBy: 'accessible-name' | 'class-name-near-carousel' | 'svg-icon-pattern';
+    selector: string;
+}
+export interface CarouselIndicator {
+    element: string;
+    name: string;
+}
+export interface PauseControlInfo {
+    found: boolean;
+    controls: PauseControl[];
+    carouselIndicators: CarouselIndicator[];
+    hasAccessibleName: boolean;
+}
+export interface PauseVerificationResult {
+    attempted: boolean;
+    controlClicked: string | null;
+    beforeClickDiffPercent: string | null;
+    afterClickDiffPercent: string | null;
+    pauseWorked: boolean | null;
+    error: string | null;
+}
+export interface AutoPlayDetectionResult {
+    url: string;
+    screenshotRecords: ScreenshotRecord[];
+    comparisons: ComparisonResult[];
+    hasAutoPlayContent: boolean;
+    stopsWithin5Seconds: boolean;
+    pauseControls: PauseControlInfo;
+    pauseVerification: PauseVerificationResult;
+    recommendation: string;
+}

package/dist/utils/image-compare.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Image comparison utilities using pixelmatch.
+ *
+ * NOTE: `pixelmatch` and `pngjs` are optional peer/runtime deps (only the
+ * auto-play check needs them). This module top-level imports them, so it must
+ * only be loaded via a dynamic `import()` from `runAutoPlayDetection` — never
+ * statically from the package barrel. That keeps the other checks usable when
+ * the optional deps are absent.
+ */
+import type { ImageDiffResult } from '../types.js';
+/**
+ * Compare two PNG images using pixel-level diff.
+ *
+ * @returns Diff statistics
+ */
+export declare function compareImages(img1Path: string, img2Path: string, diffOutputPath: string): ImageDiffResult;
+/** Format diff percentage as string with 3 decimal places */
+export declare function formatDiffPercent(diffPercent: number): string;
+/** Check if change is significant based on threshold */
+export declare function hasSignificantChange(diffPercent: number, threshold: number): boolean;
+/** Ensure output directory exists */
+export declare function ensureOutputDir(outputDir: string): void;
+/** Save JSON result to file */
+export declare function saveJsonResult(filePath: string, data: unknown): void;