agentic-qe 3.15.14 → 3.15.16

package/dist/domains/test-execution/coordinator.js

@@ -160,6 +160,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
                 workers,
                 timeout,
                 retryCount: request.retryCount,
+                projectRoot: request.projectRoot,
             });
         }
         // Sequential execution
@@ -168,6 +169,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
             framework,
             timeout,
             retryCount: request.retryCount,
+            projectRoot: request.projectRoot,
         });
     }
     /**
@@ -176,7 +178,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
      * as passed and flaky in the run's own counts (#1170). When that changes
      * the outcome, the run is stored again with it (#1176).
      */
-    async retryFailures(run, retryCount, testFiles) {
+    async retryFailures(run, retryCount, testFiles, projectRoot) {
         if (!retryCount || retryCount <= 0)
             return;
         if (run.failed === 0) {
@@ -188,6 +190,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
             failedTests: run.failedTests.map(t => t.testId),
             maxRetries: retryCount,
             backoff: 'exponential',
+            projectRoot,
         });
         if (!retried.success)
             return;
@@ -258,7 +261,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
                 // #1176: these first-attempt failures did happen; flaky analysis
                 // records them even when a retry then passes.
                 const firstAttemptFailures = [...result.value.failedTests];
-                await this.retryFailures(result.value, request.retryCount, orderedTestFiles);
+                await this.retryFailures(result.value, request.retryCount, orderedTestFiles, request.projectRoot);
                 // Record execution results for learning
                 if (this.config.enablePrioritization && prioritizationResult) {
                     await this.recordExecutionResults(runId, orderedTestFiles, result.value, prioritizationResult);
@@ -296,7 +299,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
                 if (this.config.infraHealing && result.value.failedTests.length > 0) {
                     this.feedInfraHealingFromFailures(result.value.failedTests);
                     // ADR-057: Attempt automatic recovery and re-run affected tests
-                    const rerunResult = await this.attemptAutoRecoveryAndRerun(result.value.failedTests, request.framework, { timeout: request.timeout, env: request.env, retryCount: request.retryCount });
+                    const rerunResult = await this.attemptAutoRecoveryAndRerun(result.value.failedTests, request.framework, { timeout: request.timeout, env: request.env, retryCount: request.retryCount, projectRoot: request.projectRoot });
                     if (rerunResult)
                         return rerunResult;
                 }
@@ -367,7 +370,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
             this.activeRuns.delete(runId);
             if (result.success) {
                 // #1176: retries finish before the run is recorded or announced.
-                await this.retryFailures(result.value, request.retryCount, orderedTestFiles);
+                await this.retryFailures(result.value, request.retryCount, orderedTestFiles, request.projectRoot);
                 // Record execution results for learning
                 if (this.config.enablePrioritization && prioritizationResult) {
                     await this.recordExecutionResults(runId, orderedTestFiles, result.value, prioritizationResult);
@@ -407,7 +410,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
                 if (this.config.infraHealing && result.value.failedTests.length > 0) {
                     this.feedInfraHealingFromFailures(result.value.failedTests);
                     // ADR-057: Attempt automatic recovery and re-run affected tests
-                    const rerunResult = await this.attemptAutoRecoveryAndRerun(result.value.failedTests, request.framework, { timeout: request.timeout, env: request.env, retryCount: request.retryCount });
+                    const rerunResult = await this.attemptAutoRecoveryAndRerun(result.value.failedTests, request.framework, { timeout: request.timeout, env: request.env, retryCount: request.retryCount, projectRoot: request.projectRoot });
                     if (rerunResult)
                         return rerunResult;
                 }
@@ -510,6 +513,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
             failedTests: testsToRetry,
             maxRetries: request.maxRetries,
             backoff: request.backoff ?? 'exponential',
+            projectRoot: request.projectRoot,
             onRetry: (testId, attempt) => {
                 // Could publish individual retry events here
                 void testId;
@@ -630,6 +634,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
             timeout: originalRequest.timeout,
             env: originalRequest.env,
             retryCount: originalRequest.retryCount,
+            projectRoot: originalRequest.projectRoot,
         });
     }
     /**

package/dist/domains/test-execution/interfaces.d.ts

@@ -47,6 +47,11 @@ export interface ISimpleTestRequest {
     timeout?: number;
     /** Number of parallel workers (default: auto based on file count) */
     workers?: number;
+    /**
+     * #1247: directory to run every file from, already checked to be inside the
+     * project. When omitted, each file runs from its nearest runner project.
+     */
+    projectRoot?: string;
 }
 export interface IExecuteTestsRequest {
     testFiles: string[];
@@ -59,6 +64,11 @@ export interface IExecuteTestsRequest {
      * or TestRunCompleted is published, so both carry the final outcome.
      */
     retryCount?: number;
+    /**
+     * #1247: directory to run every file from, already checked to be inside the
+     * project. When omitted, each file runs from its nearest runner project.
+     */
+    projectRoot?: string;
 }
 export interface IParallelExecutionRequest extends IExecuteTestsRequest {
     workers: number;
@@ -173,6 +183,8 @@ export interface IRetryRequest {
     failedTests: string[];
     maxRetries: number;
     backoff?: 'linear' | 'exponential';
+    /** #1247: the run's explicit projectRoot; retries run from it too. */
+    projectRoot?: string;
 }
 export interface IRetryResult {
     originalFailed: number;

package/dist/domains/test-execution/plugin.js

@@ -5,6 +5,7 @@
 import { err } from '../../shared/types/index.js';
 import { BaseDomainPlugin } from '../domain-interface.js';
 import { requirePayloadFiles } from '../../shared/io/payload-path-guard.js';
+import { requireTestRunTargets } from '../../shared/test-runner-project.js';
 import { createTestExecutionCoordinator } from './coordinator.js';
 import { getGlobalInfraHealing } from '../../strange-loop/infra-healing/global-instance.js';
 import { isMeasuredGapPayload } from '../../shared/events/domain-events.js';
@@ -65,12 +66,14 @@ export class TestExecutionPlugin extends BaseDomainPlugin {
                     // directories (#909 Jest targets) inside the project, passed on as the
                     // real paths that were checked. A missing one is still reported by the
                     // runner.
+                    // #1247: an explicit projectRoot is confined the same way.
                     let testFiles;
+                    let projectRoot;
                     if (payload.testFiles !== undefined) {
-                        const confined = await requirePayloadFiles('execute-tests', 'testFiles', payload.testFiles, { allowMissing: true, allowDirectory: true });
+                        const confined = await requireTestRunTargets('execute-tests', payload.testFiles, payload.projectRoot);
                         if (!confined.success)
                             return confined;
-                        testFiles = confined.value;
+                        ({ testFiles, projectRoot } = confined.value);
                     }
                     // Support both simple and full request formats
                     if (testFiles) {
@@ -81,6 +84,7 @@ export class TestExecutionPlugin extends BaseDomainPlugin {
                             retryCount: payload.retryCount,
                             timeout: payload.timeout,
                             workers: payload.workers,
+                            projectRoot,
                         };
                         return this.coordinator.runTests(request);
                     }

package/dist/domains/test-execution/services/retry-handler.d.ts

@@ -74,6 +74,8 @@ export interface RetryExecutionRequest {
     baseDelay?: number;
     maxDelay?: number;
     onRetry?: (testId: string, attempt: number) => void;
+    /** #1247: the run's explicit projectRoot; every retry runs from it. */
+    projectRoot?: string;
 }
 export interface RetryStatistics {
     totalRetries: number;

package/dist/domains/test-execution/services/retry-handler.js

@@ -6,6 +6,7 @@ import { LoggerFactory } from '../../../logging/index.js';
 import { spawn } from 'node:child_process';
 import { createVitestJsonReport } from '../../../shared/vitest-json-report.js';
 import { jestExactPathPattern, nameFilterArg, runnerFilePath } from '../../../shared/test-runner-args.js';
+import { runnerCwdFor } from '../../../shared/test-runner-project.js';
 import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { resolve as resolvePath } from 'node:path';
 import { ok, err } from '../../../shared/types/index.js';
@@ -92,7 +93,7 @@ export class RetryHandlerService {
      * Execute failed tests with retry logic
      */
     async executeWithRetry(request) {
-        const { runId, failedTests, maxRetries, backoff, baseDelay = 1000, maxDelay = 30000, onRetry, } = request;
+        const { runId, failedTests, maxRetries, backoff, baseDelay = 1000, maxDelay = 30000, onRetry, projectRoot, } = request;
         try {
             const stats = {
                 runId,
@@ -108,7 +109,7 @@ export class RetryHandlerService {
             const unmatched = [];
             const tests = [];
             for (const test of failedTests) {
-                const result = await this.retryTest(test, maxRetries, backoff, baseDelay, maxDelay, onRetry);
+                const result = await this.retryTest(test, maxRetries, backoff, baseDelay, maxDelay, onRetry, projectRoot);
                 stats.totalRetries += result.attempts;
                 if (result.passed) {
                     nowPassing.push(test.testId);
@@ -228,7 +229,7 @@ export class RetryHandlerService {
                 return false;
         }
     }
-    async retryTest(test, maxRetries, backoff, baseDelay, maxDelay, onRetry) {
+    async retryTest(test, maxRetries, backoff, baseDelay, maxDelay, onRetry, projectRoot) {
         let attempts = 0;
         // #1122: the final error is persisted in retry-history, so keep it redacted.
         let lastError = redactFailureText(test.error);
@@ -246,7 +247,7 @@ export class RetryHandlerService {
                 onRetry(test.testId, attempts + 1);
             }
             // Execute test (simulated - in real implementation, would run actual test)
-            const result = await this.executeTest(test);
+            const result = await this.executeTest(test, projectRoot);
             // #1141: a filter that selected no test reran nothing. Report that
             // instead of counting it as a retry, and stop: another attempt would
             // select nothing again.
@@ -272,7 +273,7 @@ export class RetryHandlerService {
             finalError: lastError,
         };
     }
-    async executeTest(test) {
+    async executeTest(test, projectRoot) {
         // In simulation mode (for unit testing), use random behavior
         if (this.config.simulateForTesting) {
             const passOnRetry = secureRandom() < this.config.simulatedRetrySuccessRate;
@@ -282,12 +283,12 @@ export class RetryHandlerService {
             };
         }
         // In production mode, actually execute the test
-        return this.executeRealTest(test);
+        return this.executeRealTest(test, projectRoot);
     }
     /**
      * Execute a real test using the configured test runner
      */
-    async executeRealTest(test) {
+    async executeRealTest(test, projectRoot) {
         const testFile = test.file;
         const testName = test.testName;
         const cwd = this.config.cwd ?? process.cwd();
@@ -295,8 +296,12 @@ export class RetryHandlerService {
         if (!existsSync(testFile)) {
             throw new Error(`Test file not found: ${testFile}. Cannot retry non-existent test file.`);
         }
+        // #1247: retry from the same directory as the first run: the caller's
+        // projectRoot, else a configured directory, else the file's runner
+        // project. The file path stays relative to `cwd`.
+        const runCwd = projectRoot ?? this.config.cwd ?? runnerCwdFor(testFile);
         // Detect or use configured test runner
-        const runner = await this.detectTestRunner(cwd);
+        const runner = await this.detectTestRunner(runCwd);
         if (!runner) {
             throw new Error(`No test runner detected or configured. Install vitest, jest, or mocha, ` +
                 `or configure testRunner in RetryHandlerConfig. Cannot execute retry for: ${testFile}`);
@@ -304,7 +309,7 @@ export class RetryHandlerService {
         // Build command based on runner
         const { command, args, report } = this.buildTestCommand(runner, testFile, testName, cwd);
         // Execute the test
-        return this.spawnTestProcess(command, args, cwd, report, runner === 'vitest' ? testFile : undefined);
+        return this.spawnTestProcess(command, args, runCwd, report, runner === 'vitest' ? testFile : undefined);
     }
     /**
      * Detect which test runner is available in the project

package/dist/domains/test-execution/services/test-executor.d.ts

@@ -113,6 +113,7 @@ export declare class TestExecutorService implements ITestExecutionService {
     private mergeSequentialCoverage;
     private executeTestFile;
     private executeTestFiles;
+    private executeProjectFiles;
     /**
      * Spawn actual test runner process (vitest, jest, mocha)
      */

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

@@ -21,6 +21,7 @@ import { mergeTestCases, redactFailedTests, redactFailureText, testCasesFromRunn
 import { capDiagnostics, getTestRunnerExecutionError, TestRunnerExecutionError } from '../../../shared/test-runner-verdict.js';
 import { createVitestJsonReport } from '../../../shared/vitest-json-report.js';
 import { jestExactPathPattern, runnerFilePath } from '../../../shared/test-runner-args.js';
+import { groupByRunnerProject } 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 +315,7 @@ Provide:
         return ok(undefined);
     }
     async runTests(request) {
-        const { testFiles, framework, timeout = 30000 } = request;
+        const { testFiles, framework, timeout = 30000, projectRoot } = request;
         const failedTests = [];
         const coverages = [];
         const allFileCoverages = [];
@@ -323,7 +324,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);
             executionResults.push(result);
             passed += result.passed;
             failed += result.failed;
@@ -393,16 +394,34 @@ 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) {
+        return this.executeTestFiles([file], framework, timeout, projectRoot);
     }
-    async executeTestFiles(files, framework, timeout) {
+    async executeTestFiles(files, framework, timeout, projectRoot) {
         // 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).
+        const groups = projectRoot
+            ? [{ cwd: projectRoot, files }]
+            : groupByRunnerProject(files);
+        if (groups.length === 1) {
+            return this.executeProjectFiles(groups[0].files, framework, 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 results = await Promise.all(groups.map(group => this.executeProjectFiles(group.files, framework, 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)
@@ -428,7 +447,7 @@ Provide:
     /**
      * Spawn actual test runner process (vitest, jest, mocha)
      */
-    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,7 +485,7 @@ Provide:
             let proc;
             try {
                 proc = spawn(command, args, {
-                    cwd: process.cwd(),
+                    cwd,
                     detached: process.platform !== 'win32',
                     env: {
                         ...process.env,
@@ -999,7 +1018,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);
     }
     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