@mozole/cli 1.4.3 → 2.0.0-b

package/dist/qa/runner.js

@@ -1,364 +1,318 @@
-import { mkdir, writeFile } from "node:fs/promises";
+import fs from "node:fs/promises";
+import http from "node:http";
 import path from "node:path";
-import { chromium } from "playwright";
-import { updateTelemetry } from "../telemetry/store.js";
-import { visualArtifactKey } from "./artifacts.js";
-import { compareVisualArtifact } from "./diff.js";
-import { acquireServer } from "./server.js";
-export function formatVisualDiff(diff) {
-    const percent = (diff.ratio * 100).toFixed(2);
-    return `${diff.viewport.padEnd(11)} ${diff.route.padEnd(12)} ${percent}% changed (${diff.changedPixels}/${diff.totalPixels} px)${diff.diffPath ? ` -> ${diff.diffPath}` : ""}`;
-}
-export function qaResultPassed(issues, visualDiffs) {
-    return issues.length === 0 && visualDiffs.length === 0;
-}
-function label(viewport) {
-    return `${viewport.width}x${viewport.height}`;
-}
-export { visualArtifactSlug } from "./artifacts.js";
-async function inspectPage(page, baseUrl, route, viewport) {
-    const issues = [];
-    let probes = 0;
-    const geometry = await page.evaluate(() => {
-        const root = document.documentElement;
-        const overflow = Math.max(root.scrollWidth, document.body?.scrollWidth ?? 0) -
-            window.innerWidth;
-        const offenders = [...document.querySelectorAll("body *")]
-            .filter((element) => element.getBoundingClientRect().right > window.innerWidth + 1)
-            .slice(0, 5)
-            .map((element) => ({
-            selector: element.id
-                ? `#${element.id}`
-                : element.classList.length
-                    ? `${element.tagName.toLowerCase()}.${[...element.classList].join(".")}`
-                    : element.tagName.toLowerCase(),
-            pixels: Math.ceil(element.getBoundingClientRect().right - window.innerWidth),
-        }));
-        const unnamed = [
-            ...document.querySelectorAll("button, input, select, textarea, [role=button], [role=link]"),
-        ]
-            .filter((element) => {
-            const text = element.getAttribute("aria-label") ||
-                element.getAttribute("aria-labelledby") ||
-                element.getAttribute("title") ||
-                element.textContent?.trim() ||
-                element.name;
-            return !text && !element.hasAttribute("disabled");
-        })
-            .slice(0, 5)
-            .map((element) => element.outerHTML.slice(0, 120));
-        const hiddenImportant = [
-            ...document.querySelectorAll("[data-mozole-important]"),
-        ]
-            .filter((element) => {
-            const box = element.getBoundingClientRect();
-            const style = getComputedStyle(element);
-            return (box.width === 0 ||
-                box.height === 0 ||
-                style.visibility === "hidden" ||
-                style.display === "none");
-        })
-            .map((element) => element.id || element.className || element.tagName.toLowerCase());
-        return {
-            overflow,
-            offenders,
-            unnamed,
-            hiddenImportant,
-            title: document.title,
-            lang: document.documentElement.lang,
-            headings: document.querySelectorAll("h1").length,
-        };
-    });
-    probes += 6;
-    if (geometry.overflow > 1)
-        issues.push({
-            viewport,
-            route,
-            kind: "overflow",
-            evidence: `${geometry.offenders[0]?.selector ?? "document"}: horizontal overflow ${Math.ceil(geometry.overflow)}px`,
-        });
-    if (!geometry.title)
-        issues.push({
-            viewport,
-            route,
-            kind: "accessibility",
-            evidence: "document title is empty",
-        });
-    if (!geometry.lang)
-        issues.push({
-            viewport,
-            route,
-            kind: "accessibility",
-            evidence: "html lang is missing",
-        });
-    if (!geometry.headings)
-        issues.push({
-            viewport,
-            route,
-            kind: "accessibility",
-            evidence: "page has no h1",
-        });
-    if (geometry.unnamed.length)
-        issues.push({
-            viewport,
-            route,
-            kind: "accessibility",
-            evidence: `unnamed interactive control: ${geometry.unnamed[0]}`,
-        });
-    for (const element of geometry.hiddenImportant)
-        issues.push({
-            viewport,
-            route,
-            kind: "visibility",
-            evidence: `${element}: visible false`,
-        });
-    const links = await page.locator("a[href]").evaluateAll((nodes) => nodes
-        .map((node) => node.href)
-        .filter((href) => {
+import pc from "picocolors";
+import { chromium } from "playwright-core";
+import { findAvailablePort } from "../server/manager.js";
+import { ensureChromiumBrowser, getBrowserLaunchArgs } from "../utils/browser.js";
+import { exists, findProjectRoot } from "../utils/fs.js";
+import { extractBreakpointBoundaries } from "./breakpoints.js";
+import { probeDOM } from "./probe.js";
+const MIME_TYPES = {
+    ".html": "text/html; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".js": "application/javascript; charset=utf-8",
+    ".mjs": "application/javascript; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".woff2": "font/woff2",
+    ".woff": "font/woff",
+    ".ico": "image/x-icon",
+};
+async function createStaticServer(rootDirectory, port) {
+    const realRoot = await fs.realpath(rootDirectory).catch(() => path.resolve(rootDirectory));
+    const realRootPrefix = realRoot.endsWith(path.sep) ? realRoot : realRoot + path.sep;
+    const server = http.createServer(async (req, res) => {
         try {
-            const url = new URL(href);
-            return (url.origin === location.origin &&
-                ["http:", "https:"].includes(url.protocol));
+            const parsedUrl = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+            let reqPath;
+            try {
+                reqPath = decodeURIComponent(parsedUrl.pathname);
+            }
+            catch {
+                res.writeHead(400, { "Content-Type": "text/plain" });
+                res.end("Bad Request");
+                return;
+            }
+            const normalizedRoot = path.resolve(rootDirectory);
+            let filePath = path.resolve(normalizedRoot, `.${path.normalize(reqPath)}`);
+            // Prevent directory traversal attacks escaping rootDirectory
+            if (!filePath.startsWith(normalizedRoot + path.sep) && filePath !== normalizedRoot) {
+                res.writeHead(403, { "Content-Type": "text/plain" });
+                res.end("Forbidden: Access denied outside web root");
+                return;
+            }
+            let stat = await fs.stat(filePath).catch(() => null);
+            if (stat?.isDirectory()) {
+                filePath = path.join(filePath, "index.html");
+                stat = await fs.stat(filePath).catch(() => null);
+            }
+            // Route fallback: /about -> /about.html
+            if (!stat && !path.extname(reqPath)) {
+                const withHtml = path.resolve(normalizedRoot, `.${path.normalize(reqPath)}.html`);
+                if (withHtml.startsWith(normalizedRoot + path.sep)) {
+                    stat = await fs.stat(withHtml).catch(() => null);
+                    if (stat)
+                        filePath = withHtml;
+                }
+            }
+            // SPA fallback to index.html
+            if (!stat) {
+                const spaFallback = path.join(normalizedRoot, "index.html");
+                stat = await fs.stat(spaFallback).catch(() => null);
+                if (stat)
+                    filePath = spaFallback;
+            }
+            if (!stat || !stat.isFile()) {
+                res.writeHead(404, { "Content-Type": "text/plain" });
+                res.end("Not Found");
+                return;
+            }
+            const realTarget = await fs.realpath(filePath).catch(() => null);
+            if (!realTarget || (realTarget !== realRoot && !realTarget.startsWith(realRootPrefix))) {
+                res.writeHead(403, { "Content-Type": "text/plain" });
+                res.end("Forbidden: Access denied outside web root");
+                return;
+            }
+            const ext = path.extname(filePath).toLowerCase();
+            const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+            const content = await fs.readFile(filePath);
+            res.writeHead(200, {
+                "Content-Type": contentType,
+                "Content-Length": content.length,
+                "Cache-Control": "no-cache",
+            });
+            res.end(content);
         }
         catch {
-            return false;
+            res.writeHead(500, { "Content-Type": "text/plain" });
+            res.end("Internal Server Error");
         }
-    }));
-    const unique = [...new Set(links)].slice(0, 100);
-    probes += unique.length;
-    const chunkSize = 5;
-    for (let i = 0; i < unique.length; i += chunkSize) {
-        const chunk = unique.slice(i, i + chunkSize);
-        await Promise.all(chunk.map(async (href) => {
-            try {
-                const response = await page.request.get(href, { timeout: 5_000 });
-                if (response.status() >= 400) {
-                    let pathname = href;
-                    try {
-                        pathname = new URL(href).pathname;
-                    }
-                    catch { }
-                    issues.push({
-                        viewport,
-                        route,
-                        kind: "broken-link",
-                        evidence: `${pathname}: HTTP ${response.status()}`,
-                    });
+    });
+    await new Promise((resolve, reject) => {
+        server.listen(port, "127.0.0.1", () => resolve());
+        server.once("error", reject);
+    });
+    return {
+        serverUrl: `http://127.0.0.1:${port}`,
+        close: () => new Promise((resolve) => {
+            server.close(() => resolve());
+        }),
+    };
+}
+async function discoverRoutesAndDirectory(projectRoot, explicitStaticDir) {
+    let staticDir = explicitStaticDir;
+    if (!staticDir) {
+        const candidates = [
+            path.join(projectRoot, "build", "client"),
+            path.join(projectRoot, "dist"),
+            projectRoot,
+        ];
+        for (const dir of candidates) {
+            if (await exists(dir)) {
+                const indexHtml = path.join(dir, "index.html");
+                if (await exists(indexHtml)) {
+                    staticDir = dir;
+                    break;
                 }
             }
-            catch {
-                let pathname = href;
-                try {
-                    pathname = new URL(href, baseUrl).pathname;
+        }
+    }
+    if (!staticDir || !(await exists(staticDir))) {
+        throw new Error(`No built static directory found in ${projectRoot}. Run 'npm run build' before running live DOM probe.`);
+    }
+    const routes = new Set(["/"]);
+    async function scanHtmlRoutes(dir, base) {
+        if (!(await exists(dir)))
+            return;
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await scanHtmlRoutes(full, `${base}/${entry.name}`);
+            }
+            else if (entry.isFile() && entry.name.endsWith(".html")) {
+                if (entry.name === "__spa-fallback.html")
+                    continue;
+                if (entry.name === "index.html") {
+                    routes.add(base || "/");
+                }
+                else {
+                    const routeName = entry.name.replace(/\.html$/, "");
+                    routes.add(`${base}/${routeName}`);
                 }
-                catch { }
-                issues.push({
-                    viewport,
-                    route,
-                    kind: "broken-link",
-                    evidence: `${pathname}: request failed`,
-                });
             }
-        }));
+        }
     }
-    return { issues, probes };
+    await scanHtmlRoutes(staticDir, "");
+    return { staticDir, routes: Array.from(routes) };
 }
-async function interactionProbes(page, viewport, route) {
-    const issues = [];
-    let probes = 0;
-    const details = page.locator("details");
-    for (let index = 0; index < Math.min(await details.count(), 10); index++) {
-        await details.nth(index).locator("summary").click();
-        probes++;
-        if (!(await details
-            .nth(index)
-            .evaluate((node) => node.open)))
-            issues.push({
-                viewport,
-                route,
-                kind: "interaction",
-                evidence: `details[${index}] did not open`,
-            });
-    }
-    const safe = page.locator("[data-mozole-qa=click]");
-    for (let index = 0; index < Math.min(await safe.count(), 10); index++) {
-        try {
-            await safe.nth(index).click({ timeout: 2_000 });
-            probes++;
+export async function runLiveGeometryProbe(options = {}) {
+    const startTime = Date.now();
+    const cwd = options.cwd ?? process.cwd();
+    const projectRoot = (await findProjectRoot(cwd)) ?? cwd;
+    console.log(pc.cyan(`\n🌐 Launching Headless DOM Geometry & Trace Runner in ${projectRoot}...`));
+    // 1. Detect or provision Chromium/Brave
+    const browserInfo = await ensureChromiumBrowser();
+    console.log(pc.dim(`  • Using browser engine: ${browserInfo.name}${browserInfo.version ? ` (${browserInfo.version})` : ""}`));
+    // 2. Discover built static files & routes
+    const { staticDir, routes: discoveredRoutes } = await discoverRoutesAndDirectory(projectRoot, options.staticDir);
+    const targetRoutes = options.routes ?? discoveredRoutes;
+    // 3. Extract CSS breakpoints to populate boundary viewports
+    const defaultViewports = [
+        { width: 320, height: 600, name: "Mobile Small (320px)" },
+        { width: 390, height: 844, name: "Mobile Standard (390px)" },
+        { width: 768, height: 1024, name: "Tablet (768px)" },
+        { width: 1280, height: 800, name: "Desktop (1280px)" },
+    ];
+    const cssList = [];
+    async function collectCss(dir) {
+        if (!(await exists(dir)))
+            return;
+        for (const e of await fs.readdir(dir, { withFileTypes: true })) {
+            const full = path.join(dir, e.name);
+            if (e.isDirectory() && !["node_modules", ".git"].includes(e.name)) {
+                await collectCss(full);
+            }
+            else if (e.isFile() && e.name.endsWith(".css")) {
+                cssList.push(await fs.readFile(full, "utf8"));
+            }
         }
-        catch (error) {
-            issues.push({
-                viewport,
-                route,
-                kind: "interaction",
-                evidence: `safe click ${index} failed: ${String(error).split("\n")[0]}`,
-            });
+    }
+    await collectCss(staticDir);
+    const boundaryPoints = extractBreakpointBoundaries(cssList, { minWidth: 320, maxWidth: 1440 });
+    for (const bp of boundaryPoints) {
+        if (!defaultViewports.some((v) => v.width === bp)) {
+            defaultViewports.push({ width: bp, height: 800, name: `Breakpoint boundary (${bp}px)` });
         }
     }
-    await page.keyboard.press("Tab");
-    probes++;
-    if (!(await page.evaluate(() => document.activeElement !== document.body)))
-        issues.push({
-            viewport,
-            route,
-            kind: "keyboard",
-            evidence: "Tab did not move focus",
-        });
-    return { issues, probes };
-}
-export async function runQa(root, config, mode, signal) {
-    const server = await acquireServer(root, config, signal);
+    defaultViewports.sort((a, b) => a.width - b.width);
+    const viewportsToTest = options.viewports ?? defaultViewports;
+    // 4. Start local static HTTP server
+    const port = options.port ?? (await findAvailablePort(4173));
+    const staticServer = await createStaticServer(staticDir, port);
+    const findings = [];
     let browser;
-    const issues = [];
-    const visualDiffs = [];
-    let probes = 0;
-    let screenshots = 0;
-    let consoleErrors = 0;
-    let failedRequests = 0;
+    let tracePath;
     try {
-        browser = await chromium.launch({ headless: true });
-        const artifactRoot = path.join(root, ".mozole", "qa");
-        if (mode.visual)
-            await mkdir(artifactRoot, { recursive: true });
-        for (const viewport of config.qa.viewports) {
-            signal?.throwIfAborted();
-            const context = await browser.newContext({ viewport });
-            const page = await context.newPage();
-            const viewportName = label(viewport);
-            page.on("console", (message) => {
-                if (message.type() === "error") {
-                    consoleErrors++;
-                    issues.push({
-                        viewport: viewportName,
-                        route: page.url(),
-                        kind: "console",
-                        evidence: message.text().slice(0, 500),
-                    });
-                }
-            });
-            page.on("pageerror", (error) => issues.push({
-                viewport: viewportName,
-                route: page.url(),
-                kind: "runtime",
-                evidence: error.message.slice(0, 500),
-            }));
-            page.on("requestfailed", (request) => {
-                const failure = request.failure()?.errorText ?? "failed";
-                if (!failure.includes("ERR_ABORTED")) {
-                    failedRequests++;
-                    issues.push({
-                        viewport: viewportName,
-                        route: page.url(),
-                        kind: "network",
-                        evidence: `${request.method()} ${request.url()} ${failure}`,
-                    });
+        browser = await chromium.launch({
+            executablePath: browserInfo.executablePath,
+            headless: true,
+            args: getBrowserLaunchArgs(),
+        });
+        const context = await browser.newContext({
+            serviceWorkers: "block",
+        });
+        // Zero-screenshot policy: snapshots = true, screenshots = false
+        await context.tracing.start({
+            screenshots: false,
+            snapshots: true,
+            sources: true,
+        });
+        const page = await context.newPage();
+        for (const route of targetRoutes) {
+            const url = `${staticServer.serverUrl}${route}`;
+            for (const vp of viewportsToTest) {
+                await page.setViewportSize({ width: vp.width, height: vp.height });
+                await page.goto(url, { waitUntil: "domcontentloaded" });
+                await page.waitForTimeout(50);
+                // Run live probe in browser context
+                const result = (await page.evaluate(probeDOM));
+                for (const [rule, issues] of Object.entries(result.issues)) {
+                    for (const issue of issues) {
+                        findings.push({
+                            rule,
+                            issue,
+                            route,
+                            viewport: vp,
+                        });
+                    }
                 }
-            });
-            page.on("response", (response) => {
-                if (response.status() >= 400) {
-                    failedRequests++;
-                    issues.push({
-                        viewport: viewportName,
-                        route: page.url(),
-                        kind: "network",
-                        evidence: `${response.request().method()} ${response.url()} HTTP ${response.status()}`,
+                // Stress test: 200% font size reflow check (capture sizes first to prevent compounding inheritance)
+                await page.evaluate(() => {
+                    const elements = Array.from(document.querySelectorAll("body, body *"));
+                    const sizes = elements.map((el) => Number.parseFloat(window.getComputedStyle(el).fontSize));
+                    elements.forEach((el, i) => {
+                        if (sizes[i] > 0) {
+                            el.style.setProperty("font-size", `${sizes[i] * 2}px`, "important");
+                        }
                     });
-                }
-            });
-            for (const route of config.routes) {
-                signal?.throwIfAborted();
-                const response = await page.goto(`${server.url}${route}`, {
-                    waitUntil: "networkidle",
-                    timeout: 30_000,
                 });
-                probes++;
-                if (!response || response.status() >= 400) {
-                    issues.push({
-                        viewport: viewportName,
+                await page.waitForTimeout(50);
+                const stressResult = (await page.evaluate(probeDOM));
+                for (const issue of stressResult.issues.overflow) {
+                    findings.push({
+                        rule: "stress-overflow-200",
+                        issue,
                         route,
-                        kind: "route",
-                        evidence: `HTTP ${response?.status() ?? "no response"}`,
+                        viewport: vp,
                     });
-                    continue;
                 }
-                const inspected = await inspectPage(page, server.url, route, viewportName);
-                issues.push(...inspected.issues);
-                probes += inspected.probes;
-                if (mode.interactive) {
-                    const interacted = await interactionProbes(page, viewportName, route);
-                    issues.push(...interacted.issues);
-                    probes += interacted.probes;
-                }
-                if (mode.visual) {
-                    const screenshotPath = path.join(artifactRoot, `${viewportName}-${visualArtifactKey(route)}.png`);
-                    const screenshot = await page.screenshot({ fullPage: true });
-                    if (mode.diff) {
-                        const comparison = await compareVisualArtifact(screenshotPath, screenshot, config.qa.visualDiffThreshold ?? 0.01);
-                        if (comparison.exceeded) {
-                            visualDiffs.push({
-                                viewport: viewportName,
-                                route,
-                                ratio: comparison.ratio,
-                                changedPixels: comparison.changedPixels,
-                                totalPixels: comparison.totalPixels,
-                                diffPath: comparison.diffPath
-                                    ? path.relative(root, comparison.diffPath)
-                                    : undefined,
-                            });
-                        }
-                    }
-                    else {
-                        await writeFile(screenshotPath, screenshot);
-                    }
-                    screenshots++;
+                for (const issue of stressResult.issues.clipping) {
+                    findings.push({
+                        rule: "stress-clipping-200",
+                        issue,
+                        route,
+                        viewport: vp,
+                    });
                 }
             }
-            await context.close();
         }
+        if (findings.length > 0 && options.saveTraceOnFailure !== false) {
+            const traceDir = path.join(projectRoot, "docs", "qa");
+            await fs.mkdir(traceDir, { recursive: true });
+            tracePath = options.tracePath ?? path.join(traceDir, "trace.zip");
+            await context.tracing.stop({ path: tracePath });
+        }
+        else {
+            await context.tracing.stop();
+        }
+        await context.close();
     }
     finally {
-        await browser?.close();
-        await server.stop();
+        if (browser) {
+            await browser.close().catch(() => { });
+        }
+        await staticServer.close().catch(() => { });
+    }
+    const durationMs = Date.now() - startTime;
+    if (findings.length > 0) {
+        console.log(pc.red(`\n  ✗ Found ${findings.length} live DOM geometry / accessibility defect(s) during probe:`));
+        for (const f of findings.slice(0, 15)) {
+            console.log(pc.yellow(`    [${f.rule.toUpperCase()}] ${f.route} @ ${f.viewport.width}px (${f.viewport.name ?? ""})`));
+            console.log(pc.dim(`      Selector: ${f.issue.selector}`));
+            if (f.issue.problem)
+                console.log(pc.dim(`      Problem: ${f.issue.problem}`));
+            if (f.issue.text)
+                console.log(pc.dim(`      Text: "${f.issue.text}"`));
+            if (f.issue.width || f.issue.height) {
+                console.log(pc.dim(`      Size: ${f.issue.width ?? 0}x${f.issue.height ?? 0}px`));
+            }
+        }
+        if (findings.length > 15) {
+            console.log(pc.dim(`    ... and ${findings.length - 15} more findings.`));
+        }
+        if (tracePath) {
+            console.log(pc.cyan(`\n  📦 Trace recording saved to: ${tracePath}`));
+            console.log(pc.dim("    Inspect trace online at https://trace.playwright.dev (zero screenshots, full DOM snapshots & network)."));
+        }
+    }
+    else {
+        console.log(pc.green(`  ✓ Live DOM geometry verified across ${targetRoutes.length} route(s) and ${viewportsToTest.length} viewport(s) with zero defects.`));
+        console.log(pc.dim(`  • Verified in ${durationMs}ms with zero raster screenshots.`));
     }
-    const unique = [
-        ...new Map(issues.map((issue) => [
-            `${issue.viewport}|${issue.route}|${issue.kind}|${issue.evidence}`,
-            issue,
-        ])).values(),
-    ];
-    const passed = qaResultPassed(unique, visualDiffs);
-    const diffOutput = mode.diff
-        ? visualDiffs.length
-            ? `\n\nVISUAL DIFFS\n${visualDiffs.map(formatVisualDiff).join("\n")}`
-            : "\n\nVISUAL DIFFS\nNo changes above threshold."
-        : "";
-    const output = (passed
-        ? `QA PASS\n\n${config.qa.viewports.map((viewport) => `${label(viewport).padEnd(11)} ✓`).join("\n")}\n\nconsole errors   ${consoleErrors}\nfailed requests  ${failedRequests}\noverflow         ${unique.filter((issue) => issue.kind === "overflow").length}\nbroken links     ${unique.filter((issue) => issue.kind === "broken-link").length}${mode.visual ? `\nscreenshots      ${screenshots}` : ""}`
-        : `QA FAIL\n\n${unique
-            .slice(0, 12)
-            .map((issue) => `${issue.viewport} ${issue.route}\n${issue.evidence}`)
-            .join("\n\n")}`) + diffOutput;
-    if (config.telemetry?.enabled)
-        await updateTelemetry(root, (telemetry) => {
-            telemetry.qa.runs++;
-            telemetry.qa.probes += probes;
-            telemetry.qa.screenshots += screenshots;
-            if (mode.visual)
-                telemetry.qa.visualRuns++;
-            telemetry.governor.modelFacingDiagnosticChars += output.length;
-        });
     return {
-        passed,
-        issues: unique,
-        viewports: config.qa.viewports.map(label),
-        consoleErrors,
-        failedRequests,
-        overflows: unique.filter((issue) => issue.kind === "overflow").length,
-        brokenLinks: unique.filter((issue) => issue.kind === "broken-link").length,
-        probes,
-        screenshots,
-        visualDiffs,
-        output,
+        success: findings.length === 0,
+        browserName: browserInfo.name,
+        findings,
+        routesChecked: targetRoutes,
+        viewportsChecked: viewportsToTest,
+        durationMs,
+        traceSavedTo: tracePath,
     };
 }
 //# sourceMappingURL=runner.js.map