agentic-qe 3.15.15 → 3.15.17

package/dist/domains/test-execution/services/test-executor.js

@@ -17,10 +17,12 @@ import { secureRandom, secureRandomInt } from '../../../shared/utils/crypto-rand
 import { writeTestRunEvidence } from '../../quality-assessment/quality-evidence.js';
 import { istanbulLineHits } from '../../../coordination/handlers/handler-utils.js';
 import { fileCoverageKey, projectFileCoverageKeys } from '../../coverage-analysis/collected-metrics.js';
-import { mergeTestCases, redactFailedTests, redactFailureText, testCasesFromRunnerReport } from './runner-test-cases.js';
+import { mergeTestCases, redactFailedTests, redactFailureText, testCaseFailureMessage, testCasesFromRunnerReport } from './runner-test-cases.js';
 import { capDiagnostics, getTestRunnerExecutionError, TestRunnerExecutionError } from '../../../shared/test-runner-verdict.js';
 import { createVitestJsonReport } from '../../../shared/vitest-json-report.js';
+import { createPytestJunitReport, isPythonTestFile, pytestCommand, pytestRunFromReport, PYTEST_ENV } from '../../../shared/pytest-junit-report.js';
 import { jestExactPathPattern, runnerFilePath } from '../../../shared/test-runner-args.js';
+import { groupByRunnerProject, runnerFrameworkFor } from '../../../shared/test-runner-project.js';
 import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
 import { terminateTestRunner, trackTestRunnerExit } from '../../../shared/test-runner-process.js';
 const DEFAULT_CONFIG = {
@@ -314,7 +316,7 @@ Provide:
         return ok(undefined);
     }
     async runTests(request) {
-        const { testFiles, framework, timeout = 30000 } = request;
+        const { testFiles, framework, timeout = 30000, projectRoot, frameworkFromConfig } = request;
         const failedTests = [];
         const coverages = [];
         const allFileCoverages = [];
@@ -323,7 +325,7 @@ Provide:
         let failed = 0;
         let skipped = 0;
         for (const file of testFiles) {
-            const result = await this.executeTestFile(file, framework, timeout);
+            const result = await this.executeTestFile(file, framework, timeout, projectRoot, frameworkFromConfig);
             executionResults.push(result);
             passed += result.passed;
             failed += result.failed;
@@ -393,16 +395,49 @@ Provide:
         const coverage = this.extractCoverageFromJson({ coverageMap: merged });
         return coverage.summary ? { summary: coverage.summary, perFile: coverage.perFile } : undefined;
     }
-    async executeTestFile(file, framework, timeout) {
-        return this.executeTestFiles([file], framework, timeout);
+    async executeTestFile(file, framework, timeout, projectRoot, frameworkFromConfig = false) {
+        return this.executeTestFiles([file], framework, timeout, projectRoot, frameworkFromConfig);
     }
-    async executeTestFiles(files, framework, timeout) {
+    async executeTestFiles(files, framework, timeout, projectRoot, frameworkFromConfig = false) {
         // In simulation mode (for unit testing), use random behavior
         if (this.config.simulateForTesting) {
             return this.aggregateResults(files.map(file => this.simulateTestExecution(file)));
         }
+        // #1247: a runner loads the config of the directory it starts in, so each
+        // file runs from its own runner project (or the caller's projectRoot).
+        // #1248: Python files run apart from the others, with pytest.
+        const groups = projectRoot
+            ? [files.filter(isPythonTestFile), files.filter(file => !isPythonTestFile(file))]
+                .filter(group => group.length > 0)
+                .map(group => ({ cwd: projectRoot, files: group }))
+            : groupByRunnerProject(files);
+        // #1272: an explicit framework wins; otherwise the project's config decides.
+        // #1248: Python files run with pytest, never with a JavaScript runner.
+        const frameworkIn = (group) => {
+            if (group.files.some(isPythonTestFile)) {
+                if (frameworkFromConfig || framework.toLowerCase() === 'pytest')
+                    return 'pytest';
+                throw new TestRunnerExecutionError(`Python test files cannot run with ${framework}: ${group.files.filter(isPythonTestFile).join(', ')}. ` +
+                    `Use framework 'pytest', or leave the framework unset.`);
+            }
+            return (frameworkFromConfig ? runnerFrameworkFor(group.cwd) : undefined) ?? framework;
+        };
+        if (groups.length === 1) {
+            return this.executeProjectFiles(groups[0].files, frameworkIn(groups[0]), timeout, groups[0].cwd);
+        }
+        // Each project gets its own runner and timeout. Their coverage maps are
+        // merged from raw counters, or left unmeasured (#1030).
+        const frameworks = groups.map(frameworkIn);
+        const results = await Promise.all(groups.map((group, index) => this.executeProjectFiles(group.files, frameworks[index], timeout, group.cwd)));
+        const combined = this.aggregateResults(results);
+        const merged = this.mergeSequentialCoverage(results);
+        combined.coverage = merged?.summary;
+        combined.fileCoverages = merged?.perFile;
+        return combined;
+    }
+    async executeProjectFiles(files, framework, timeout, cwd) {
         // Production mode: spawn actual test runner process
-        const result = await this.spawnTestRunner(files, framework, timeout);
+        const result = await this.spawnTestRunner(files, framework, timeout, cwd);
         if (result.success === false) {
             // Runner/suite errors have no trustworthy assertion receipt to aggregate.
             if (result.error instanceof TestRunnerExecutionError)
@@ -426,9 +461,9 @@ Provide:
         return result.value;
     }
     /**
-     * Spawn actual test runner process (vitest, jest, mocha)
+     * Spawn actual test runner process (vitest, jest, mocha, node:test, pytest)
      */
-    async spawnTestRunner(files, framework, timeout) {
+    async spawnTestRunner(files, framework, timeout, cwd = process.cwd()) {
         // Verify test file exists
         const missingFile = files.find(file => !existsSync(file));
         if (missingFile) {
@@ -466,11 +501,12 @@ Provide:
             let proc;
             try {
                 proc = spawn(command, args, {
-                    cwd: process.cwd(),
+                    cwd,
                     detached: process.platform !== 'win32',
                     env: {
                         ...process.env,
                         FORCE_COLOR: '0', // Disable color codes for easier parsing
+                        ...PYTEST_ENV, // pytest reads any FORCE_COLOR as "force colour" (#1248)
                         CI: 'true', // Enable CI mode for consistent output
                     },
                 });
@@ -515,11 +551,15 @@ Provide:
                     finish(err(toError(error)));
                     return;
                 }
-                if (reportText === undefined) {
+                // #1248: pytest reports its own missing report (pytest not installed).
+                const pytest = framework.toLowerCase() === 'pytest';
+                if (reportText === undefined && !pytest) {
                     finish(err(new TestRunnerExecutionError(`The current Vitest JSON report is missing for ${fileLabel}.`)));
                     return;
                 }
-                const parseResult = this.parseTestOutput(reportText, stderr, fileLabel, framework, code);
+                const parseResult = pytest
+                    ? this.parsePytestOutput(reportText, `${stderr}\n${stdout}`, files, code, command)
+                    : this.parseTestOutput(reportText ?? '', stderr, fileLabel, framework, code);
                 // Read only this invocation's coverage artifacts. A previous or
                 // concurrent run's project coverage directory is not evidence.
                 if (parseResult.success && coverageDirectory) {
@@ -592,8 +632,14 @@ Provide:
                     command: process.execPath,
                     args: ['--test', ...files],
                 };
+            case 'pytest': {
+                // #1248: results come from the JUnit report file; no coverage is collected.
+                const report = createPytestJunitReport();
+                return { ...pytestCommand(files, report.path), report };
+            }
             default: {
-                // Default to vitest
+                // Default to vitest. Python files never get here: executeTestFiles
+                // sends them to pytest or refuses the run (#1248).
                 const coverageDirectory = createCoverageDirectory();
                 let report;
                 try {
@@ -636,6 +682,43 @@ Provide:
                 `stdout: ${capDiagnostics(stdout, 500)}\nstderr: ${capDiagnostics(stderr, 500)}`));
         }
     }
+    /**
+     * #1248: a pytest run from its JUnit report (undefined when pytest wrote none).
+     */
+    parsePytestOutput(report, output, files, exitCode, python) {
+        const run = pytestRunFromReport(report, files, exitCode, output, python);
+        if (!run.success)
+            return run;
+        const failedTests = run.value.tests
+            .filter(test => test.status === 'failed')
+            .map(test => ({
+            testId: uuidv4(),
+            testName: test.name,
+            file: test.file,
+            error: test.failureMessage ?? 'Test failed',
+            stack: test.failureMessage ?? '',
+            duration: test.duration ?? 0,
+        }));
+        const testCases = run.value.tests.map(test => {
+            const failureMessage = test.failureMessage && testCaseFailureMessage(test.failureMessage);
+            return {
+                name: test.name,
+                file: test.file,
+                status: test.status,
+                ...(test.duration !== undefined ? { duration: test.duration } : {}),
+                ...(failureMessage ? { failureMessage } : {}),
+            };
+        });
+        return ok({
+            total: run.value.total,
+            passed: run.value.passed,
+            failed: run.value.failed,
+            skipped: run.value.skipped,
+            failedTests,
+            testCases,
+            coverage: undefined,
+        });
+    }
     /**
      * Parse the TAP or spec summary emitted by Node's built-in test runner.
      */
@@ -999,7 +1082,7 @@ Provide:
         return shards;
     }
     async executeWorker(files, _workerIndex, _isolation, request) {
-        return this.executeTestFiles(files, request.framework, request.timeout ?? 30000);
+        return this.executeTestFiles(files, request.framework, request.timeout ?? 30000, request.projectRoot, request.frameworkFromConfig);
     }
     aggregateResults(results) {
         const aggregated = {

package/dist/domains/visual-accessibility/coordinator.d.ts

@@ -25,6 +25,20 @@ export interface WorkflowStatus {
     progress: number;
     error?: string;
 }
+/**
+ * A color-contrast violation as axe-core measured it (#1228). A colour the
+ * browser did not report is null and an unreported ratio is -1, with
+ * measured: false.
+ */
+export interface ContrastIssue {
+    element: string;
+    foreground: string | null;
+    background: string | null;
+    ratio: number;
+    required: number;
+    measured: boolean;
+    notMeasuredReason?: string;
+}
 /**
  * Coordinator configuration
  */
@@ -140,13 +154,7 @@ export declare class VisualAccessibilityCoordinator extends BaseDomainCoordinato
         url: string;
         wcagLevel?: 'A' | 'AA' | 'AAA';
     }): Promise<Result<{
-        issues: Array<{
-            element: string;
-            foreground: string;
-            background: string;
-            ratio: number;
-            required: number;
-        }>;
+        issues: ContrastIssue[];
     }, Error>>;
     /**
      * Test responsive design across multiple viewports

package/dist/domains/visual-accessibility/coordinator.js

@@ -11,6 +11,7 @@ import { cosineSimilarity } from '../../shared/utils/vector-math.js';
 import { createVisualTesterServiceWithDependencies, } from './services/visual-tester.js';
 import { AccessibilityTesterService, } from './services/accessibility-tester.js';
 import { ResponsiveTesterService, } from './services/responsive-tester.js';
+import { contrastValues, contrastValuesMeasured, defaultRequiredRatio } from './services/accessibility-contrast.js';
 import { A2CAlgorithm } from '../../integrations/rl-suite/algorithms/a2c.js';
 import { createQEFlashAttention } from '../../integrations/ruvector/wrappers.js';
 // CQ-002: Base domain coordinator
@@ -589,13 +590,20 @@ export class VisualAccessibilityCoordinator extends BaseDomainCoordinator {
             }
             // Filter for color contrast violations
             const contrastViolations = auditResult.value.violations.filter((v) => v.id.includes('color-contrast') || v.id.includes('contrast'));
-            const issues = contrastViolations.flatMap((violation) => violation.nodes.map((node) => ({
-                element: node.target.join(' '),
-                foreground: '#000000',
-                background: '#ffffff',
-                ratio: 1.0,
-                required: level === 'AAA' ? 7.0 : 4.5,
-            })));
+            // #1228: the colours and ratio axe-core measured; unreported values are null / -1
+            const issues = contrastViolations.flatMap((violation) => violation.nodes.map((node) => {
+                const values = node.contrast ?? contrastValues(undefined, node.failureSummary);
+                const measured = contrastValuesMeasured(values);
+                return {
+                    element: node.target.join(' '),
+                    foreground: values.foreground,
+                    background: values.background,
+                    ratio: values.ratio ?? -1,
+                    required: values.requiredRatio ?? defaultRequiredRatio(level),
+                    measured,
+                    ...(measured ? {} : { notMeasuredReason: 'axe-core did not report the colours and ratio for this element' }),
+                };
+            }));
             return ok({ issues });
         }
         catch (error) {

package/dist/domains/visual-accessibility/interfaces.d.ts

@@ -187,18 +187,36 @@ export interface ViolationNode {
     readonly target: string[];
     readonly failureSummary: string;
     readonly fixSuggestion?: string;
+    /** Colours and ratio axe-core reported for a contrast violation (#1228). */
+    readonly contrast?: ContrastValues;
+}
+/**
+ * Colours and contrast ratio as the browser measured them (#1228).
+ * A value the browser did not report is null, never a default colour or ratio.
+ */
+export interface ContrastValues {
+    readonly foreground: string | null;
+    readonly background: string | null;
+    readonly ratio: number | null;
+    /** The ratio axe-core required for this element (3:1 for large text), when reported. */
+    readonly requiredRatio: number | null;
 }
 /**
  * Color contrast analysis
  */
 export interface ContrastAnalysis {
     readonly element: string;
-    readonly foreground: string;
-    readonly background: string;
+    /** null when the browser did not report the colour (#1228). */
+    readonly foreground: string | null;
+    readonly background: string | null;
+    /** -1 when the browser did not report the ratio (#1228). */
     readonly ratio: number;
     readonly requiredRatio: number;
     readonly passes: boolean;
     readonly wcagLevel: 'A' | 'AA' | 'AAA';
+    /** false when the colours or ratio were not reported; see notMeasuredReason (#1228). */
+    readonly measured?: boolean;
+    readonly notMeasuredReason?: string;
 }
 export interface VisualRegressionDetectedEvent extends DomainEvent {
     readonly type: 'VisualRegressionDetectedEvent';
@@ -360,12 +378,18 @@ export interface KeyboardNavigationReport {
     readonly tabOrder: TabOrderItem[];
     readonly issues: KeyboardIssue[];
     readonly traps: FocusTrap[];
+    /**
+     * What this report did not measure (#1228). An empty `traps` list, or a
+     * null `hasVisibleFocus`, is not a clean result for an aspect listed here.
+     */
+    readonly notMeasured?: string[];
 }
 export interface TabOrderItem {
     readonly index: number;
     readonly selector: string;
     readonly elementType: string;
-    readonly hasVisibleFocus: boolean;
+    /** null: the focus indicator was not measured (#1228). */
+    readonly hasVisibleFocus: boolean | null;
 }
 export interface KeyboardIssue {
     readonly type: 'no-focus-indicator' | 'skip-link-missing' | 'incorrect-tab-order' | 'non-interactive-focusable';

package/dist/domains/visual-accessibility/services/accessibility-contrast.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Agentic QE v3 - Measured colour contrast values (#1228)
+ *
+ * axe-core reports the colours and ratio it measured for each element checked
+ * by its color-contrast rules: in the check data (fgColor, bgColor,
+ * contrastRatio, expectedContrastRatio) and in the failure summary text. These
+ * helpers carry those values through. A value the browser did not report is
+ * null (or a ratio of -1 in ContrastAnalysis), never a default colour or ratio.
+ */
+import type { ContrastAnalysis, ContrastValues } from '../interfaces.js';
+/** The fields of axe-core's color-contrast check data that AQE keeps. */
+export interface AxeContrastData {
+    fgColor?: string;
+    bgColor?: string;
+    contrastRatio?: number;
+    expectedContrastRatio?: string;
+}
+/** axe-core rule ids that measure text contrast. */
+export declare const CONTRAST_RULE_IDS: readonly ["color-contrast", "color-contrast-enhanced"];
+export declare function isContrastRule(ruleId: string): boolean;
+/**
+ * Browser-side expression `(node) => AxeContrastData | undefined` for an axe-core
+ * result node. Embedded in the scripts that run axe-core in the page.
+ */
+export declare const AXE_CONTRAST_DATA_JS = "function (n) {\n  var checks = [].concat(n.any || [], n.all || [], n.none || []);\n  for (var i = 0; i < checks.length; i++) {\n    var c = checks[i];\n    if ((c.id === 'color-contrast' || c.id === 'color-contrast-enhanced') && c.data) {\n      return {\n        fgColor: c.data.fgColor,\n        bgColor: c.data.bgColor,\n        contrastRatio: c.data.contrastRatio,\n        expectedContrastRatio: c.data.expectedContrastRatio\n      };\n    }\n  }\n  return undefined;\n}";
+/**
+ * Read the values from axe-core's failure summary, e.g. "Element has insufficient
+ * color contrast of 2.32 (foreground color: #aaaaaa, background color: #ffffff,
+ * ...). Expected contrast ratio of 4.5:1".
+ */
+export declare function parseContrastFailureSummary(summary: string | undefined): ContrastValues;
+/** Values from axe-core's check data, with gaps filled from the failure summary. */
+export declare function contrastValues(data: AxeContrastData | undefined, failureSummary?: string): ContrastValues;
+export declare function contrastValuesMeasured(values: ContrastValues): boolean;
+/** The ratio WCAG requires for normal text at a level, when axe-core did not say. */
+export declare function defaultRequiredRatio(level: 'A' | 'AA' | 'AAA'): number;
+/** One element's contrast result; unreported values stay unmeasured. */
+export declare function toContrastAnalysis(element: string, values: ContrastValues, passes: boolean, wcagLevel: 'A' | 'AA' | 'AAA'): ContrastAnalysis;
+//# sourceMappingURL=accessibility-contrast.d.ts.map

package/dist/domains/visual-accessibility/services/accessibility-contrast.js

@@ -0,0 +1,93 @@
+/**
+ * Agentic QE v3 - Measured colour contrast values (#1228)
+ *
+ * axe-core reports the colours and ratio it measured for each element checked
+ * by its color-contrast rules: in the check data (fgColor, bgColor,
+ * contrastRatio, expectedContrastRatio) and in the failure summary text. These
+ * helpers carry those values through. A value the browser did not report is
+ * null (or a ratio of -1 in ContrastAnalysis), never a default colour or ratio.
+ */
+/** axe-core rule ids that measure text contrast. */
+export const CONTRAST_RULE_IDS = ['color-contrast', 'color-contrast-enhanced'];
+export function isContrastRule(ruleId) {
+    return ruleId.includes('contrast');
+}
+/**
+ * Browser-side expression `(node) => AxeContrastData | undefined` for an axe-core
+ * result node. Embedded in the scripts that run axe-core in the page.
+ */
+export const AXE_CONTRAST_DATA_JS = `function (n) {
+  var checks = [].concat(n.any || [], n.all || [], n.none || []);
+  for (var i = 0; i < checks.length; i++) {
+    var c = checks[i];
+    if ((c.id === 'color-contrast' || c.id === 'color-contrast-enhanced') && c.data) {
+      return {
+        fgColor: c.data.fgColor,
+        bgColor: c.data.bgColor,
+        contrastRatio: c.data.contrastRatio,
+        expectedContrastRatio: c.data.expectedContrastRatio
+      };
+    }
+  }
+  return undefined;
+}`;
+const COLOR = '(#[0-9a-f]{3,8}|rgba?\\([^)]*\\))';
+/**
+ * Read the values from axe-core's failure summary, e.g. "Element has insufficient
+ * color contrast of 2.32 (foreground color: #aaaaaa, background color: #ffffff,
+ * ...). Expected contrast ratio of 4.5:1".
+ */
+export function parseContrastFailureSummary(summary) {
+    const text = summary ?? '';
+    const ratio = text.match(/contrast (?:ratio )?of\s*(\d+(?:\.\d+)?)(?![\d.]|\s*:)/i);
+    const fg = text.match(new RegExp(`foreground colou?r:?\\s*${COLOR}`, 'i'));
+    const bg = text.match(new RegExp(`background colou?r:?\\s*${COLOR}`, 'i'));
+    const expected = text.match(/expected contrast ratio of\s*(\d+(?:\.\d+)?)\s*:\s*1/i);
+    return {
+        foreground: fg?.[1] ?? null,
+        background: bg?.[1] ?? null,
+        ratio: validRatio(ratio ? parseFloat(ratio[1]) : undefined),
+        requiredRatio: validRatio(expected ? parseFloat(expected[1]) : undefined),
+    };
+}
+/** Values from axe-core's check data, with gaps filled from the failure summary. */
+export function contrastValues(data, failureSummary) {
+    const parsed = parseContrastFailureSummary(failureSummary);
+    const expected = data?.expectedContrastRatio?.match(/(\d+(?:\.\d+)?)/);
+    return {
+        foreground: nonEmpty(data?.fgColor) ?? parsed.foreground,
+        background: nonEmpty(data?.bgColor) ?? parsed.background,
+        ratio: validRatio(data?.contrastRatio) ?? parsed.ratio,
+        requiredRatio: validRatio(expected ? parseFloat(expected[1]) : undefined) ?? parsed.requiredRatio,
+    };
+}
+export function contrastValuesMeasured(values) {
+    return values.foreground !== null && values.background !== null && values.ratio !== null;
+}
+/** The ratio WCAG requires for normal text at a level, when axe-core did not say. */
+export function defaultRequiredRatio(level) {
+    return level === 'AAA' ? 7 : 4.5;
+}
+/** One element's contrast result; unreported values stay unmeasured. */
+export function toContrastAnalysis(element, values, passes, wcagLevel) {
+    const measured = contrastValuesMeasured(values);
+    return {
+        element,
+        foreground: values.foreground,
+        background: values.background,
+        ratio: values.ratio ?? -1,
+        requiredRatio: values.requiredRatio ?? defaultRequiredRatio(wcagLevel),
+        passes,
+        wcagLevel,
+        measured,
+        ...(measured ? {} : { notMeasuredReason: 'the browser did not report the colours and ratio for this element' }),
+    };
+}
+function validRatio(value) {
+    // A contrast ratio is between 1 and 21; axe-core reports 0 when it could not compute one.
+    return typeof value === 'number' && Number.isFinite(value) && value >= 1 ? value : null;
+}
+function nonEmpty(value) {
+    return typeof value === 'string' && value.trim() !== '' ? value : null;
+}
+//# sourceMappingURL=accessibility-contrast.js.map

package/dist/domains/visual-accessibility/services/accessibility-tester-browser.d.ts

@@ -6,6 +6,7 @@ import { Result } from '../../../shared/types/index.js';
 import { AccessibilityReport, WCAGCriterion, ContrastAnalysis, KeyboardNavigationReport, KeyboardIssue, AuditOptions } from '../interfaces.js';
 import type { VibiumClient, AccessibilityResult as VibiumAccessibilityResult } from '../../../integrations/vibium/index.js';
 import type { IBrowserClient, IAgentBrowserClient } from '../../../integrations/browser/index.js';
+import { type AxeContrastData } from './accessibility-contrast.js';
 /**
  * Axe-core result structure from browser evaluation
  */
@@ -22,6 +23,8 @@ export interface AxeCoreResult {
             html: string;
             target: string[];
             failureSummary?: string;
+            /** color-contrast check data: the measured colours and ratio (#1228) */
+            contrast?: AxeContrastData;
         }>;
     }>;
     passes: string[];
@@ -38,13 +41,18 @@ export declare function isAgentBrowserClient(client: IBrowserClient): client is
  */
 export declare function getAxeTagsForWcagLevel(level: 'A' | 'AA' | 'AAA'): string[];
 /**
- * Map Vibium Severity type to our impact type
+ * Map an axe-core impact or a Vibium severity to our impact type
  */
 export declare function mapImpactSeverity(severity: string): 'critical' | 'serious' | 'moderate' | 'minor';
 /**
  * Extract error message from a Result
  */
 export declare function getErrorMessage<T, E extends Error>(result: Result<T, E>): string;
+/**
+ * Browser-side statements that load axe-core into the page when it is not
+ * loaded yet. For use inside an async function.
+ */
+export declare const AXE_LOADER_JS = "\n      // Check if axe is already loaded\n      if (typeof axe === 'undefined') {\n        // Inject axe-core from CDN\n        const script = document.createElement('script');\n        script.src = 'https://cdnjs.cloudflare.com/ajax/libs/axe-core/4.8.4/axe.min.js';\n        script.crossOrigin = 'anonymous';\n        document.head.appendChild(script);\n\n        // Wait for script to load\n        await new Promise((resolve, reject) => {\n          script.onload = resolve;\n          script.onerror = () => reject(new Error('Failed to load axe-core'));\n          setTimeout(() => reject(new Error('Timeout loading axe-core')), 10000);\n        });\n      }";
 /**
  * Inject and run axe-core in the browser context
  */
@@ -62,9 +70,11 @@ export declare function mapAxeResultToReport(url: string, axeResult: AxeCoreResu
  */
 export declare function mapVibiumResultToReport(url: string, vibiumResult: VibiumAccessibilityResult, wcagLevel: 'A' | 'AA' | 'AAA'): AccessibilityReport;
 /**
- * Extract contrast analysis from Vibium accessibility result
+ * Extract contrast analysis from Vibium accessibility result.
+ * Only elements the audit reported are listed, with the values it reported
+ * (#1228). An error means the contrast rule produced no result.
  */
-export declare function extractContrastFromVibiumResult(vibiumResult: VibiumAccessibilityResult, defaultWCAGLevel: 'A' | 'AA' | 'AAA'): ContrastAnalysis[];
+export declare function extractContrastFromVibiumResult(vibiumResult: VibiumAccessibilityResult, defaultWCAGLevel: 'A' | 'AA' | 'AAA'): Result<ContrastAnalysis[], Error>;
 /**
  * Run accessibility audit using unified browser client (agent-browser or other)
  */
@@ -100,6 +110,11 @@ export declare function checkKeyboardWithVibium(vibiumClient: VibiumClient, url:
     headless: boolean;
     timeout: number;
 }): Promise<Result<KeyboardNavigationReport, Error>>;
+/**
+ * What an automated keyboard check does not measure (#1228): it lists the
+ * focusable elements and runs rule checks, but tabs through nothing.
+ */
+export declare const KEYBOARD_NOT_MEASURED: readonly string[];
 /**
  * Get element type from tag name
  */