cbrowser 7.2.0 → 7.4.0

package/dist/browser.js

@@ -6,59 +6,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FluentCBrowser = exports.CBrowser = void 0;
-exports.parseNaturalLanguage = parseNaturalLanguage;
-exports.executeNaturalLanguage = executeNaturalLanguage;
-exports.executeNaturalLanguageScript = executeNaturalLanguageScript;
-exports.findElementByIntent = findElementByIntent;
-exports.huntBugs = huntBugs;
-exports.crossBrowserDiff = crossBrowserDiff;
-exports.applyChaos = applyChaos;
-exports.runChaosTest = runChaosTest;
-exports.comparePersonas = comparePersonas;
-exports.formatComparisonReport = formatComparisonReport;
-exports.parseNLInstruction = parseNLInstruction;
-exports.parseNLTestSuite = parseNLTestSuite;
-exports.runNLTestSuite = runNLTestSuite;
-exports.formatNLTestReport = formatNLTestReport;
-exports.runNLTestFile = runNLTestFile;
-exports.repairTest = repairTest;
-exports.repairTestSuite = repairTestSuite;
-exports.formatRepairReport = formatRepairReport;
-exports.exportRepairedTest = exportRepairedTest;
-exports.detectFlakyTests = detectFlakyTests;
-exports.formatFlakyTestReport = formatFlakyTestReport;
-exports.capturePerformanceBaseline = capturePerformanceBaseline;
-exports.listPerformanceBaselines = listPerformanceBaselines;
-exports.loadPerformanceBaseline = loadPerformanceBaseline;
-exports.deletePerformanceBaseline = deletePerformanceBaseline;
-exports.detectPerformanceRegression = detectPerformanceRegression;
-exports.formatPerformanceRegressionReport = formatPerformanceRegressionReport;
-exports.parseTestFilesForCoverage = parseTestFilesForCoverage;
-exports.parseSitemap = parseSitemap;
-exports.crawlSiteForCoverage = crawlSiteForCoverage;
-exports.identifyCoverageGaps = identifyCoverageGaps;
-exports.calculateCoverageAnalysis = calculateCoverageAnalysis;
-exports.generateCoverageMap = generateCoverageMap;
-exports.formatCoverageReport = formatCoverageReport;
-exports.generateCoverageHtmlReport = generateCoverageHtmlReport;
-exports.loadVisualBaselines = loadVisualBaselines;
-exports.captureVisualBaseline = captureVisualBaseline;
-exports.listVisualBaselines = listVisualBaselines;
-exports.getVisualBaseline = getVisualBaseline;
-exports.deleteVisualBaseline = deleteVisualBaseline;
-exports.runVisualRegression = runVisualRegression;
-exports.runVisualRegressionSuite = runVisualRegressionSuite;
-exports.formatVisualRegressionReport = formatVisualRegressionReport;
-exports.generateVisualRegressionHtmlReport = generateVisualRegressionHtmlReport;
-exports.runCrossBrowserTest = runCrossBrowserTest;
-exports.runCrossBrowserSuite = runCrossBrowserSuite;
-exports.formatCrossBrowserReport = formatCrossBrowserReport;
-exports.generateCrossBrowserHtmlReport = generateCrossBrowserHtmlReport;
-exports.runResponsiveTest = runResponsiveTest;
-exports.runResponsiveSuite = runResponsiveSuite;
-exports.formatResponsiveReport = formatResponsiveReport;
-exports.generateResponsiveHtmlReport = generateResponsiveHtmlReport;
-exports.listViewportPresets = listViewportPresets;
 const playwright_1 = require("playwright");
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -2319,4339 +2266,4 @@ class FluentCBrowser {
     }
 }
 exports.FluentCBrowser = FluentCBrowser;
-// ============================================================================
-// Tier 3: Natural Language API (v3.0.0)
-// ============================================================================
-/**
- * Natural language command patterns.
- */
-const NL_PATTERNS = [
-    // Navigation
-    { pattern: /^(?:go to|navigate to|open|visit)\s+(.+)$/i, action: "navigate", extract: (m) => ({ url: m[1] }) },
-    { pattern: /^(?:go\s+)?back$/i, action: "back", extract: () => ({}) },
-    { pattern: /^(?:go\s+)?forward$/i, action: "forward", extract: () => ({}) },
-    { pattern: /^refresh|reload$/i, action: "reload", extract: () => ({}) },
-    // Clicking
-    { pattern: /^click(?:\s+on)?\s+(?:the\s+)?["']?(.+?)["']?$/i, action: "click", extract: (m) => ({ selector: m[1] }) },
-    { pattern: /^press(?:\s+the)?\s+["']?(.+?)["']?(?:\s+button)?$/i, action: "click", extract: (m) => ({ selector: m[1] }) },
-    { pattern: /^tap(?:\s+on)?\s+["']?(.+?)["']?$/i, action: "click", extract: (m) => ({ selector: m[1] }) },
-    // Form filling
-    { pattern: /^(?:type|enter|input|fill(?:\s+in)?)\s+["'](.+?)["']\s+(?:in(?:to)?|on)\s+(?:the\s+)?["']?(.+?)["']?$/i, action: "fill", extract: (m) => ({ value: m[1], selector: m[2] }) },
-    { pattern: /^(?:fill(?:\s+in)?|set)\s+(?:the\s+)?["']?(.+?)["']?\s+(?:to|with|as)\s+["'](.+?)["']$/i, action: "fill", extract: (m) => ({ selector: m[1], value: m[2] }) },
-    // Selecting
-    { pattern: /^select\s+["'](.+?)["']\s+(?:from|in)\s+(?:the\s+)?["']?(.+?)["']?$/i, action: "select", extract: (m) => ({ value: m[1], selector: m[2] }) },
-    { pattern: /^choose\s+["'](.+?)["']$/i, action: "click", extract: (m) => ({ selector: m[1] }) },
-    // Screenshots
-    { pattern: /^(?:take\s+a?\s*)?screenshot(?:\s+as\s+["']?(.+?)["']?)?$/i, action: "screenshot", extract: (m) => ({ path: m[1] || "" }) },
-    { pattern: /^capture(?:\s+the)?\s+(?:page|screen)$/i, action: "screenshot", extract: () => ({}) },
-    // Waiting
-    { pattern: /^wait(?:\s+for)?\s+(\d+)\s*(?:ms|milliseconds?)?$/i, action: "wait", extract: (m) => ({ ms: m[1] }) },
-    { pattern: /^wait(?:\s+for)?\s+(\d+)\s*(?:s|seconds?)$/i, action: "waitSeconds", extract: (m) => ({ seconds: m[1] }) },
-    { pattern: /^wait(?:\s+for)?\s+["']?(.+?)["']?(?:\s+to\s+appear)?$/i, action: "waitFor", extract: (m) => ({ selector: m[1] }) },
-    // Scrolling
-    { pattern: /^scroll\s+(?:to\s+)?(?:the\s+)?(top|bottom)$/i, action: "scroll", extract: (m) => ({ direction: m[1] }) },
-    { pattern: /^scroll\s+(up|down)(?:\s+(\d+))?$/i, action: "scrollBy", extract: (m) => ({ direction: m[1], amount: m[2] || "300" }) },
-    // Extraction
-    { pattern: /^(?:get|extract|find)\s+(?:all\s+)?(?:the\s+)?(.+)$/i, action: "extract", extract: (m) => ({ what: m[1] }) },
-];
-/**
- * Parse natural language into browser action.
- */
-function parseNaturalLanguage(command) {
-    const trimmed = command.trim();
-    for (const { pattern, action, extract } of NL_PATTERNS) {
-        const match = trimmed.match(pattern);
-        if (match) {
-            return { action, params: extract(match) };
-        }
-    }
-    return null;
-}
-/**
- * Execute a natural language command.
- */
-async function executeNaturalLanguage(browser, command) {
-    const parsed = parseNaturalLanguage(command);
-    if (!parsed) {
-        return { success: false, action: "unknown", error: `Could not parse command: "${command}"` };
-    }
-    const { action, params } = parsed;
-    try {
-        let result;
-        switch (action) {
-            case "navigate":
-                result = await browser.navigate(params.url);
-                break;
-            case "click":
-                result = await browser.click(params.selector);
-                break;
-            case "fill":
-                result = await browser.fill(params.selector, params.value);
-                break;
-            case "screenshot":
-                result = await browser.screenshot(params.path || undefined);
-                break;
-            case "wait":
-                await new Promise(r => setTimeout(r, parseInt(params.ms)));
-                result = { waited: parseInt(params.ms) };
-                break;
-            case "waitSeconds":
-                await new Promise(r => setTimeout(r, parseInt(params.seconds) * 1000));
-                result = { waited: parseInt(params.seconds) * 1000 };
-                break;
-            case "extract":
-                result = await browser.extract(params.what);
-                break;
-            default:
-                return { success: false, action, error: `Unsupported action: ${action}` };
-        }
-        return { success: true, action, result };
-    }
-    catch (e) {
-        return { success: false, action, error: e.message };
-    }
-}
-/**
- * Execute multiple natural language commands in sequence.
- */
-async function executeNaturalLanguageScript(browser, commands) {
-    const results = [];
-    for (const command of commands) {
-        if (!command.trim() || command.startsWith("#"))
-            continue; // Skip empty lines and comments
-        const result = await executeNaturalLanguage(browser, command);
-        results.push({ command, ...result });
-        if (!result.success)
-            break; // Stop on first error
-    }
-    return results;
-}
-// ============================================================================
-// Tier 4: Visual AI Understanding (v4.0.0)
-// ============================================================================
-/**
- * AI-powered semantic element finding.
- * Examples: "the cheapest product", "login form", "main navigation"
- */
-async function findElementByIntent(browser, intent) {
-    const page = await browser.getPage();
-    // Extract page structure for AI analysis
-    const pageData = await page.evaluate(() => {
-        const elements = [];
-        // Find interactive elements
-        const interactives = document.querySelectorAll("button, a, input, select, [role='button'], [onclick], .btn, .card, .product, [data-price], .price");
-        interactives.forEach((el, i) => {
-            const text = el.innerText?.trim().slice(0, 100) || "";
-            const priceMatch = text.match(/\$[\d,.]+|\d+\.\d{2}/);
-            elements.push({
-                tag: el.tagName.toLowerCase(),
-                text,
-                classes: el.className.toString().slice(0, 100),
-                id: el.id,
-                role: el.getAttribute("role") || "",
-                type: el.type || "",
-                price: priceMatch ? priceMatch[0] : undefined,
-                selector: el.id ? `#${el.id}` : `${el.tagName.toLowerCase()}:nth-of-type(${i + 1})`,
-            });
-        });
-        return elements;
-    });
-    // Intent matching logic
-    const intentLower = intent.toLowerCase();
-    // Price-based intents
-    if (intentLower.includes("cheapest") || intentLower.includes("lowest price")) {
-        const withPrices = pageData.filter(el => el.price);
-        if (withPrices.length > 0) {
-            const sorted = withPrices.sort((a, b) => {
-                const priceA = parseFloat(a.price.replace(/[$,]/g, ""));
-                const priceB = parseFloat(b.price.replace(/[$,]/g, ""));
-                return priceA - priceB;
-            });
-            return {
-                selector: sorted[0].selector,
-                confidence: 0.8,
-                description: `Cheapest item: ${sorted[0].text.slice(0, 50)} (${sorted[0].price})`,
-            };
-        }
-    }
-    if (intentLower.includes("most expensive") || intentLower.includes("highest price")) {
-        const withPrices = pageData.filter(el => el.price);
-        if (withPrices.length > 0) {
-            const sorted = withPrices.sort((a, b) => {
-                const priceA = parseFloat(a.price.replace(/[$,]/g, ""));
-                const priceB = parseFloat(b.price.replace(/[$,]/g, ""));
-                return priceB - priceA;
-            });
-            return {
-                selector: sorted[0].selector,
-                confidence: 0.8,
-                description: `Most expensive: ${sorted[0].text.slice(0, 50)} (${sorted[0].price})`,
-            };
-        }
-    }
-    // Form-based intents
-    if (intentLower.includes("login") || intentLower.includes("sign in")) {
-        const loginBtn = pageData.find(el => el.text.toLowerCase().includes("login") ||
-            el.text.toLowerCase().includes("sign in") ||
-            el.classes.includes("login"));
-        if (loginBtn) {
-            return { selector: loginBtn.selector, confidence: 0.9, description: "Login button/form" };
-        }
-    }
-    if (intentLower.includes("search")) {
-        const searchInput = pageData.find(el => el.type === "search" ||
-            el.classes.includes("search") ||
-            el.id.includes("search"));
-        if (searchInput) {
-            return { selector: searchInput.selector, confidence: 0.9, description: "Search input" };
-        }
-    }
-    // Text-based matching
-    const textMatch = pageData.find(el => el.text.toLowerCase().includes(intentLower) ||
-        el.classes.toLowerCase().includes(intentLower));
-    if (textMatch) {
-        return { selector: textMatch.selector, confidence: 0.7, description: `Matched: ${textMatch.text.slice(0, 50)}` };
-    }
-    return null;
-}
-/**
- * Autonomously explore a page and find bugs.
- */
-async function huntBugs(browser, url, options = {}) {
-    const startTime = Date.now();
-    const bugs = [];
-    const visited = new Set();
-    const maxPages = options.maxPages || 10;
-    const timeout = options.timeout || 60000;
-    const page = await browser.getPage();
-    const consoleErrors = [];
-    // Capture console errors
-    page.on("console", (msg) => {
-        if (msg.type() === "error") {
-            consoleErrors.push(msg.text());
-        }
-    });
-    // Start with initial URL
-    await browser.navigate(url);
-    visited.add(url);
-    // Check for issues on current page
-    const pageIssues = await page.evaluate(() => {
-        const issues = [];
-        // Check for broken images
-        document.querySelectorAll("img").forEach((img, i) => {
-            if (!img.complete || img.naturalWidth === 0) {
-                issues.push({
-                    type: "missing-image",
-                    description: `Broken image: ${img.src || img.alt || "unknown"}`,
-                    selector: `img:nth-of-type(${i + 1})`,
-                });
-            }
-        });
-        // Check for empty links
-        document.querySelectorAll("a").forEach((a, i) => {
-            if (!a.href || a.href === "#" || a.href === "javascript:void(0)") {
-                issues.push({
-                    type: "broken-link",
-                    description: `Empty/invalid link: ${a.textContent?.slice(0, 50) || "no text"}`,
-                    selector: `a:nth-of-type(${i + 1})`,
-                });
-            }
-        });
-        // Check for empty buttons
-        document.querySelectorAll("button").forEach((btn, i) => {
-            if (!btn.textContent?.trim() && !btn.getAttribute("aria-label")) {
-                issues.push({
-                    type: "a11y-violation",
-                    description: "Button with no accessible text",
-                    selector: `button:nth-of-type(${i + 1})`,
-                });
-            }
-        });
-        // Check for missing form labels
-        document.querySelectorAll("input:not([type='hidden'])").forEach((input, i) => {
-            const id = input.id;
-            const hasLabel = id && document.querySelector(`label[for="${id}"]`);
-            if (!hasLabel && !input.getAttribute("aria-label") && !input.getAttribute("placeholder")) {
-                issues.push({
-                    type: "form-error",
-                    description: "Input without label or placeholder",
-                    selector: `input:nth-of-type(${i + 1})`,
-                });
-            }
-        });
-        return issues;
-    });
-    // Add page issues to bugs
-    for (const issue of pageIssues) {
-        bugs.push({
-            type: issue.type,
-            severity: issue.type === "a11y-violation" ? "high" : "medium",
-            description: issue.description,
-            url,
-            selector: issue.selector,
-        });
-    }
-    // Add console errors
-    for (const error of consoleErrors) {
-        bugs.push({
-            type: "console-error",
-            severity: "high",
-            description: error.slice(0, 200),
-            url,
-        });
-    }
-    return {
-        bugs,
-        pagesVisited: visited.size,
-        duration: Date.now() - startTime,
-    };
-}
-/**
- * Compare page behavior across multiple browsers.
- */
-async function crossBrowserDiff(url, browsers = ["chromium", "firefox", "webkit"]) {
-    const { chromium, firefox, webkit } = await import("playwright");
-    const screenshots = {};
-    const metrics = {};
-    const differences = [];
-    const contents = {};
-    const browserLaunchers = { chromium, firefox, webkit };
-    for (const browserName of browsers) {
-        const launcher = browserLaunchers[browserName];
-        const browser = await launcher.launch({ headless: true });
-        const page = await browser.newPage();
-        const startTime = Date.now();
-        await page.goto(url, { waitUntil: "domcontentloaded" });
-        const loadTime = Date.now() - startTime;
-        // Capture metrics
-        const resourceCount = await page.evaluate(() => performance.getEntriesByType("resource").length);
-        metrics[browserName] = { loadTime, resourceCount };
-        // Capture screenshot
-        const screenshotPath = `/tmp/cross-browser-${browserName}-${Date.now()}.png`;
-        await page.screenshot({ path: screenshotPath, fullPage: true });
-        screenshots[browserName] = screenshotPath;
-        // Capture content hash
-        contents[browserName] = await page.evaluate(() => document.body.innerText.slice(0, 1000));
-        await browser.close();
-    }
-    // Compare timing
-    const loadTimes = Object.entries(metrics).map(([b, m]) => ({ browser: b, time: m.loadTime }));
-    const avgTime = loadTimes.reduce((sum, t) => sum + t.time, 0) / loadTimes.length;
-    const slowBrowsers = loadTimes.filter(t => t.time > avgTime * 1.5);
-    if (slowBrowsers.length > 0) {
-        differences.push({
-            type: "timing",
-            description: `Significantly slower in: ${slowBrowsers.map(b => `${b.browser} (${b.time}ms)`).join(", ")}`,
-            browsers: slowBrowsers.map(b => b.browser),
-        });
-    }
-    // Compare content
-    const contentValues = Object.values(contents);
-    const contentMismatch = contentValues.some(c => c !== contentValues[0]);
-    if (contentMismatch) {
-        differences.push({
-            type: "content",
-            description: "Page content differs between browsers",
-            browsers,
-        });
-    }
-    return { url, browsers, differences, screenshots, metrics };
-}
-/**
- * Apply chaos engineering conditions to browser.
- */
-async function applyChaos(browser, config) {
-    const context = await browser.context;
-    const page = await browser.getPage();
-    // Network conditions
-    if (config.offline) {
-        await context.setOffline(true);
-    }
-    // Route interception for latency/failures
-    if (config.networkLatency || config.blockUrls || config.failApis) {
-        await page.route("**/*", async (route) => {
-            const url = route.request().url();
-            // Block URLs
-            if (config.blockUrls?.some(pattern => url.includes(pattern))) {
-                await route.abort();
-                return;
-            }
-            // Fail specific APIs
-            const failConfig = config.failApis?.find(f => url.includes(f.pattern));
-            if (failConfig) {
-                await route.fulfill({
-                    status: failConfig.status,
-                    body: failConfig.body || "Chaos: Simulated failure",
-                });
-                return;
-            }
-            // Add latency
-            if (config.networkLatency) {
-                await new Promise(r => setTimeout(r, config.networkLatency));
-            }
-            // Random delays
-            if (config.randomDelays && Math.random() < config.randomDelays) {
-                await new Promise(r => setTimeout(r, Math.random() * 3000));
-            }
-            await route.continue();
-        });
-    }
-}
-/**
- * Run chaos test - apply conditions and verify app resilience.
- */
-async function runChaosTest(browser, url, chaos, actions = []) {
-    const startTime = Date.now();
-    const errors = [];
-    try {
-        await applyChaos(browser, chaos);
-        await browser.navigate(url);
-        // Execute actions
-        for (const action of actions) {
-            const result = await executeNaturalLanguage(browser, action);
-            if (!result.success) {
-                errors.push(`Action failed: ${action} - ${result.error}`);
-            }
-        }
-        const screenshot = await browser.screenshot();
-        return {
-            passed: errors.length === 0,
-            errors,
-            duration: Date.now() - startTime,
-            screenshot,
-        };
-    }
-    catch (e) {
-        return {
-            passed: false,
-            errors: [...errors, e.message],
-            duration: Date.now() - startTime,
-            screenshot: "",
-        };
-    }
-}
-/**
- * Run the same journey with multiple personas and compare results.
- * This runs personas in parallel (up to maxConcurrency) for efficiency.
- */
-async function comparePersonas(options) {
-    const { startUrl, goal, personas, maxSteps = 20, maxConcurrency = 3, headless = true, } = options;
-    const startTime = Date.now();
-    const results = [];
-    console.log(`\n🔄 Comparing ${personas.length} personas...`);
-    console.log(`   URL: ${startUrl}`);
-    console.log(`   Goal: ${goal}`);
-    console.log(`   Concurrency: ${maxConcurrency}\n`);
-    // Process personas in batches
-    for (let i = 0; i < personas.length; i += maxConcurrency) {
-        const batch = personas.slice(i, i + maxConcurrency);
-        console.log(`📦 Batch ${Math.floor(i / maxConcurrency) + 1}: ${batch.join(", ")}`);
-        const batchPromises = batch.map(async (personaName) => {
-            const browser = new CBrowser({ headless });
-            try {
-                const persona = (0, personas_js_1.getPersona)(personaName) || personas_js_1.BUILTIN_PERSONAS["first-timer"];
-                const journeyStart = Date.now();
-                // Run the journey
-                const journey = await browser.journey({
-                    persona: personaName,
-                    startUrl,
-                    goal,
-                    maxSteps,
-                });
-                // Calculate average reaction time from persona config
-                const timing = persona.humanBehavior?.timing;
-                const avgReactionTime = timing
-                    ? (timing.reactionTime.min + timing.reactionTime.max) / 2
-                    : 500;
-                // Calculate error rate from persona config
-                const errors = persona.humanBehavior?.errors;
-                const errorRate = errors
-                    ? (errors.misClickRate + errors.typoRate) / 2
-                    : 0.05;
-                const result = {
-                    persona: personaName,
-                    description: persona.description,
-                    techLevel: persona.demographics.tech_level || "intermediate",
-                    device: persona.demographics.device || "desktop",
-                    success: journey.success,
-                    totalTime: journey.totalTime,
-                    stepCount: journey.steps.length,
-                    frictionCount: journey.frictionPoints.length,
-                    frictionPoints: journey.frictionPoints,
-                    avgReactionTime,
-                    errorRate,
-                    screenshots: {
-                        start: journey.steps[0]?.screenshot || "",
-                        end: journey.steps[journey.steps.length - 1]?.screenshot || "",
-                    },
-                };
-                console.log(`   ✓ ${personaName}: ${journey.success ? "SUCCESS" : "FAILED"} (${journey.totalTime}ms, ${journey.frictionPoints.length} friction)`);
-                return result;
-            }
-            catch (e) {
-                console.log(`   ✗ ${personaName}: ERROR - ${e.message}`);
-                return {
-                    persona: personaName,
-                    description: "Unknown",
-                    techLevel: "unknown",
-                    device: "unknown",
-                    success: false,
-                    totalTime: 0,
-                    stepCount: 0,
-                    frictionCount: 1,
-                    frictionPoints: [`Error: ${e.message}`],
-                    avgReactionTime: 0,
-                    errorRate: 0,
-                    screenshots: { start: "", end: "" },
-                };
-            }
-            finally {
-                await browser.close();
-            }
-        });
-        const batchResults = await Promise.all(batchPromises);
-        results.push(...batchResults);
-    }
-    // Generate summary
-    const successfulResults = results.filter((r) => r.success);
-    const failedResults = results.filter((r) => !r.success);
-    const sortedByTime = [...successfulResults].sort((a, b) => a.totalTime - b.totalTime);
-    const sortedByFriction = [...results].sort((a, b) => b.frictionCount - a.frictionCount);
-    // Collect all friction points
-    const allFrictionPoints = results.flatMap((r) => r.frictionPoints);
-    const frictionCounts = allFrictionPoints.reduce((acc, fp) => {
-        acc[fp] = (acc[fp] || 0) + 1;
-        return acc;
-    }, {});
-    const commonFriction = Object.entries(frictionCounts)
-        .filter(([_, count]) => count > 1)
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, 5)
-        .map(([fp]) => fp);
-    // Generate recommendations
-    const recommendations = [];
-    if (failedResults.length > 0) {
-        recommendations.push(`⚠️ ${failedResults.length} persona(s) failed to complete the journey: ${failedResults.map((r) => r.persona).join(", ")}`);
-    }
-    if (sortedByFriction[0]?.frictionCount > 0) {
-        recommendations.push(`🔧 "${sortedByFriction[0].persona}" experienced the most friction (${sortedByFriction[0].frictionCount} points) - review for accessibility improvements`);
-    }
-    const beginnerPersonas = results.filter((r) => r.techLevel === "beginner");
-    const expertPersonas = results.filter((r) => r.techLevel === "expert");
-    if (beginnerPersonas.length > 0 && expertPersonas.length > 0) {
-        const avgBeginnerTime = beginnerPersonas.reduce((sum, r) => sum + r.totalTime, 0) / beginnerPersonas.length;
-        const avgExpertTime = expertPersonas.reduce((sum, r) => sum + r.totalTime, 0) / expertPersonas.length;
-        if (avgBeginnerTime > avgExpertTime * 3) {
-            recommendations.push(`📚 Beginners take ${(avgBeginnerTime / avgExpertTime).toFixed(1)}x longer than experts - consider adding more guidance`);
-        }
-    }
-    const mobilePersonas = results.filter((r) => r.device === "mobile");
-    const desktopPersonas = results.filter((r) => r.device === "desktop");
-    if (mobilePersonas.length > 0 && desktopPersonas.length > 0) {
-        const mobileFriction = mobilePersonas.reduce((sum, r) => sum + r.frictionCount, 0) / mobilePersonas.length;
-        const desktopFriction = desktopPersonas.reduce((sum, r) => sum + r.frictionCount, 0) / desktopPersonas.length;
-        if (mobileFriction > desktopFriction * 2) {
-            recommendations.push(`📱 Mobile users experience ${(mobileFriction / desktopFriction).toFixed(1)}x more friction - review mobile UX`);
-        }
-    }
-    if (commonFriction.length > 0) {
-        recommendations.push(`🎯 Common friction points across personas: ${commonFriction.slice(0, 3).join("; ")}`);
-    }
-    if (recommendations.length === 0) {
-        recommendations.push("✅ All personas completed the journey without significant issues");
-    }
-    const avgTime = successfulResults.length > 0
-        ? successfulResults.reduce((sum, r) => sum + r.totalTime, 0) / successfulResults.length
-        : 0;
-    const comparison = {
-        url: startUrl,
-        goal,
-        timestamp: new Date().toISOString(),
-        duration: Date.now() - startTime,
-        personas: results,
-        summary: {
-            totalPersonas: personas.length,
-            successCount: successfulResults.length,
-            failureCount: failedResults.length,
-            fastestPersona: sortedByTime[0]?.persona || "N/A",
-            slowestPersona: sortedByTime[sortedByTime.length - 1]?.persona || "N/A",
-            mostFriction: sortedByFriction[0]?.persona || "N/A",
-            leastFriction: sortedByFriction[sortedByFriction.length - 1]?.persona || "N/A",
-            avgCompletionTime: Math.round(avgTime),
-            commonFrictionPoints: commonFriction,
-        },
-        recommendations,
-    };
-    return comparison;
-}
-/**
- * Generate a formatted comparison report.
- */
-function formatComparisonReport(comparison) {
-    const lines = [];
-    lines.push("");
-    lines.push("╔══════════════════════════════════════════════════════════════════════════════╗");
-    lines.push("║                    MULTI-PERSONA COMPARISON REPORT                           ║");
-    lines.push("╚══════════════════════════════════════════════════════════════════════════════╝");
-    lines.push("");
-    lines.push(`📍 URL: ${comparison.url}`);
-    lines.push(`🎯 Goal: ${comparison.goal}`);
-    lines.push(`⏱️  Total Duration: ${(comparison.duration / 1000).toFixed(1)}s`);
-    lines.push(`📅 Timestamp: ${comparison.timestamp}`);
-    lines.push("");
-    // Results table
-    lines.push("┌─────────────────────┬──────────┬──────────┬──────────┬──────────┬─────────────────────────────┐");
-    lines.push("│ Persona             │ Success  │ Time     │ Steps    │ Friction │ Key Issues                  │");
-    lines.push("├─────────────────────┼──────────┼──────────┼──────────┼──────────┼─────────────────────────────┤");
-    for (const result of comparison.personas) {
-        const name = result.persona.padEnd(19).slice(0, 19);
-        const success = result.success ? "✓".padEnd(8) : "✗".padEnd(8);
-        const time = `${(result.totalTime / 1000).toFixed(1)}s`.padEnd(8);
-        const steps = `${result.stepCount}`.padEnd(8);
-        const friction = `${result.frictionCount}`.padEnd(8);
-        const issues = (result.frictionPoints[0] || "-").slice(0, 27).padEnd(27);
-        lines.push(`│ ${name} │ ${success} │ ${time} │ ${steps} │ ${friction} │ ${issues} │`);
-    }
-    lines.push("└─────────────────────┴──────────┴──────────┴──────────┴──────────┴─────────────────────────────┘");
-    lines.push("");
-    // Summary
-    lines.push("📊 SUMMARY");
-    lines.push("─".repeat(60));
-    lines.push(`  Total Personas: ${comparison.summary.totalPersonas}`);
-    lines.push(`  Success Rate: ${comparison.summary.successCount}/${comparison.summary.totalPersonas} (${Math.round((comparison.summary.successCount / comparison.summary.totalPersonas) * 100)}%)`);
-    lines.push(`  Avg Completion Time: ${(comparison.summary.avgCompletionTime / 1000).toFixed(1)}s`);
-    lines.push(`  Fastest: ${comparison.summary.fastestPersona}`);
-    lines.push(`  Slowest: ${comparison.summary.slowestPersona}`);
-    lines.push(`  Most Friction: ${comparison.summary.mostFriction}`);
-    lines.push(`  Least Friction: ${comparison.summary.leastFriction}`);
-    lines.push("");
-    // Recommendations
-    lines.push("💡 RECOMMENDATIONS");
-    lines.push("─".repeat(60));
-    for (const rec of comparison.recommendations) {
-        lines.push(`  ${rec}`);
-    }
-    lines.push("");
-    return lines.join("\n");
-}
-// =========================================================================
-// Natural Language Test Suites
-// =========================================================================
-/**
- * Parse a single natural language instruction into an NLTestStep.
- *
- * Supported patterns:
- * - "go to https://..." / "navigate to https://..." / "open https://..."
- * - "click [the] <target>" / "press <target>"
- * - "type '<value>' in[to] <target>" / "fill <target> with '<value>'"
- * - "select '<option>' from <dropdown>"
- * - "scroll down/up"
- * - "wait [for] <seconds> seconds"
- * - "verify <assertion>" / "assert <assertion>" / "check <assertion>"
- * - "take screenshot"
- */
-function parseNLInstruction(instruction) {
-    const lower = instruction.toLowerCase().trim();
-    // Navigate patterns
-    const navigateMatch = lower.match(/^(?:go to|navigate to|open|visit)\s+(.+)$/i);
-    if (navigateMatch) {
-        return {
-            instruction,
-            action: "navigate",
-            target: navigateMatch[1].trim(),
-        };
-    }
-    // Click patterns
-    const clickMatch = lower.match(/^(?:click|tap|press)\s+(?:on\s+)?(?:the\s+)?(.+)$/i);
-    if (clickMatch) {
-        return {
-            instruction,
-            action: "click",
-            target: clickMatch[1].trim(),
-        };
-    }
-    // Fill patterns: "type 'value' in target" or "fill target with 'value'"
-    const typeMatch = lower.match(/^(?:type|enter)\s+['"](.+?)['"]\s+(?:in|into)\s+(?:the\s+)?(.+)$/i);
-    if (typeMatch) {
-        return {
-            instruction,
-            action: "fill",
-            value: typeMatch[1],
-            target: typeMatch[2].trim(),
-        };
-    }
-    const fillMatch = lower.match(/^fill\s+(?:the\s+)?(.+?)\s+with\s+['"](.+?)['"]$/i);
-    if (fillMatch) {
-        return {
-            instruction,
-            action: "fill",
-            target: fillMatch[1].trim(),
-            value: fillMatch[2],
-        };
-    }
-    // Select patterns
-    const selectMatch = lower.match(/^select\s+['"](.+?)['"]\s+(?:from|in)\s+(?:the\s+)?(.+)$/i);
-    if (selectMatch) {
-        return {
-            instruction,
-            action: "select",
-            value: selectMatch[1],
-            target: selectMatch[2].trim(),
-        };
-    }
-    // Scroll patterns
-    const scrollMatch = lower.match(/^scroll\s+(up|down|left|right)(?:\s+(\d+)\s+(?:times|pixels))?$/i);
-    if (scrollMatch) {
-        return {
-            instruction,
-            action: "scroll",
-            target: scrollMatch[1],
-            value: scrollMatch[2] || "3",
-        };
-    }
-    // Wait patterns
-    const waitMatch = lower.match(/^wait\s+(?:for\s+)?(\d+(?:\.\d+)?)\s*(?:seconds?|s)$/i);
-    if (waitMatch) {
-        return {
-            instruction,
-            action: "wait",
-            value: waitMatch[1],
-        };
-    }
-    // Wait for text pattern
-    const waitForMatch = lower.match(/^wait\s+(?:for|until)\s+['"](.+?)['"]\s+(?:appears?|is visible|shows?)$/i);
-    if (waitForMatch) {
-        return {
-            instruction,
-            action: "wait",
-            target: waitForMatch[1],
-        };
-    }
-    // Assert/verify patterns
-    const assertPatterns = [
-        // Title assertions
-        { pattern: /^(?:verify|assert|check)\s+(?:that\s+)?(?:page\s+)?title\s+(?:contains?|has)\s+['"](.+?)['"]$/i, type: "title", assertType: "contains" },
-        { pattern: /^(?:verify|assert|check)\s+(?:that\s+)?(?:page\s+)?title\s+(?:is|equals?)\s+['"](.+?)['"]$/i, type: "title", assertType: "equals" },
-        // URL assertions
-        { pattern: /^(?:verify|assert|check)\s+(?:that\s+)?url\s+(?:contains?|has)\s+['"](.+?)['"]$/i, type: "url", assertType: "contains" },
-        { pattern: /^(?:verify|assert|check)\s+(?:that\s+)?url\s+(?:is|equals?)\s+['"](.+?)['"]$/i, type: "url", assertType: "equals" },
-        // Content assertions
-        { pattern: /^(?:verify|assert|check)\s+(?:that\s+)?(?:page\s+)?(?:contains?|has|shows?)\s+['"](.+?)['"]$/i, type: "content", assertType: "contains" },
-        { pattern: /^(?:verify|assert|check)\s+(?:that\s+)?['"](.+?)['"]\s+(?:is\s+)?(?:visible|displayed|shown)$/i, type: "content", assertType: "contains" },
-        // Element exists
-        { pattern: /^(?:verify|assert|check)\s+(?:that\s+)?['"](.+?)['"]\s+exists?$/i, type: "element", assertType: "exists" },
-        { pattern: /^(?:verify|assert|check)\s+(?:that\s+)?(?:there\s+is\s+)?(?:a|an)\s+['"](.+?)['"]$/i, type: "element", assertType: "exists" },
-        // Count assertions
-        { pattern: /^(?:verify|assert|check)\s+(?:that\s+)?(?:there\s+are\s+)?(\d+)\s+(.+?)$/i, type: "count", assertType: "count" },
-    ];
-    for (const { pattern, type, assertType } of assertPatterns) {
-        const match = lower.match(pattern);
-        if (match) {
-            return {
-                instruction,
-                action: "assert",
-                target: type === "count" ? match[2] : match[1],
-                value: type === "count" ? match[1] : undefined,
-                assertionType: assertType,
-            };
-        }
-    }
-    // Screenshot pattern
-    if (/^(?:take\s+(?:a\s+)?screenshot|screenshot|capture\s+(?:the\s+)?(?:page|screen))$/i.test(lower)) {
-        return {
-            instruction,
-            action: "screenshot",
-        };
-    }
-    // Unknown - return as-is for AI-powered interpretation later
-    return {
-        instruction,
-        action: "unknown",
-        target: instruction,
-    };
-}
-/**
- * Parse a natural language test suite from text.
- *
- * Format:
- * ```
- * # Test: Login Flow
- * go to https://example.com
- * click the login button
- * type "user@example.com" in email field
- * type "password123" in password field
- * click submit
- * verify url contains "/dashboard"
- *
- * # Test: Search Functionality
- * go to https://example.com
- * type "test query" in search box
- * click search button
- * verify page contains "results"
- * ```
- */
-function parseNLTestSuite(text, suiteName = "Unnamed Suite") {
-    const lines = text.split("\n").map(l => l.trim()).filter(l => l && !l.startsWith("//"));
-    const tests = [];
-    let currentTest = null;
-    for (const line of lines) {
-        // Check for test header: "# Test: Name" or "## Name" or "Test: Name"
-        const testHeaderMatch = line.match(/^(?:#\s*)?(?:test:\s*)?(.+)$/i);
-        if (line.startsWith("#") || line.toLowerCase().startsWith("test:")) {
-            // Save previous test if exists
-            if (currentTest && currentTest.steps.length > 0) {
-                tests.push(currentTest);
-            }
-            const name = testHeaderMatch?.[1]?.replace(/^#+\s*/, "").replace(/^test:\s*/i, "").trim() || "Unnamed Test";
-            currentTest = {
-                name,
-                steps: [],
-            };
-        }
-        else if (line.length > 0) {
-            // Parse as instruction
-            if (!currentTest) {
-                // Create default test if no header found
-                currentTest = {
-                    name: "Default Test",
-                    steps: [],
-                };
-            }
-            const step = parseNLInstruction(line);
-            currentTest.steps.push(step);
-        }
-    }
-    // Save final test
-    if (currentTest && currentTest.steps.length > 0) {
-        tests.push(currentTest);
-    }
-    return { name: suiteName, tests };
-}
-/**
- * Run a natural language test suite.
- */
-async function runNLTestSuite(suite, options = {}) {
-    const { stepTimeout = 30000, continueOnFailure = true, screenshotOnFailure = true, headless = true, } = options;
-    const startTime = Date.now();
-    const testResults = [];
-    console.log(`\n🧪 Running Test Suite: ${suite.name}`);
-    console.log(`   Tests: ${suite.tests.length}`);
-    console.log(`   Continue on failure: ${continueOnFailure}`);
-    console.log("");
-    const browser = new CBrowser({
-        headless,
-    });
-    try {
-        await browser.launch();
-        for (const test of suite.tests) {
-            console.log(`\n📋 Test: ${test.name}`);
-            const testStartTime = Date.now();
-            const stepResults = [];
-            let testPassed = true;
-            let testError;
-            for (const step of test.steps) {
-                console.log(`   → ${step.instruction}`);
-                const stepStartTime = Date.now();
-                let stepPassed = true;
-                let stepError;
-                let screenshot;
-                let actualValue;
-                try {
-                    // Execute the step based on action type
-                    switch (step.action) {
-                        case "navigate": {
-                            await browser.navigate(step.target || "");
-                            break;
-                        }
-                        case "click": {
-                            const result = await browser.smartClick(step.target || "");
-                            if (!result.success) {
-                                throw new Error(`Failed to click: ${step.target}`);
-                            }
-                            break;
-                        }
-                        case "fill": {
-                            await browser.fill(step.target || "", step.value || "");
-                            break;
-                        }
-                        case "select": {
-                            await browser.fill(step.target || "", step.value || "");
-                            break;
-                        }
-                        case "scroll": {
-                            const direction = step.target?.toLowerCase() === "up" ? -500 : 500;
-                            // Use private page access through cast
-                            const page = browser.page;
-                            if (page) {
-                                await page.evaluate((d) => window.scrollBy(0, d), direction);
-                            }
-                            break;
-                        }
-                        case "wait": {
-                            if (step.target) {
-                                // Wait for text to appear - use private page access
-                                const page = browser.page;
-                                if (page) {
-                                    await page.waitForSelector(`text=${step.target}`, { timeout: stepTimeout });
-                                }
-                            }
-                            else {
-                                // Wait for duration
-                                const ms = parseFloat(step.value || "1") * 1000;
-                                await new Promise(r => setTimeout(r, ms));
-                            }
-                            break;
-                        }
-                        case "assert": {
-                            const assertResult = await browser.assert(step.instruction);
-                            stepPassed = assertResult.passed;
-                            actualValue = String(assertResult.actual);
-                            if (!assertResult.passed) {
-                                stepError = assertResult.message;
-                            }
-                            break;
-                        }
-                        case "screenshot": {
-                            screenshot = await browser.screenshot();
-                            break;
-                        }
-                        case "unknown": {
-                            // Try to interpret as a click or fill
-                            console.log(`   ⚠️ Unknown instruction, attempting smart interpretation...`);
-                            const result = await browser.smartClick(step.target || step.instruction);
-                            if (!result.success) {
-                                throw new Error(`Could not interpret: ${step.instruction}`);
-                            }
-                            break;
-                        }
-                    }
-                    console.log(`     ✓ Passed (${Date.now() - stepStartTime}ms)`);
-                }
-                catch (e) {
-                    stepPassed = false;
-                    stepError = e.message;
-                    testPassed = false;
-                    testError = testError || e.message;
-                    console.log(`     ✗ Failed: ${e.message}`);
-                    if (screenshotOnFailure) {
-                        try {
-                            screenshot = await browser.screenshot();
-                        }
-                        catch { }
-                    }
-                }
-                stepResults.push({
-                    instruction: step.instruction,
-                    action: step.action,
-                    passed: stepPassed,
-                    duration: Date.now() - stepStartTime,
-                    error: stepError,
-                    screenshot,
-                    actualValue,
-                });
-                // Stop test if step failed and not continuing on failure
-                if (!stepPassed && !continueOnFailure) {
-                    break;
-                }
-            }
-            testResults.push({
-                name: test.name,
-                passed: testPassed,
-                duration: Date.now() - testStartTime,
-                stepResults,
-                error: testError,
-            });
-            console.log(`   ${testPassed ? "✅" : "❌"} ${test.name}: ${testPassed ? "PASSED" : "FAILED"}`);
-        }
-    }
-    finally {
-        await browser.close();
-    }
-    const passed = testResults.filter(t => t.passed).length;
-    const failed = testResults.filter(t => !t.passed).length;
-    const result = {
-        name: suite.name,
-        timestamp: new Date().toISOString(),
-        duration: Date.now() - startTime,
-        testResults,
-        summary: {
-            total: suite.tests.length,
-            passed,
-            failed,
-            skipped: 0,
-            passRate: suite.tests.length > 0 ? (passed / suite.tests.length) * 100 : 0,
-        },
-    };
-    return result;
-}
-/**
- * Format a test suite result as a report.
- */
-function formatNLTestReport(result) {
-    const lines = [];
-    lines.push("");
-    lines.push("╔══════════════════════════════════════════════════════════════════════════════╗");
-    lines.push("║                    NATURAL LANGUAGE TEST REPORT                              ║");
-    lines.push("╚══════════════════════════════════════════════════════════════════════════════╝");
-    lines.push("");
-    lines.push(`📋 Suite: ${result.name}`);
-    lines.push(`⏱️  Duration: ${(result.duration / 1000).toFixed(1)}s`);
-    lines.push(`📅 Timestamp: ${result.timestamp}`);
-    lines.push("");
-    // Summary stats
-    const passEmoji = result.summary.passRate === 100 ? "🎉" : result.summary.passRate >= 80 ? "✅" : "⚠️";
-    lines.push(`${passEmoji} Pass Rate: ${result.summary.passed}/${result.summary.total} (${result.summary.passRate.toFixed(0)}%)`);
-    lines.push("");
-    // Results table
-    lines.push("┌───────────────────────────────────────┬──────────┬──────────┬────────────────────┐");
-    lines.push("│ Test                                  │ Status   │ Duration │ Error              │");
-    lines.push("├───────────────────────────────────────┼──────────┼──────────┼────────────────────┤");
-    for (const test of result.testResults) {
-        const name = test.name.padEnd(37).slice(0, 37);
-        const status = test.passed ? "✓ PASS".padEnd(8) : "✗ FAIL".padEnd(8);
-        const duration = `${(test.duration / 1000).toFixed(1)}s`.padEnd(8);
-        const error = (test.error || "-").slice(0, 18).padEnd(18);
-        lines.push(`│ ${name} │ ${status} │ ${duration} │ ${error} │`);
-    }
-    lines.push("└───────────────────────────────────────┴──────────┴──────────┴────────────────────┘");
-    lines.push("");
-    // Failed test details
-    const failedTests = result.testResults.filter(t => !t.passed);
-    if (failedTests.length > 0) {
-        lines.push("❌ FAILED TESTS");
-        lines.push("─".repeat(60));
-        for (const test of failedTests) {
-            lines.push(`\n  📋 ${test.name}`);
-            const failedSteps = test.stepResults.filter(s => !s.passed);
-            for (const step of failedSteps) {
-                lines.push(`     ✗ ${step.instruction}`);
-                if (step.error) {
-                    lines.push(`       Error: ${step.error}`);
-                }
-                if (step.screenshot) {
-                    lines.push(`       Screenshot: ${step.screenshot}`);
-                }
-            }
-        }
-        lines.push("");
-    }
-    return lines.join("\n");
-}
-/**
- * Run a natural language test suite from a file.
- */
-async function runNLTestFile(filepath, options = {}) {
-    if (!(0, fs_1.existsSync)(filepath)) {
-        throw new Error(`Test file not found: ${filepath}`);
-    }
-    const content = (0, fs_1.readFileSync)(filepath, "utf-8");
-    const suiteName = filepath.split("/").pop()?.replace(/\.[^.]+$/, "") || "Test Suite";
-    const suite = parseNLTestSuite(content, suiteName);
-    return runNLTestSuite(suite, options);
-}
-// =========================================================================
-// AI Test Repair (v6.2.0)
-// =========================================================================
-/**
- * Classify the type of failure from an error message.
- */
-function classifyFailure(error, step) {
-    const lowerError = error.toLowerCase();
-    if (lowerError.includes("not found") || lowerError.includes("no element") || lowerError.includes("failed to click")) {
-        return "selector_not_found";
-    }
-    if (lowerError.includes("assertion") || lowerError.includes("verify") || lowerError.includes("expected")) {
-        return "assertion_failed";
-    }
-    if (lowerError.includes("timeout") || lowerError.includes("timed out")) {
-        return "timeout";
-    }
-    if (lowerError.includes("navigation") || lowerError.includes("navigate") || lowerError.includes("url")) {
-        return "navigation_failed";
-    }
-    if (lowerError.includes("not interactable") || lowerError.includes("disabled") || lowerError.includes("hidden")) {
-        return "element_not_interactable";
-    }
-    return "unknown";
-}
-/**
- * Find alternative selectors for a target on the current page.
- */
-async function findAlternatives(browser, originalTarget) {
-    const page = browser.page;
-    if (!page)
-        return [];
-    try {
-        const alternatives = await page.evaluate((target) => {
-            const results = [];
-            const lowerTarget = target.toLowerCase();
-            // Find buttons with similar text
-            document.querySelectorAll("button, [role='button'], input[type='submit'], input[type='button']").forEach((el) => {
-                const text = el.textContent?.trim() || el.value || "";
-                if (text && (text.toLowerCase().includes(lowerTarget) || lowerTarget.includes(text.toLowerCase()))) {
-                    results.push(`button: "${text}"`);
-                }
-            });
-            // Find links with similar text
-            document.querySelectorAll("a").forEach((el) => {
-                const text = el.textContent?.trim() || "";
-                if (text && (text.toLowerCase().includes(lowerTarget) || lowerTarget.includes(text.toLowerCase()))) {
-                    results.push(`link: "${text}"`);
-                }
-            });
-            // Find inputs with similar labels/placeholders
-            document.querySelectorAll("input, textarea, select").forEach((el) => {
-                const input = el;
-                const placeholder = input.placeholder || "";
-                const label = document.querySelector(`label[for="${input.id}"]`)?.textContent?.trim() || "";
-                const name = input.name || "";
-                if (placeholder.toLowerCase().includes(lowerTarget) || lowerTarget.includes(placeholder.toLowerCase())) {
-                    results.push(`input with placeholder "${placeholder}"`);
-                }
-                if (label.toLowerCase().includes(lowerTarget) || lowerTarget.includes(label.toLowerCase())) {
-                    results.push(`input labeled "${label}"`);
-                }
-                if (name.toLowerCase().includes(lowerTarget)) {
-                    results.push(`input named "${name}"`);
-                }
-            });
-            // Find elements by aria-label
-            document.querySelectorAll("[aria-label]").forEach((el) => {
-                const label = el.getAttribute("aria-label") || "";
-                if (label.toLowerCase().includes(lowerTarget) || lowerTarget.includes(label.toLowerCase())) {
-                    results.push(`aria:${el.tagName.toLowerCase()}/"${label}"`);
-                }
-            });
-            return [...new Set(results)].slice(0, 10);
-        }, originalTarget);
-        return alternatives;
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Get page context for failure analysis.
- */
-async function getPageContext(browser) {
-    const page = browser.page;
-    if (!page)
-        return { url: "", title: "", visibleText: [] };
-    try {
-        const context = await page.evaluate(() => {
-            const visibleText = [];
-            // Get visible button/link text
-            document.querySelectorAll("button, a, [role='button']").forEach((el) => {
-                const text = el.textContent?.trim();
-                if (text && text.length < 50) {
-                    visibleText.push(text);
-                }
-            });
-            return {
-                url: window.location.href,
-                title: document.title,
-                visibleText: [...new Set(visibleText)].slice(0, 20),
-            };
-        });
-        return context;
-    }
-    catch {
-        return { url: "", title: "", visibleText: [] };
-    }
-}
-/**
- * Generate repair suggestions for a failed step.
- */
-async function generateRepairSuggestions(browser, step, error, failureType, alternatives, pageContext) {
-    const suggestions = [];
-    switch (failureType) {
-        case "selector_not_found": {
-            // Suggest alternative selectors
-            for (const alt of alternatives.slice(0, 3)) {
-                const newInstruction = step.instruction.replace(step.target || "", alt.replace(/^(button|link|input|aria):\s*/, "").replace(/"/g, "'"));
-                suggestions.push({
-                    type: "selector_update",
-                    confidence: 0.7,
-                    description: `Update selector to "${alt}"`,
-                    originalInstruction: step.instruction,
-                    suggestedInstruction: `click ${alt.replace(/^(button|link|input|aria):\s*/, "")}`,
-                    reasoning: `Found similar element on page: ${alt}`,
-                });
-            }
-            // Suggest adding a wait
-            if (suggestions.length === 0) {
-                suggestions.push({
-                    type: "add_wait",
-                    confidence: 0.5,
-                    description: "Add wait before this step",
-                    originalInstruction: step.instruction,
-                    suggestedInstruction: `wait 2 seconds\n${step.instruction}`,
-                    reasoning: "Element might not be loaded yet - adding wait may help",
-                });
-            }
-            break;
-        }
-        case "assertion_failed": {
-            // Suggest updating the assertion based on page content
-            if (step.action === "assert" && pageContext.visibleText.length > 0) {
-                const possibleText = pageContext.visibleText.find((t) => t.length > 3 && t.length < 30);
-                if (possibleText) {
-                    suggestions.push({
-                        type: "assertion_update",
-                        confidence: 0.6,
-                        description: `Update assertion to check for visible text`,
-                        originalInstruction: step.instruction,
-                        suggestedInstruction: `verify page contains "${possibleText}"`,
-                        reasoning: `Page contains "${possibleText}" which might be the intended check`,
-                    });
-                }
-            }
-            // Suggest checking URL instead
-            if (pageContext.url) {
-                const urlPath = new URL(pageContext.url).pathname;
-                suggestions.push({
-                    type: "assertion_update",
-                    confidence: 0.5,
-                    description: "Assert URL instead of content",
-                    originalInstruction: step.instruction,
-                    suggestedInstruction: `verify url contains "${urlPath}"`,
-                    reasoning: `Current URL is ${pageContext.url}`,
-                });
-            }
-            break;
-        }
-        case "timeout": {
-            suggestions.push({
-                type: "add_wait",
-                confidence: 0.7,
-                description: "Increase wait time",
-                originalInstruction: step.instruction,
-                suggestedInstruction: `wait 5 seconds\n${step.instruction}`,
-                reasoning: "Operation timed out - page may need more time to load",
-            });
-            break;
-        }
-        case "element_not_interactable": {
-            suggestions.push({
-                type: "add_wait",
-                confidence: 0.6,
-                description: "Wait for element to become interactive",
-                originalInstruction: step.instruction,
-                suggestedInstruction: `wait 2 seconds\n${step.instruction}`,
-                reasoning: "Element exists but is not interactable - may need to wait",
-            });
-            // Suggest scrolling
-            suggestions.push({
-                type: "change_action",
-                confidence: 0.5,
-                description: "Scroll element into view first",
-                originalInstruction: step.instruction,
-                suggestedInstruction: `scroll down\n${step.instruction}`,
-                reasoning: "Element might be outside viewport",
-            });
-            break;
-        }
-        default: {
-            // Generic suggestion to skip
-            suggestions.push({
-                type: "skip_step",
-                confidence: 0.3,
-                description: "Skip this step",
-                originalInstruction: step.instruction,
-                suggestedInstruction: `// SKIPPED: ${step.instruction}`,
-                reasoning: "Unable to determine a fix - consider removing this step",
-            });
-        }
-    }
-    // Sort by confidence
-    return suggestions.sort((a, b) => b.confidence - a.confidence);
-}
-/**
- * Analyze a failed test step and suggest repairs.
- */
-async function analyzeFailure(browser, step, error) {
-    const failureType = classifyFailure(error, step);
-    const alternatives = step.target ? await findAlternatives(browser, step.target) : [];
-    const pageContext = await getPageContext(browser);
-    const suggestions = await generateRepairSuggestions(browser, step, error, failureType, alternatives, pageContext);
-    return {
-        step,
-        error,
-        failureType,
-        targetSelector: step.target,
-        alternativeSelectors: alternatives,
-        pageContext,
-        suggestions,
-    };
-}
-/**
- * Run a test, analyze failures, and suggest/apply repairs.
- */
-async function repairTest(test, options = {}) {
-    const { headless = true, autoApply = false, verifyRepairs = true, maxRetries = 3, } = options;
-    const browser = new CBrowser({ headless });
-    const failureAnalyses = [];
-    const repairedSteps = [];
-    let failedSteps = 0;
-    console.log(`\n🔧 Analyzing test: ${test.name}`);
-    console.log(`   Steps: ${test.steps.length}`);
-    console.log(`   Auto-apply: ${autoApply}`);
-    console.log("");
-    try {
-        await browser.launch();
-        for (const step of test.steps) {
-            console.log(`   → ${step.instruction}`);
-            let stepPassed = false;
-            let lastError = "";
-            let attempts = 0;
-            while (!stepPassed && attempts < maxRetries) {
-                attempts++;
-                try {
-                    // Execute the step
-                    switch (step.action) {
-                        case "navigate":
-                            await browser.navigate(step.target || "");
-                            stepPassed = true;
-                            break;
-                        case "click":
-                            const clickResult = await browser.smartClick(step.target || "");
-                            stepPassed = clickResult.success;
-                            if (!stepPassed)
-                                lastError = `Failed to click: ${step.target}`;
-                            break;
-                        case "fill":
-                            await browser.fill(step.target || "", step.value || "");
-                            stepPassed = true;
-                            break;
-                        case "assert":
-                            const assertResult = await browser.assert(step.instruction);
-                            stepPassed = assertResult.passed;
-                            if (!stepPassed)
-                                lastError = assertResult.message;
-                            break;
-                        case "wait":
-                            if (step.target) {
-                                const page = browser.page;
-                                if (page) {
-                                    await page.waitForSelector(`text=${step.target}`, { timeout: 10000 });
-                                }
-                            }
-                            else {
-                                const ms = parseFloat(step.value || "1") * 1000;
-                                await new Promise((r) => setTimeout(r, ms));
-                            }
-                            stepPassed = true;
-                            break;
-                        case "scroll":
-                            const direction = step.target?.toLowerCase() === "up" ? -500 : 500;
-                            const page = browser.page;
-                            if (page) {
-                                await page.evaluate((d) => window.scrollBy(0, d), direction);
-                            }
-                            stepPassed = true;
-                            break;
-                        case "screenshot":
-                            await browser.screenshot();
-                            stepPassed = true;
-                            break;
-                        default:
-                            // Try as click
-                            const unknownResult = await browser.smartClick(step.target || step.instruction);
-                            stepPassed = unknownResult.success;
-                            if (!stepPassed)
-                                lastError = `Could not interpret: ${step.instruction}`;
-                    }
-                }
-                catch (e) {
-                    lastError = e.message;
-                    stepPassed = false;
-                }
-                if (!stepPassed && attempts < maxRetries) {
-                    console.log(`     ⚠️ Attempt ${attempts} failed, retrying...`);
-                    await new Promise((r) => setTimeout(r, 500));
-                }
-            }
-            if (stepPassed) {
-                console.log(`     ✓ Passed`);
-                repairedSteps.push(step);
-            }
-            else {
-                console.log(`     ✗ Failed: ${lastError}`);
-                failedSteps++;
-                // Analyze the failure
-                const analysis = await analyzeFailure(browser, step, lastError);
-                failureAnalyses.push(analysis);
-                if (autoApply && analysis.suggestions.length > 0) {
-                    const bestSuggestion = analysis.suggestions[0];
-                    console.log(`     🔧 Auto-applying: ${bestSuggestion.description}`);
-                    // Parse the suggested instruction into a step
-                    const repairedStep = parseNLInstruction(bestSuggestion.suggestedInstruction.split("\n").pop() || "");
-                    repairedSteps.push(repairedStep);
-                }
-                else {
-                    // Keep original step
-                    repairedSteps.push(step);
-                    if (analysis.suggestions.length > 0) {
-                        console.log(`     💡 Suggestions:`);
-                        for (const suggestion of analysis.suggestions.slice(0, 2)) {
-                            console.log(`        - ${suggestion.description} (${Math.round(suggestion.confidence * 100)}%)`);
-                            console.log(`          → ${suggestion.suggestedInstruction}`);
-                        }
-                    }
-                }
-            }
-        }
-        // Create repaired test
-        const repairedTest = {
-            name: test.name,
-            description: test.description,
-            steps: repairedSteps,
-        };
-        // Optionally verify the repaired test
-        let repairedTestPasses;
-        if (verifyRepairs && autoApply && failedSteps > 0) {
-            console.log(`\n   🔄 Verifying repaired test...`);
-            await browser.close();
-            const verifyBrowser = new CBrowser({ headless });
-            try {
-                await verifyBrowser.launch();
-                let allPassed = true;
-                for (const step of repairedSteps) {
-                    try {
-                        switch (step.action) {
-                            case "navigate":
-                                await verifyBrowser.navigate(step.target || "");
-                                break;
-                            case "click":
-                                const result = await verifyBrowser.smartClick(step.target || "");
-                                if (!result.success)
-                                    allPassed = false;
-                                break;
-                            case "fill":
-                                await verifyBrowser.fill(step.target || "", step.value || "");
-                                break;
-                            case "assert":
-                                const assertResult = await verifyBrowser.assert(step.instruction);
-                                if (!assertResult.passed)
-                                    allPassed = false;
-                                break;
-                            case "wait":
-                                if (!step.target) {
-                                    const ms = parseFloat(step.value || "1") * 1000;
-                                    await new Promise((r) => setTimeout(r, ms));
-                                }
-                                break;
-                        }
-                    }
-                    catch {
-                        allPassed = false;
-                    }
-                }
-                repairedTestPasses = allPassed;
-                console.log(`   ${allPassed ? "✅" : "❌"} Repaired test ${allPassed ? "PASSES" : "still FAILS"}`);
-            }
-            finally {
-                await verifyBrowser.close();
-            }
-        }
-        return {
-            originalTest: test,
-            repairedTest: failedSteps > 0 ? repairedTest : undefined,
-            failedSteps,
-            repairedSteps: autoApply ? failedSteps : 0,
-            failureAnalyses,
-            repairedTestPasses,
-        };
-    }
-    finally {
-        await browser.close();
-    }
-}
-/**
- * Run test repair on a full suite.
- */
-async function repairTestSuite(suite, options = {}) {
-    const startTime = Date.now();
-    const testResults = [];
-    console.log(`\n🔧 Repairing Test Suite: ${suite.name}`);
-    console.log(`   Tests: ${suite.tests.length}`);
-    console.log("");
-    for (const test of suite.tests) {
-        const result = await repairTest(test, options);
-        testResults.push(result);
-    }
-    const testsWithFailures = testResults.filter((r) => r.failedSteps > 0).length;
-    const testsRepaired = testResults.filter((r) => r.repairedSteps > 0).length;
-    const totalFailedSteps = testResults.reduce((sum, r) => sum + r.failedSteps, 0);
-    const totalRepairedSteps = testResults.reduce((sum, r) => sum + r.repairedSteps, 0);
-    return {
-        suiteName: suite.name,
-        timestamp: new Date().toISOString(),
-        duration: Date.now() - startTime,
-        testResults,
-        summary: {
-            totalTests: suite.tests.length,
-            testsWithFailures,
-            testsRepaired,
-            totalFailedSteps,
-            totalRepairedSteps,
-            repairSuccessRate: totalFailedSteps > 0 ? (totalRepairedSteps / totalFailedSteps) * 100 : 100,
-        },
-    };
-}
-/**
- * Format a repair result as a report.
- */
-function formatRepairReport(result) {
-    const lines = [];
-    lines.push("");
-    lines.push("╔══════════════════════════════════════════════════════════════════════════════╗");
-    lines.push("║                       AI TEST REPAIR REPORT                                  ║");
-    lines.push("╚══════════════════════════════════════════════════════════════════════════════╝");
-    lines.push("");
-    lines.push(`📋 Suite: ${result.suiteName}`);
-    lines.push(`⏱️  Duration: ${(result.duration / 1000).toFixed(1)}s`);
-    lines.push(`📅 Timestamp: ${result.timestamp}`);
-    lines.push("");
-    // Summary
-    lines.push("📊 SUMMARY");
-    lines.push("─".repeat(60));
-    lines.push(`  Total Tests: ${result.summary.totalTests}`);
-    lines.push(`  Tests with Failures: ${result.summary.testsWithFailures}`);
-    lines.push(`  Tests Repaired: ${result.summary.testsRepaired}`);
-    lines.push(`  Total Failed Steps: ${result.summary.totalFailedSteps}`);
-    lines.push(`  Total Repaired Steps: ${result.summary.totalRepairedSteps}`);
-    lines.push(`  Repair Success Rate: ${result.summary.repairSuccessRate.toFixed(0)}%`);
-    lines.push("");
-    // Per-test details
-    for (const testResult of result.testResults) {
-        if (testResult.failedSteps === 0)
-            continue;
-        lines.push(`\n🔧 ${testResult.originalTest.name}`);
-        lines.push(`   Failed Steps: ${testResult.failedSteps}`);
-        lines.push(`   Repaired: ${testResult.repairedSteps}`);
-        for (const analysis of testResult.failureAnalyses) {
-            lines.push(`\n   ❌ ${analysis.step.instruction}`);
-            lines.push(`      Error: ${analysis.error}`);
-            lines.push(`      Type: ${analysis.failureType}`);
-            if (analysis.suggestions.length > 0) {
-                lines.push(`      💡 Suggestions:`);
-                for (const s of analysis.suggestions.slice(0, 2)) {
-                    lines.push(`         - ${s.description} (${Math.round(s.confidence * 100)}%)`);
-                    lines.push(`           → ${s.suggestedInstruction}`);
-                }
-            }
-        }
-        if (testResult.repairedTestPasses !== undefined) {
-            lines.push(`\n   ${testResult.repairedTestPasses ? "✅" : "❌"} Repaired test ${testResult.repairedTestPasses ? "PASSES" : "still FAILS"}`);
-        }
-    }
-    lines.push("");
-    return lines.join("\n");
-}
-/**
- * Export repaired test to file.
- */
-function exportRepairedTest(result) {
-    if (!result.repairedTest) {
-        return `# Test: ${result.originalTest.name}\n# No repairs needed\n${result.originalTest.steps.map((s) => s.instruction).join("\n")}`;
-    }
-    const lines = [];
-    lines.push(`# Test: ${result.repairedTest.name} (Repaired)`);
-    lines.push(`# Original failures: ${result.failedSteps}`);
-    lines.push(`# Repairs applied: ${result.repairedSteps}`);
-    lines.push("");
-    for (const step of result.repairedTest.steps) {
-        lines.push(step.instruction);
-    }
-    return lines.join("\n");
-}
-/**
- * Calculate flakiness score.
- * 0 = completely stable (all same result)
- * 100 = maximally flaky (50% pass, 50% fail)
- */
-function calculateFlakinessScore(passCount, failCount) {
-    const total = passCount + failCount;
-    if (total === 0)
-        return 0;
-    const passRate = passCount / total;
-    // Flakiness is maximized at 50% pass rate
-    // Score = 1 - |passRate - 0.5| * 2, scaled to 0-100
-    const flakiness = (1 - Math.abs(passRate - 0.5) * 2) * 100;
-    return Math.round(flakiness);
-}
-/**
- * Classify a test based on its results.
- */
-function classifyTest(passCount, failCount) {
-    const total = passCount + failCount;
-    if (total === 0)
-        return "stable_pass";
-    const passRate = passCount / total;
-    if (passRate === 1)
-        return "stable_pass";
-    if (passRate === 0)
-        return "stable_fail";
-    if (passRate >= 0.8)
-        return "mostly_pass";
-    if (passRate <= 0.2)
-        return "mostly_fail";
-    return "flaky";
-}
-/**
- * Run a single test once and return the result.
- */
-async function runTestOnce(test, runNumber, headless) {
-    const browser = new CBrowser({ headless });
-    const stepResults = [];
-    let testPassed = true;
-    let testError;
-    const startTime = Date.now();
-    try {
-        await browser.launch();
-        for (const step of test.steps) {
-            let stepPassed = true;
-            let stepError;
-            try {
-                switch (step.action) {
-                    case "navigate":
-                        await browser.navigate(step.target || "");
-                        break;
-                    case "click":
-                        const clickResult = await browser.smartClick(step.target || "");
-                        if (!clickResult.success) {
-                            stepPassed = false;
-                            stepError = `Failed to click: ${step.target}`;
-                        }
-                        break;
-                    case "fill":
-                        await browser.fill(step.target || "", step.value || "");
-                        break;
-                    case "assert":
-                        const assertResult = await browser.assert(step.instruction);
-                        stepPassed = assertResult.passed;
-                        if (!assertResult.passed) {
-                            stepError = assertResult.message;
-                        }
-                        break;
-                    case "wait":
-                        if (!step.target) {
-                            const ms = parseFloat(step.value || "1") * 1000;
-                            await new Promise((r) => setTimeout(r, ms));
-                        }
-                        else {
-                            const page = browser.page;
-                            if (page) {
-                                await page.waitForSelector(`text=${step.target}`, { timeout: 10000 });
-                            }
-                        }
-                        break;
-                    case "scroll":
-                        const direction = step.target?.toLowerCase() === "up" ? -500 : 500;
-                        const page = browser.page;
-                        if (page) {
-                            await page.evaluate((d) => window.scrollBy(0, d), direction);
-                        }
-                        break;
-                    case "screenshot":
-                        await browser.screenshot();
-                        break;
-                    default:
-                        const unknownResult = await browser.smartClick(step.target || step.instruction);
-                        if (!unknownResult.success) {
-                            stepPassed = false;
-                            stepError = `Could not interpret: ${step.instruction}`;
-                        }
-                }
-            }
-            catch (e) {
-                stepPassed = false;
-                stepError = e.message;
-            }
-            stepResults.push({
-                instruction: step.instruction,
-                passed: stepPassed,
-                error: stepError,
-            });
-            if (!stepPassed) {
-                testPassed = false;
-                testError = testError || stepError;
-            }
-        }
-    }
-    catch (e) {
-        testPassed = false;
-        testError = e.message;
-    }
-    finally {
-        await browser.close();
-    }
-    return {
-        runNumber,
-        passed: testPassed,
-        duration: Date.now() - startTime,
-        error: testError,
-        stepResults,
-    };
-}
-/**
- * Analyze a test for flakiness by running it multiple times.
- */
-async function analyzeTestFlakiness(test, options) {
-    const { runs = 5, headless = true, flakinessThreshold = 20, delayBetweenRuns = 500, } = options;
-    const testRuns = [];
-    console.log(`\n   🔄 Running ${runs} times...`);
-    for (let i = 1; i <= runs; i++) {
-        const result = await runTestOnce(test, i, headless);
-        testRuns.push(result);
-        const icon = result.passed ? "✓" : "✗";
-        console.log(`      Run ${i}: ${icon} (${result.duration}ms)`);
-        if (i < runs && delayBetweenRuns > 0) {
-            await new Promise((r) => setTimeout(r, delayBetweenRuns));
-        }
-    }
-    // Calculate overall stats
-    const passCount = testRuns.filter((r) => r.passed).length;
-    const failCount = testRuns.filter((r) => !r.passed).length;
-    const flakinessScore = calculateFlakinessScore(passCount, failCount);
-    const classification = classifyTest(passCount, failCount);
-    const isFlaky = flakinessScore >= flakinessThreshold;
-    // Calculate duration stats
-    const durations = testRuns.map((r) => r.duration);
-    const avgDuration = durations.reduce((a, b) => a + b, 0) / durations.length;
-    const variance = Math.sqrt(durations.reduce((sum, d) => sum + Math.pow(d - avgDuration, 2), 0) / durations.length);
-    // Analyze per-step flakiness
-    const stepAnalysis = [];
-    for (let stepIdx = 0; stepIdx < test.steps.length; stepIdx++) {
-        const step = test.steps[stepIdx];
-        const stepResults = testRuns.map((r) => r.stepResults[stepIdx]).filter(Boolean);
-        const stepPassCount = stepResults.filter((s) => s?.passed).length;
-        const stepFailCount = stepResults.filter((s) => !s?.passed).length;
-        const stepFlakinessScore = calculateFlakinessScore(stepPassCount, stepFailCount);
-        const stepErrors = [...new Set(stepResults.filter((s) => s?.error).map((s) => s.error))];
-        stepAnalysis.push({
-            instruction: step.instruction,
-            passCount: stepPassCount,
-            failCount: stepFailCount,
-            flakinessScore: stepFlakinessScore,
-            isFlaky: stepFlakinessScore >= flakinessThreshold,
-            errors: stepErrors,
-        });
-    }
-    return {
-        testName: test.name,
-        totalRuns: runs,
-        passCount,
-        failCount,
-        flakinessScore,
-        isFlaky,
-        classification,
-        runs: testRuns,
-        stepAnalysis,
-        avgDuration: Math.round(avgDuration),
-        durationVariance: Math.round(variance),
-    };
-}
-/**
- * Run flaky test detection on a test suite.
- */
-async function detectFlakyTests(suite, options = {}) {
-    const { runs = 5, flakinessThreshold = 20 } = options;
-    const startTime = Date.now();
-    const testAnalyses = [];
-    console.log(`\n🔍 Flaky Test Detection: ${suite.name}`);
-    console.log(`   Tests: ${suite.tests.length}`);
-    console.log(`   Runs per test: ${runs}`);
-    console.log(`   Flakiness threshold: ${flakinessThreshold}%`);
-    for (const test of suite.tests) {
-        console.log(`\n📋 Test: ${test.name}`);
-        const analysis = await analyzeTestFlakiness(test, options);
-        testAnalyses.push(analysis);
-        const statusIcon = analysis.classification === "stable_pass" ? "✅" :
-            analysis.classification === "stable_fail" ? "❌" :
-                analysis.classification === "flaky" ? "⚠️" :
-                    analysis.classification === "mostly_pass" ? "🟡" : "🟠";
-        console.log(`   ${statusIcon} ${analysis.classification.toUpperCase()} (${analysis.passCount}/${analysis.totalRuns} passed, flakiness: ${analysis.flakinessScore}%)`);
-    }
-    // Calculate summary
-    const stablePassTests = testAnalyses.filter((t) => t.classification === "stable_pass").length;
-    const stableFailTests = testAnalyses.filter((t) => t.classification === "stable_fail").length;
-    const flakyTests = testAnalyses.filter((t) => t.isFlaky).length;
-    const mostFlakyTest = testAnalyses.reduce((max, t) => t.flakinessScore > (max?.flakinessScore || 0) ? t : max, testAnalyses[0])?.testName;
-    const allSteps = testAnalyses.flatMap((t) => t.stepAnalysis);
-    const mostFlakyStep = allSteps.reduce((max, s) => s.flakinessScore > (max?.flakinessScore || 0) ? s : max, allSteps[0])?.instruction;
-    const overallFlakinessScore = testAnalyses.length > 0
-        ? Math.round(testAnalyses.reduce((sum, t) => sum + t.flakinessScore, 0) / testAnalyses.length)
-        : 0;
-    return {
-        suiteName: suite.name,
-        timestamp: new Date().toISOString(),
-        duration: Date.now() - startTime,
-        runsPerTest: runs,
-        testAnalyses,
-        summary: {
-            totalTests: suite.tests.length,
-            stablePassTests,
-            stableFailTests,
-            flakyTests,
-            mostFlakyTest: flakyTests > 0 ? mostFlakyTest : undefined,
-            mostFlakyStep: allSteps.some((s) => s.isFlaky) ? mostFlakyStep : undefined,
-            overallFlakinessScore,
-        },
-    };
-}
-/**
- * Format a flaky test report.
- */
-function formatFlakyTestReport(result) {
-    const lines = [];
-    lines.push("");
-    lines.push("╔══════════════════════════════════════════════════════════════════════════════╗");
-    lines.push("║                      FLAKY TEST DETECTION REPORT                             ║");
-    lines.push("╚══════════════════════════════════════════════════════════════════════════════╝");
-    lines.push("");
-    lines.push(`📋 Suite: ${result.suiteName}`);
-    lines.push(`⏱️  Duration: ${(result.duration / 1000).toFixed(1)}s`);
-    lines.push(`🔄 Runs per test: ${result.runsPerTest}`);
-    lines.push(`📅 Timestamp: ${result.timestamp}`);
-    lines.push("");
-    // Summary
-    const flakyEmoji = result.summary.flakyTests === 0 ? "✅" : "⚠️";
-    lines.push(`${flakyEmoji} Overall Flakiness: ${result.summary.overallFlakinessScore}%`);
-    lines.push("");
-    lines.push("📊 SUMMARY");
-    lines.push("─".repeat(60));
-    lines.push(`  Total Tests: ${result.summary.totalTests}`);
-    lines.push(`  Stable (Pass): ${result.summary.stablePassTests}`);
-    lines.push(`  Stable (Fail): ${result.summary.stableFailTests}`);
-    lines.push(`  Flaky: ${result.summary.flakyTests}`);
-    if (result.summary.mostFlakyTest) {
-        lines.push(`  Most Flaky Test: ${result.summary.mostFlakyTest}`);
-    }
-    if (result.summary.mostFlakyStep) {
-        lines.push(`  Most Flaky Step: ${result.summary.mostFlakyStep.slice(0, 50)}...`);
-    }
-    lines.push("");
-    // Results table
-    lines.push("┌────────────────────────────────┬────────────┬──────────┬───────────┬────────────┐");
-    lines.push("│ Test                           │ Status     │ Pass/Fail│ Flakiness │ Avg Time   │");
-    lines.push("├────────────────────────────────┼────────────┼──────────┼───────────┼────────────┤");
-    for (const test of result.testAnalyses) {
-        const name = test.testName.padEnd(30).slice(0, 30);
-        const status = test.classification.replace("_", " ").toUpperCase().padEnd(10).slice(0, 10);
-        const passFailStr = `${test.passCount}/${test.totalRuns}`.padEnd(8);
-        const flakiness = `${test.flakinessScore}%`.padEnd(9);
-        const avgTime = `${(test.avgDuration / 1000).toFixed(1)}s`.padEnd(10);
-        lines.push(`│ ${name} │ ${status} │ ${passFailStr} │ ${flakiness} │ ${avgTime} │`);
-    }
-    lines.push("└────────────────────────────────┴────────────┴──────────┴───────────┴────────────┘");
-    lines.push("");
-    // Flaky tests details
-    const flakyTests = result.testAnalyses.filter((t) => t.isFlaky);
-    if (flakyTests.length > 0) {
-        lines.push("⚠️  FLAKY TESTS DETAILS");
-        lines.push("─".repeat(60));
-        for (const test of flakyTests) {
-            lines.push(`\n  📋 ${test.testName}`);
-            lines.push(`     Flakiness: ${test.flakinessScore}%`);
-            lines.push(`     Pass Rate: ${test.passCount}/${test.totalRuns} (${Math.round((test.passCount / test.totalRuns) * 100)}%)`);
-            lines.push(`     Duration: ${test.avgDuration}ms ± ${test.durationVariance}ms`);
-            const flakySteps = test.stepAnalysis.filter((s) => s.isFlaky);
-            if (flakySteps.length > 0) {
-                lines.push(`     Flaky Steps:`);
-                for (const step of flakySteps) {
-                    lines.push(`       - "${step.instruction.slice(0, 40)}..." (${step.flakinessScore}% flaky)`);
-                    if (step.errors.length > 0) {
-                        lines.push(`         Errors: ${step.errors[0].slice(0, 50)}`);
-                    }
-                }
-            }
-        }
-        lines.push("");
-    }
-    // Recommendations
-    lines.push("💡 RECOMMENDATIONS");
-    lines.push("─".repeat(60));
-    if (result.summary.flakyTests === 0) {
-        lines.push("  ✅ All tests are stable - no action needed");
-    }
-    else {
-        lines.push(`  ⚠️ ${result.summary.flakyTests} flaky test(s) detected`);
-        lines.push("  Consider:");
-        lines.push("    - Adding explicit waits for timing-sensitive operations");
-        lines.push("    - Using more specific selectors");
-        lines.push("    - Checking for race conditions in the application");
-        lines.push("    - Isolating tests to avoid shared state issues");
-    }
-    lines.push("");
-    return lines.join("\n");
-}
-// ============================================================================
-// Performance Regression Detection (v6.4.0)
-// ============================================================================
-const DEFAULT_REGRESSION_THRESHOLDS = {
-    lcp: 20, // 20% increase
-    fid: 50, // 50% increase
-    cls: 0.1, // Absolute increase of 0.1
-    fcp: 20, // 20% increase
-    ttfb: 30, // 30% increase
-    tti: 25, // 25% increase
-    tbt: 50, // 50% increase
-    transferSize: 25, // 25% increase
-};
-/**
- * Capture a performance baseline for a URL
- */
-async function capturePerformanceBaseline(url, options = {}) {
-    const { runs = 3, name, headless = true, device, throttle } = options;
-    const paths = (0, config_js_1.getPaths)();
-    (0, config_js_1.ensureDirectories)();
-    const browser = new CBrowser({ headless });
-    const allMetrics = [];
-    try {
-        for (let i = 0; i < runs; i++) {
-            await browser.navigate(url);
-            // Wait for page to stabilize
-            await new Promise((r) => setTimeout(r, 2000));
-            const metrics = await browser.getPerformanceMetrics();
-            allMetrics.push(metrics);
-            // Brief pause between runs
-            if (i < runs - 1) {
-                await new Promise((r) => setTimeout(r, 1000));
-            }
-        }
-    }
-    finally {
-        await browser.close();
-    }
-    // Average the metrics
-    const avgMetrics = {};
-    const numericMetricKeys = [
-        "lcp", "fid", "cls", "fcp", "ttfb", "tti", "tbt",
-        "domContentLoaded", "load", "resourceCount", "transferSize"
-    ];
-    for (const key of numericMetricKeys) {
-        const values = allMetrics
-            .map((m) => m[key])
-            .filter((v) => v !== undefined && v !== null);
-        if (values.length > 0) {
-            avgMetrics[key] = values.reduce((a, b) => a + b, 0) / values.length;
-        }
-    }
-    // Determine ratings
-    if (avgMetrics.lcp !== undefined) {
-        avgMetrics.lcpRating = avgMetrics.lcp <= 2500 ? "good" : avgMetrics.lcp <= 4000 ? "needs-improvement" : "poor";
-    }
-    if (avgMetrics.cls !== undefined) {
-        avgMetrics.clsRating = avgMetrics.cls <= 0.1 ? "good" : avgMetrics.cls <= 0.25 ? "needs-improvement" : "poor";
-    }
-    const baseline = {
-        id: `baseline-${Date.now()}`,
-        url,
-        name: name || new URL(url).hostname,
-        timestamp: new Date().toISOString(),
-        metrics: avgMetrics,
-        runsAveraged: runs,
-        environment: {
-            browser: "chromium",
-            viewport: { width: 1280, height: 720 },
-            device,
-            connection: throttle,
-        },
-    };
-    // Save baseline
-    const baselinesDir = (0, path_1.join)(paths.dataDir, "baselines");
-    if (!(0, fs_1.existsSync)(baselinesDir)) {
-        (0, fs_1.mkdirSync)(baselinesDir, { recursive: true });
-    }
-    const baselineFile = (0, path_1.join)(baselinesDir, `${baseline.id}.json`);
-    (0, fs_1.writeFileSync)(baselineFile, JSON.stringify(baseline, null, 2));
-    return baseline;
-}
-/**
- * List all saved performance baselines
- */
-function listPerformanceBaselines() {
-    const paths = (0, config_js_1.getPaths)();
-    const baselinesDir = (0, path_1.join)(paths.dataDir, "baselines");
-    if (!(0, fs_1.existsSync)(baselinesDir)) {
-        return [];
-    }
-    const files = (0, fs_1.readdirSync)(baselinesDir).filter((f) => f.endsWith(".json"));
-    const baselines = [];
-    for (const file of files) {
-        try {
-            const content = (0, fs_1.readFileSync)((0, path_1.join)(baselinesDir, file), "utf-8");
-            baselines.push(JSON.parse(content));
-        }
-        catch {
-            // Skip invalid files
-        }
-    }
-    return baselines.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
-}
-/**
- * Load a specific baseline by ID or name
- */
-function loadPerformanceBaseline(idOrName) {
-    const baselines = listPerformanceBaselines();
-    // Try exact ID match first
-    let baseline = baselines.find((b) => b.id === idOrName);
-    if (baseline)
-        return baseline;
-    // Try name match
-    baseline = baselines.find((b) => b.name === idOrName);
-    if (baseline)
-        return baseline;
-    // Try URL match
-    baseline = baselines.find((b) => b.url.includes(idOrName));
-    return baseline || null;
-}
-/**
- * Delete a performance baseline
- */
-function deletePerformanceBaseline(idOrName) {
-    const baseline = loadPerformanceBaseline(idOrName);
-    if (!baseline)
-        return false;
-    const paths = (0, config_js_1.getPaths)();
-    const baselineFile = (0, path_1.join)(paths.dataDir, "baselines", `${baseline.id}.json`);
-    if ((0, fs_1.existsSync)(baselineFile)) {
-        (0, fs_1.unlinkSync)(baselineFile);
-        return true;
-    }
-    return false;
-}
-/**
- * Compare current performance against a baseline
- */
-async function detectPerformanceRegression(url, baselineIdOrName, options = {}) {
-    const { thresholds = DEFAULT_REGRESSION_THRESHOLDS, headless = true } = options;
-    const startTime = Date.now();
-    // Load baseline
-    const baseline = loadPerformanceBaseline(baselineIdOrName);
-    if (!baseline) {
-        throw new Error(`Baseline not found: ${baselineIdOrName}`);
-    }
-    // Capture current metrics
-    const browser = new CBrowser({ headless });
-    let currentMetrics;
-    try {
-        await browser.navigate(url);
-        await new Promise((r) => setTimeout(r, 2000));
-        currentMetrics = await browser.getPerformanceMetrics();
-    }
-    finally {
-        await browser.close();
-    }
-    // Compare metrics
-    const comparisons = [];
-    const regressions = [];
-    const metricsToCompare = [
-        "lcp", "fid", "cls", "fcp", "ttfb", "tti", "tbt", "transferSize"
-    ];
-    for (const metric of metricsToCompare) {
-        const baselineValue = baseline.metrics[metric];
-        const currentValue = currentMetrics[metric];
-        if (baselineValue === undefined || currentValue === undefined)
-            continue;
-        const change = currentValue - baselineValue;
-        const changePercent = baselineValue > 0 ? (change / baselineValue) * 100 : 0;
-        // Determine threshold and if it's a regression
-        const threshold = thresholds[metric] || 20;
-        const isClsMetric = metric === "cls";
-        // For CLS, threshold is absolute; for others, it's percentage
-        const exceedsThreshold = isClsMetric
-            ? change > threshold
-            : changePercent > threshold;
-        let status = "stable";
-        let severity = "warning";
-        if (changePercent < -10 || (isClsMetric && change < -0.05)) {
-            status = "improved";
-        }
-        else if (exceedsThreshold) {
-            if (isClsMetric ? change > threshold * 2 : changePercent > threshold * 2) {
-                status = "critical";
-                severity = "critical";
-            }
-            else {
-                status = "regression";
-                severity = "regression";
-            }
-        }
-        else if (changePercent > 5 || (isClsMetric && change > 0.02)) {
-            status = "warning";
-        }
-        const comparison = {
-            metric,
-            baseline: baselineValue,
-            current: currentValue,
-            change,
-            changePercent,
-            isRegression: status === "regression" || status === "critical",
-            isImprovement: status === "improved",
-            status,
-        };
-        comparisons.push(comparison);
-        if (comparison.isRegression) {
-            regressions.push({
-                metric,
-                baselineValue,
-                currentValue,
-                change,
-                changePercent,
-                threshold,
-                severity,
-            });
-        }
-    }
-    // Calculate summary
-    const improved = comparisons.filter((c) => c.isImprovement).length;
-    const regressed = comparisons.filter((c) => c.status === "regression").length;
-    const critical = comparisons.filter((c) => c.status === "critical").length;
-    const stable = comparisons.filter((c) => c.status === "stable" || c.status === "warning").length;
-    const overallChange = comparisons.length > 0
-        ? comparisons.reduce((sum, c) => sum + c.changePercent, 0) / comparisons.length
-        : 0;
-    return {
-        url,
-        baseline,
-        currentMetrics,
-        timestamp: new Date().toISOString(),
-        duration: Date.now() - startTime,
-        comparisons,
-        regressions,
-        passed: regressions.length === 0,
-        summary: {
-            totalMetrics: comparisons.length,
-            improved,
-            stable,
-            regressed,
-            critical,
-            overallChange,
-        },
-    };
-}
-/**
- * Format a performance regression report
- */
-function formatPerformanceRegressionReport(result) {
-    const lines = [];
-    lines.push("🔍 PERFORMANCE REGRESSION REPORT");
-    lines.push("═".repeat(60));
-    lines.push("");
-    lines.push(`📍 URL: ${result.url}`);
-    lines.push(`📊 Baseline: ${result.baseline.name} (${new Date(result.baseline.timestamp).toLocaleDateString()})`);
-    lines.push(`⏱️  Duration: ${(result.duration / 1000).toFixed(1)}s`);
-    lines.push("");
-    // Overall result
-    if (result.passed) {
-        lines.push("✅ PASSED - No performance regressions detected");
-    }
-    else {
-        lines.push(`❌ FAILED - ${result.regressions.length} regression(s) detected`);
-    }
-    lines.push("");
-    // Detailed comparisons
-    lines.push("─".repeat(60));
-    lines.push("METRIC COMPARISON");
-    lines.push("─".repeat(60));
-    lines.push("");
-    const metricNames = {
-        lcp: "LCP (Largest Contentful Paint)",
-        fid: "FID (First Input Delay)",
-        cls: "CLS (Cumulative Layout Shift)",
-        fcp: "FCP (First Contentful Paint)",
-        ttfb: "TTFB (Time to First Byte)",
-        tti: "TTI (Time to Interactive)",
-        tbt: "TBT (Total Blocking Time)",
-        transferSize: "Transfer Size",
-    };
-    for (const comp of result.comparisons) {
-        const name = metricNames[comp.metric] || comp.metric;
-        const icon = comp.isImprovement ? "✅" :
-            comp.status === "critical" ? "🔴" :
-                comp.status === "regression" ? "❌" :
-                    comp.status === "warning" ? "⚠️" : "✓";
-        const unit = comp.metric === "cls" ? "" :
-            comp.metric === "transferSize" ? " KB" : " ms";
-        const baseVal = comp.metric === "transferSize"
-            ? (comp.baseline / 1024).toFixed(1)
-            : comp.baseline.toFixed(1);
-        const currVal = comp.metric === "transferSize"
-            ? (comp.current / 1024).toFixed(1)
-            : comp.current.toFixed(1);
-        const changeStr = comp.changePercent >= 0
-            ? `+${comp.changePercent.toFixed(1)}%`
-            : `${comp.changePercent.toFixed(1)}%`;
-        lines.push(`${icon} ${name}`);
-        lines.push(`   Baseline: ${baseVal}${unit} → Current: ${currVal}${unit} (${changeStr})`);
-        lines.push("");
-    }
-    // Summary
-    lines.push("─".repeat(60));
-    lines.push("SUMMARY");
-    lines.push("─".repeat(60));
-    lines.push("");
-    lines.push(`  Total Metrics: ${result.summary.totalMetrics}`);
-    lines.push(`  ✅ Improved: ${result.summary.improved}`);
-    lines.push(`  ✓  Stable: ${result.summary.stable}`);
-    lines.push(`  ❌ Regressed: ${result.summary.regressed}`);
-    lines.push(`  🔴 Critical: ${result.summary.critical}`);
-    lines.push(`  📊 Overall Change: ${result.summary.overallChange >= 0 ? "+" : ""}${result.summary.overallChange.toFixed(1)}%`);
-    lines.push("");
-    // Recommendations if regressions found
-    if (result.regressions.length > 0) {
-        lines.push("─".repeat(60));
-        lines.push("💡 RECOMMENDATIONS");
-        lines.push("─".repeat(60));
-        lines.push("");
-        for (const reg of result.regressions) {
-            const name = metricNames[reg.metric] || reg.metric;
-            lines.push(`⚠️ ${name}:`);
-            switch (reg.metric) {
-                case "lcp":
-                    lines.push("   - Optimize largest content element (images, videos)");
-                    lines.push("   - Consider lazy loading below-fold content");
-                    lines.push("   - Improve server response times");
-                    break;
-                case "cls":
-                    lines.push("   - Set explicit dimensions on images/embeds");
-                    lines.push("   - Avoid inserting content above existing content");
-                    lines.push("   - Reserve space for dynamic content");
-                    break;
-                case "fcp":
-                case "ttfb":
-                    lines.push("   - Optimize server response time");
-                    lines.push("   - Use CDN for static assets");
-                    lines.push("   - Enable compression (gzip/brotli)");
-                    break;
-                case "tbt":
-                case "tti":
-                    lines.push("   - Split long JavaScript tasks");
-                    lines.push("   - Defer non-critical JavaScript");
-                    lines.push("   - Remove unused code");
-                    break;
-                case "transferSize":
-                    lines.push("   - Compress and optimize assets");
-                    lines.push("   - Remove unused CSS/JavaScript");
-                    lines.push("   - Optimize images (WebP, proper sizing)");
-                    break;
-                default:
-                    lines.push("   - Review recent changes for performance impact");
-            }
-            lines.push("");
-        }
-    }
-    return lines.join("\n");
-}
-// ============================================================================
-// Test Coverage Map (v6.5.0)
-// ============================================================================
-/**
- * Parse test files to extract tested URLs and actions
- */
-function parseTestFilesForCoverage(testFiles) {
-    const pageMap = new Map();
-    for (const testFile of testFiles) {
-        if (!(0, fs_1.existsSync)(testFile))
-            continue;
-        const content = (0, fs_1.readFileSync)(testFile, "utf-8");
-        const lines = content.split("\n");
-        let currentUrl = null;
-        let lineNumber = 0;
-        for (const line of lines) {
-            lineNumber++;
-            const trimmed = line.trim().toLowerCase();
-            // Skip comments and empty lines
-            if (trimmed.startsWith("#") || !trimmed)
-                continue;
-            // Detect navigation
-            const navMatch = line.match(/(?:go to|navigate to|open|visit)\s+["']?([^"'\s]+)["']?/i);
-            if (navMatch) {
-                currentUrl = navMatch[1];
-                const path = normalizeUrlToPath(currentUrl);
-                if (!pageMap.has(path)) {
-                    pageMap.set(path, {
-                        url: currentUrl,
-                        path,
-                        testFiles: [],
-                        actions: [],
-                        testCount: 0,
-                        coverageScore: 0,
-                    });
-                }
-                const page = pageMap.get(path);
-                if (!page.testFiles.includes(testFile)) {
-                    page.testFiles.push(testFile);
-                    page.testCount++;
-                }
-                page.actions.push({
-                    type: "navigate",
-                    target: currentUrl,
-                    testFile,
-                    lineNumber,
-                });
-            }
-            // Detect click actions
-            const clickMatch = line.match(/click\s+(?:on\s+)?(?:the\s+)?["']?([^"'\n]+)["']?/i);
-            if (clickMatch && currentUrl) {
-                const path = normalizeUrlToPath(currentUrl);
-                const page = pageMap.get(path);
-                if (page) {
-                    page.actions.push({
-                        type: "click",
-                        target: clickMatch[1].trim(),
-                        testFile,
-                        lineNumber,
-                    });
-                }
-            }
-            // Detect fill/type actions
-            const fillMatch = line.match(/(?:type|fill|enter)\s+["']([^"']+)["']\s+(?:in|into)\s+(?:the\s+)?["']?([^"'\n]+)["']?/i);
-            if (fillMatch && currentUrl) {
-                const path = normalizeUrlToPath(currentUrl);
-                const page = pageMap.get(path);
-                if (page) {
-                    page.actions.push({
-                        type: "fill",
-                        target: fillMatch[2].trim(),
-                        value: fillMatch[1],
-                        testFile,
-                        lineNumber,
-                    });
-                }
-            }
-            // Detect verify actions
-            const verifyMatch = line.match(/(?:verify|assert|check|expect|should)\s+(.+)/i);
-            if (verifyMatch && currentUrl) {
-                const path = normalizeUrlToPath(currentUrl);
-                const page = pageMap.get(path);
-                if (page) {
-                    page.actions.push({
-                        type: "verify",
-                        target: verifyMatch[1].trim(),
-                        testFile,
-                        lineNumber,
-                    });
-                }
-            }
-            // Detect wait actions
-            const waitMatch = line.match(/wait\s+(?:for\s+)?(.+)/i);
-            if (waitMatch && currentUrl) {
-                const path = normalizeUrlToPath(currentUrl);
-                const page = pageMap.get(path);
-                if (page) {
-                    page.actions.push({
-                        type: "wait",
-                        target: waitMatch[1].trim(),
-                        testFile,
-                        lineNumber,
-                    });
-                }
-            }
-        }
-    }
-    // Calculate coverage scores
-    for (const page of pageMap.values()) {
-        const hasClicks = page.actions.some(a => a.type === "click");
-        const hasFills = page.actions.some(a => a.type === "fill");
-        const hasVerifies = page.actions.some(a => a.type === "verify");
-        let score = 20; // Base score for visiting
-        if (hasClicks)
-            score += 25;
-        if (hasFills)
-            score += 25;
-        if (hasVerifies)
-            score += 30;
-        page.coverageScore = Math.min(100, score);
-    }
-    return Array.from(pageMap.values());
-}
-/**
- * Normalize URL to a path for comparison
- */
-function normalizeUrlToPath(url) {
-    try {
-        const parsed = new URL(url);
-        return parsed.pathname.replace(/\/$/, "") || "/";
-    }
-    catch {
-        // Not a full URL, treat as path
-        return url.replace(/\/$/, "") || "/";
-    }
-}
-/**
- * Fetch and parse sitemap.xml
- */
-async function parseSitemap(sitemapUrl) {
-    const pages = [];
-    try {
-        const response = await fetch(sitemapUrl);
-        const xml = await response.text();
-        // Simple XML parsing for sitemap
-        const locMatches = xml.matchAll(/<loc>([^<]+)<\/loc>/g);
-        for (const match of locMatches) {
-            const url = match[1].trim();
-            pages.push({
-                url,
-                path: normalizeUrlToPath(url),
-                source: "sitemap",
-            });
-        }
-    }
-    catch (err) {
-        console.error(`Failed to fetch sitemap: ${err}`);
-    }
-    return pages;
-}
-/**
- * Crawl a site to discover pages
- */
-async function crawlSiteForCoverage(startUrl, maxPages = 100, includePattern, excludePattern) {
-    const pages = [];
-    const visited = new Set();
-    const queue = [startUrl];
-    const browser = new CBrowser({
-        headless: true,
-        browser: "chromium",
-    });
-    const baseUrl = new URL(startUrl);
-    const includeRegex = includePattern ? new RegExp(includePattern) : null;
-    const excludeRegex = excludePattern ? new RegExp(excludePattern) : null;
-    try {
-        while (queue.length > 0 && pages.length < maxPages) {
-            const url = queue.shift();
-            const path = normalizeUrlToPath(url);
-            if (visited.has(path))
-                continue;
-            visited.add(path);
-            // Check patterns
-            if (includeRegex && !includeRegex.test(path))
-                continue;
-            if (excludeRegex && excludeRegex.test(path))
-                continue;
-            try {
-                const result = await browser.navigate(url);
-                // Count interactive elements
-                const page = await browser.getPage();
-                const interactiveElements = await page.locator("button, a, input, select, textarea, [onclick], [role='button']").count();
-                const formCount = await page.locator("form").count();
-                // Get outbound links
-                const links = await page.locator("a[href]").evaluateAll((els) => els.map(el => el.href).filter(href => href && !href.startsWith("javascript:")));
-                const sitePage = {
-                    url,
-                    path,
-                    title: result.title,
-                    source: pages.length === 0 ? "crawl" : "link",
-                    status: 200,
-                    outboundLinks: links,
-                    interactiveElements,
-                    formCount,
-                };
-                pages.push(sitePage);
-                // Add internal links to queue
-                for (const link of links) {
-                    try {
-                        const linkUrl = new URL(link);
-                        if (linkUrl.hostname === baseUrl.hostname && !visited.has(normalizeUrlToPath(link))) {
-                            queue.push(link);
-                        }
-                    }
-                    catch {
-                        // Invalid URL, skip
-                    }
-                }
-            }
-            catch (err) {
-                // Page failed to load
-                pages.push({
-                    url,
-                    path,
-                    source: "link",
-                    status: 0,
-                });
-            }
-        }
-    }
-    finally {
-        await browser.close();
-    }
-    return pages;
-}
-/**
- * Identify coverage gaps
- */
-function identifyCoverageGaps(sitePages, testedPages, minCoverage = 50) {
-    const gaps = [];
-    const testedPaths = new Set(testedPages.map(p => p.path));
-    for (const sitePage of sitePages) {
-        const testedPage = testedPages.find(p => p.path === sitePage.path);
-        // Completely untested
-        if (!testedPage) {
-            const priority = determinePriority(sitePage);
-            gaps.push({
-                page: sitePage,
-                reason: "untested",
-                priority,
-                suggestedTests: generateSuggestedTests(sitePage),
-                similarTestedPages: findSimilarTestedPages(sitePage.path, testedPages),
-            });
-            continue;
-        }
-        // Low coverage
-        if (testedPage.coverageScore < minCoverage) {
-            gaps.push({
-                page: sitePage,
-                reason: "low-coverage",
-                priority: "medium",
-                suggestedTests: generateSuggestedTests(sitePage, testedPage),
-            });
-            continue;
-        }
-        // No interactions tested
-        const hasInteractions = testedPage.actions.some(a => a.type === "click" || a.type === "fill");
-        if (!hasInteractions && sitePage.interactiveElements && sitePage.interactiveElements > 5) {
-            gaps.push({
-                page: sitePage,
-                reason: "no-interactions",
-                priority: "low",
-                suggestedTests: [`Test interactive elements on ${sitePage.path}`],
-            });
-        }
-        // No verifications
-        const hasVerifications = testedPage.actions.some(a => a.type === "verify");
-        if (!hasVerifications) {
-            gaps.push({
-                page: sitePage,
-                reason: "no-verifications",
-                priority: "low",
-                suggestedTests: [`Add assertions to verify ${sitePage.path} content`],
-            });
-        }
-    }
-    // Sort by priority
-    const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
-    gaps.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
-    return gaps;
-}
-/**
- * Determine priority of an untested page
- */
-function determinePriority(page) {
-    const path = page.path.toLowerCase();
-    // Critical paths
-    if (path.includes("checkout") || path.includes("payment") || path.includes("login") ||
-        path.includes("register") || path.includes("signup") || path.includes("auth")) {
-        return "critical";
-    }
-    // High priority - user account, settings
-    if (path.includes("account") || path.includes("profile") || path.includes("settings") ||
-        path.includes("dashboard") || path.includes("admin")) {
-        return "high";
-    }
-    // Medium - has forms or many interactive elements
-    if (page.formCount && page.formCount > 0)
-        return "medium";
-    if (page.interactiveElements && page.interactiveElements > 10)
-        return "medium";
-    return "low";
-}
-/**
- * Generate suggested test steps for a page
- */
-function generateSuggestedTests(sitePage, existingTests) {
-    const suggestions = [];
-    suggestions.push(`go to ${sitePage.url}`);
-    if (sitePage.formCount && sitePage.formCount > 0) {
-        suggestions.push(`fill form fields with test data`);
-        suggestions.push(`submit form and verify success`);
-    }
-    if (sitePage.interactiveElements && sitePage.interactiveElements > 0) {
-        suggestions.push(`click primary call-to-action`);
-    }
-    suggestions.push(`verify page contains expected content`);
-    suggestions.push(`verify no console errors`);
-    if (existingTests) {
-        // Add specific suggestions based on what's missing
-        const hasClicks = existingTests.actions.some(a => a.type === "click");
-        const hasFills = existingTests.actions.some(a => a.type === "fill");
-        const hasVerifies = existingTests.actions.some(a => a.type === "verify");
-        if (!hasClicks)
-            suggestions.unshift(`# Add click interactions`);
-        if (!hasFills && sitePage.formCount)
-            suggestions.unshift(`# Add form fill tests`);
-        if (!hasVerifies)
-            suggestions.unshift(`# Add verification assertions`);
-    }
-    return suggestions;
-}
-/**
- * Find similar tested pages for reference
- */
-function findSimilarTestedPages(path, testedPages) {
-    const segments = path.split("/").filter(Boolean);
-    if (segments.length === 0)
-        return [];
-    const similar = [];
-    const prefix = "/" + segments[0];
-    for (const tested of testedPages) {
-        if (tested.path.startsWith(prefix) && tested.path !== path) {
-            similar.push(tested.path);
-            if (similar.length >= 3)
-                break;
-        }
-    }
-    return similar;
-}
-/**
- * Calculate overall coverage analysis
- */
-function calculateCoverageAnalysis(sitePages, testedPages) {
-    const testedPaths = new Set(testedPages.map(p => p.path));
-    // Section coverage
-    const sections = {};
-    for (const page of sitePages) {
-        const segments = page.path.split("/").filter(Boolean);
-        const section = segments.length > 0 ? "/" + segments[0] : "/";
-        if (!sections[section]) {
-            sections[section] = { total: 0, tested: 0 };
-        }
-        sections[section].total++;
-        if (testedPaths.has(page.path)) {
-            sections[section].tested++;
-        }
-    }
-    const sectionCoverage = {};
-    for (const [section, data] of Object.entries(sections)) {
-        sectionCoverage[section] = {
-            ...data,
-            percent: data.total > 0 ? Math.round((data.tested / data.total) * 100) : 0,
-        };
-    }
-    const totalPages = sitePages.length;
-    const testedCount = sitePages.filter(p => testedPaths.has(p.path)).length;
-    return {
-        totalPages,
-        testedPages: testedCount,
-        untestedPages: totalPages - testedCount,
-        coveragePercent: totalPages > 0 ? Math.round((testedCount / totalPages) * 100) : 0,
-        sectionCoverage,
-    };
-}
-/**
- * Generate complete coverage map
- */
-async function generateCoverageMap(baseUrl, testFiles, options = {}) {
-    const startTime = Date.now();
-    // Parse test files
-    const testedPages = parseTestFilesForCoverage(testFiles);
-    // Get site pages
-    let sitePages;
-    if (options.sitemapUrl) {
-        sitePages = await parseSitemap(options.sitemapUrl);
-    }
-    else {
-        sitePages = await crawlSiteForCoverage(baseUrl, options.maxPages || 100, options.includePattern, options.excludePattern);
-    }
-    // Identify gaps
-    const gaps = identifyCoverageGaps(sitePages, testedPages, options.minCoverage || 50);
-    // Calculate analysis
-    const analysis = calculateCoverageAnalysis(sitePages, testedPages);
-    // Generate recommendations
-    const recommendations = [];
-    if (analysis.coveragePercent < 50) {
-        recommendations.push("Coverage is below 50% - prioritize testing critical paths");
-    }
-    const criticalGaps = gaps.filter(g => g.priority === "critical");
-    if (criticalGaps.length > 0) {
-        recommendations.push(`${criticalGaps.length} critical pages have no tests (checkout, auth, etc.)`);
-    }
-    const lowCoverageSections = Object.entries(analysis.sectionCoverage)
-        .filter(([_, data]) => data.percent < 30 && data.total > 2)
-        .map(([section]) => section);
-    if (lowCoverageSections.length > 0) {
-        recommendations.push(`Sections with low coverage: ${lowCoverageSections.join(", ")}`);
-    }
-    if (gaps.filter(g => g.reason === "no-verifications").length > 3) {
-        recommendations.push("Many tests lack assertions - add verification steps");
-    }
-    return {
-        baseUrl,
-        timestamp: new Date().toISOString(),
-        duration: Date.now() - startTime,
-        testFiles,
-        sitePages,
-        testedPages,
-        gaps,
-        analysis,
-        recommendations,
-    };
-}
-/**
- * Format coverage map as text report
- */
-function formatCoverageReport(result) {
-    const lines = [];
-    lines.push("╔══════════════════════════════════════════════════════════════════════════════╗");
-    lines.push("║                         TEST COVERAGE MAP REPORT                            ║");
-    lines.push("╚══════════════════════════════════════════════════════════════════════════════╝");
-    lines.push("");
-    lines.push(`📊 Site: ${result.baseUrl}`);
-    lines.push(`📅 Generated: ${result.timestamp}`);
-    lines.push(`⏱️  Analysis time: ${(result.duration / 1000).toFixed(1)}s`);
-    lines.push(`📝 Test files analyzed: ${result.testFiles.length}`);
-    lines.push("");
-    // Overall coverage
-    lines.push("═══════════════════════════════════════════════════════════════════════════════");
-    lines.push("📈 OVERALL COVERAGE");
-    lines.push("═══════════════════════════════════════════════════════════════════════════════");
-    lines.push("");
-    const { analysis } = result;
-    const coverageBar = generateCoverageProgressBar(analysis.coveragePercent);
-    lines.push(`  Coverage: ${coverageBar} ${analysis.coveragePercent}%`);
-    lines.push("");
-    lines.push(`  Total pages:    ${analysis.totalPages}`);
-    lines.push(`  Tested pages:   ${analysis.testedPages}`);
-    lines.push(`  Untested pages: ${analysis.untestedPages}`);
-    lines.push("");
-    // Section coverage
-    lines.push("───────────────────────────────────────────────────────────────────────────────");
-    lines.push("📁 COVERAGE BY SECTION");
-    lines.push("───────────────────────────────────────────────────────────────────────────────");
-    lines.push("");
-    const sections = Object.entries(analysis.sectionCoverage)
-        .sort((a, b) => b[1].total - a[1].total);
-    for (const [section, data] of sections) {
-        const bar = generateCoverageProgressBar(data.percent, 20);
-        const status = data.percent >= 70 ? "✅" : data.percent >= 40 ? "⚠️" : "❌";
-        lines.push(`  ${status} ${section.padEnd(20)} ${bar} ${data.tested}/${data.total} (${data.percent}%)`);
-    }
-    lines.push("");
-    // Coverage gaps
-    if (result.gaps.length > 0) {
-        lines.push("═══════════════════════════════════════════════════════════════════════════════");
-        lines.push("🕳️  COVERAGE GAPS");
-        lines.push("═══════════════════════════════════════════════════════════════════════════════");
-        lines.push("");
-        const priorityEmoji = { critical: "🚨", high: "🔴", medium: "🟡", low: "🟢" };
-        for (const gap of result.gaps.slice(0, 15)) {
-            const emoji = priorityEmoji[gap.priority];
-            lines.push(`  ${emoji} ${gap.page.path}`);
-            lines.push(`     Reason: ${gap.reason} | Priority: ${gap.priority}`);
-            if (gap.suggestedTests.length > 0) {
-                lines.push(`     Suggested: ${gap.suggestedTests[0]}`);
-            }
-            lines.push("");
-        }
-        if (result.gaps.length > 15) {
-            lines.push(`  ... and ${result.gaps.length - 15} more gaps`);
-            lines.push("");
-        }
-    }
-    // Recommendations
-    if (result.recommendations.length > 0) {
-        lines.push("═══════════════════════════════════════════════════════════════════════════════");
-        lines.push("💡 RECOMMENDATIONS");
-        lines.push("═══════════════════════════════════════════════════════════════════════════════");
-        lines.push("");
-        for (const rec of result.recommendations) {
-            lines.push(`  ${rec}`);
-        }
-        lines.push("");
-    }
-    // Tested pages summary
-    lines.push("───────────────────────────────────────────────────────────────────────────────");
-    lines.push("✅ TESTED PAGES (Top 10 by coverage)");
-    lines.push("───────────────────────────────────────────────────────────────────────────────");
-    lines.push("");
-    const topTested = [...result.testedPages]
-        .sort((a, b) => b.coverageScore - a.coverageScore)
-        .slice(0, 10);
-    for (const page of topTested) {
-        const bar = generateCoverageProgressBar(page.coverageScore, 15);
-        lines.push(`  ${bar} ${page.coverageScore}% ${page.path}`);
-        lines.push(`       Actions: ${page.actions.length} | Tests: ${page.testCount}`);
-    }
-    return lines.join("\n");
-}
-/**
- * Generate HTML coverage report
- */
-function generateCoverageHtmlReport(result) {
-    const { analysis, gaps, testedPages } = result;
-    const coverageColor = analysis.coveragePercent >= 70 ? "#22c55e" :
-        analysis.coveragePercent >= 40 ? "#eab308" : "#ef4444";
-    return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Test Coverage Map - ${result.baseUrl}</title>
-  <style>
-    * { box-sizing: border-box; margin: 0; padding: 0; }
-    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #1a1a2e; color: #eee; padding: 2rem; }
-    .container { max-width: 1200px; margin: 0 auto; }
-    h1 { color: #fff; margin-bottom: 0.5rem; }
-    .subtitle { color: #888; margin-bottom: 2rem; }
-    .card { background: #252540; border-radius: 12px; padding: 1.5rem; margin-bottom: 1.5rem; }
-    .card h2 { color: #fff; font-size: 1.1rem; margin-bottom: 1rem; display: flex; align-items: center; gap: 0.5rem; }
-    .stats { display: grid; grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); gap: 1rem; }
-    .stat { text-align: center; }
-    .stat-value { font-size: 2rem; font-weight: bold; color: ${coverageColor}; }
-    .stat-label { color: #888; font-size: 0.875rem; }
-    .progress-bar { height: 8px; background: #333; border-radius: 4px; overflow: hidden; margin: 1rem 0; }
-    .progress-fill { height: 100%; background: ${coverageColor}; transition: width 0.5s; }
-    .section-list { list-style: none; }
-    .section-item { display: flex; align-items: center; gap: 1rem; padding: 0.75rem 0; border-bottom: 1px solid #333; }
-    .section-name { flex: 1; }
-    .section-bar { width: 150px; height: 6px; background: #333; border-radius: 3px; overflow: hidden; }
-    .section-bar-fill { height: 100%; border-radius: 3px; }
-    .section-percent { width: 60px; text-align: right; font-weight: 500; }
-    .gap-list { list-style: none; }
-    .gap-item { padding: 1rem; margin-bottom: 0.75rem; background: #1a1a2e; border-radius: 8px; border-left: 4px solid; }
-    .gap-critical { border-color: #ef4444; }
-    .gap-high { border-color: #f97316; }
-    .gap-medium { border-color: #eab308; }
-    .gap-low { border-color: #22c55e; }
-    .gap-path { font-weight: 600; color: #fff; }
-    .gap-reason { color: #888; font-size: 0.875rem; margin-top: 0.25rem; }
-    .badge { display: inline-block; padding: 0.25rem 0.5rem; border-radius: 4px; font-size: 0.75rem; font-weight: 600; text-transform: uppercase; }
-    .badge-critical { background: #ef4444; color: #fff; }
-    .badge-high { background: #f97316; color: #fff; }
-    .badge-medium { background: #eab308; color: #000; }
-    .badge-low { background: #22c55e; color: #fff; }
-    .recommendations { list-style: none; }
-    .recommendations li { padding: 0.75rem; background: #1a1a2e; border-radius: 6px; margin-bottom: 0.5rem; }
-    .page-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(250px, 1fr)); gap: 1rem; }
-    .page-card { background: #1a1a2e; border-radius: 8px; padding: 1rem; }
-    .page-score { font-size: 1.5rem; font-weight: bold; }
-    .page-path { color: #888; font-size: 0.875rem; word-break: break-all; }
-  </style>
-</head>
-<body>
-  <div class="container">
-    <h1>Test Coverage Map</h1>
-    <p class="subtitle">${result.baseUrl} | Generated ${new Date(result.timestamp).toLocaleString()}</p>
-
-    <div class="card">
-      <h2>📊 Overall Coverage</h2>
-      <div class="stats">
-        <div class="stat">
-          <div class="stat-value">${analysis.coveragePercent}%</div>
-          <div class="stat-label">Coverage</div>
-        </div>
-        <div class="stat">
-          <div class="stat-value">${analysis.totalPages}</div>
-          <div class="stat-label">Total Pages</div>
-        </div>
-        <div class="stat">
-          <div class="stat-value">${analysis.testedPages}</div>
-          <div class="stat-label">Tested</div>
-        </div>
-        <div class="stat">
-          <div class="stat-value">${analysis.untestedPages}</div>
-          <div class="stat-label">Untested</div>
-        </div>
-      </div>
-      <div class="progress-bar">
-        <div class="progress-fill" style="width: ${analysis.coveragePercent}%"></div>
-      </div>
-    </div>
-
-    <div class="card">
-      <h2>📁 Coverage by Section</h2>
-      <ul class="section-list">
-        ${Object.entries(analysis.sectionCoverage)
-        .sort((a, b) => b[1].total - a[1].total)
-        .map(([section, data]) => {
-        const color = data.percent >= 70 ? "#22c55e" : data.percent >= 40 ? "#eab308" : "#ef4444";
-        return `
-              <li class="section-item">
-                <span class="section-name">${section}</span>
-                <div class="section-bar">
-                  <div class="section-bar-fill" style="width: ${data.percent}%; background: ${color}"></div>
-                </div>
-                <span class="section-percent" style="color: ${color}">${data.percent}%</span>
-                <span style="color: #666; font-size: 0.875rem">${data.tested}/${data.total}</span>
-              </li>
-            `;
-    }).join("")}
-      </ul>
-    </div>
-
-    ${gaps.length > 0 ? `
-      <div class="card">
-        <h2>🕳️ Coverage Gaps (${gaps.length})</h2>
-        <ul class="gap-list">
-          ${gaps.slice(0, 20).map(gap => `
-            <li class="gap-item gap-${gap.priority}">
-              <div style="display: flex; justify-content: space-between; align-items: center;">
-                <span class="gap-path">${gap.page.path}</span>
-                <span class="badge badge-${gap.priority}">${gap.priority}</span>
-              </div>
-              <div class="gap-reason">Reason: ${gap.reason}</div>
-            </li>
-          `).join("")}
-        </ul>
-        ${gaps.length > 20 ? `<p style="color: #666; text-align: center;">...and ${gaps.length - 20} more gaps</p>` : ""}
-      </div>
-    ` : ""}
-
-    ${result.recommendations.length > 0 ? `
-      <div class="card">
-        <h2>💡 Recommendations</h2>
-        <ul class="recommendations">
-          ${result.recommendations.map(rec => `<li>${rec}</li>`).join("")}
-        </ul>
-      </div>
-    ` : ""}
-
-    <div class="card">
-      <h2>✅ Tested Pages (Top 12)</h2>
-      <div class="page-grid">
-        ${testedPages
-        .sort((a, b) => b.coverageScore - a.coverageScore)
-        .slice(0, 12)
-        .map(page => {
-        const color = page.coverageScore >= 70 ? "#22c55e" : page.coverageScore >= 40 ? "#eab308" : "#ef4444";
-        return `
-              <div class="page-card">
-                <div class="page-score" style="color: ${color}">${page.coverageScore}%</div>
-                <div class="page-path">${page.path}</div>
-                <div style="color: #666; font-size: 0.75rem; margin-top: 0.5rem;">
-                  ${page.actions.length} actions | ${page.testCount} test(s)
-                </div>
-              </div>
-            `;
-    }).join("")}
-      </div>
-    </div>
-
-    <footer style="text-align: center; color: #666; margin-top: 2rem; font-size: 0.875rem;">
-      Generated by CBrowser v6.5.0 | Analysis took ${(result.duration / 1000).toFixed(1)}s
-    </footer>
-  </div>
-</body>
-</html>`;
-}
-/**
- * Generate a text progress bar for coverage
- */
-function generateCoverageProgressBar(percent, width = 30) {
-    const filled = Math.round((percent / 100) * width);
-    const empty = width - filled;
-    return "█".repeat(filled) + "░".repeat(empty);
-}
-// =========================================================================
-// Tier 7: AI Visual Regression (v7.0.0)
-// =========================================================================
-/**
- * Get the path to visual baselines storage
- */
-function getVisualBaselinesPath() {
-    const baseDir = process.env.CBROWSER_DATA_DIR || (0, path_1.join)(process.cwd(), ".cbrowser");
-    const baselinesDir = (0, path_1.join)(baseDir, "visual-baselines");
-    if (!(0, fs_1.existsSync)(baselinesDir)) {
-        (0, fs_1.mkdirSync)(baselinesDir, { recursive: true });
-    }
-    return baselinesDir;
-}
-/**
- * Get the path to visual baseline screenshots
- */
-function getVisualScreenshotsPath() {
-    const baselinesDir = getVisualBaselinesPath();
-    const screenshotsDir = (0, path_1.join)(baselinesDir, "screenshots");
-    if (!(0, fs_1.existsSync)(screenshotsDir)) {
-        (0, fs_1.mkdirSync)(screenshotsDir, { recursive: true });
-    }
-    return screenshotsDir;
-}
-/**
- * Load all visual baselines from storage
- */
-function loadVisualBaselines() {
-    const baselinesPath = getVisualBaselinesPath();
-    const indexPath = (0, path_1.join)(baselinesPath, "baselines.json");
-    if (!(0, fs_1.existsSync)(indexPath)) {
-        return [];
-    }
-    try {
-        const data = JSON.parse((0, fs_1.readFileSync)(indexPath, "utf-8"));
-        return data.baselines || [];
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Save visual baselines to storage
- */
-function saveVisualBaselines(baselines) {
-    const baselinesPath = getVisualBaselinesPath();
-    const indexPath = (0, path_1.join)(baselinesPath, "baselines.json");
-    (0, fs_1.writeFileSync)(indexPath, JSON.stringify({ baselines, updated: new Date().toISOString() }, null, 2));
-}
-/**
- * Capture a visual baseline screenshot
- */
-async function captureVisualBaseline(url, name, options = {}) {
-    const browser = new CBrowser({
-        device: options.device,
-        viewportWidth: options.viewport?.width || 1920,
-        viewportHeight: options.viewport?.height || 1080,
-    });
-    try {
-        await browser.launch();
-        await browser.navigate(url);
-        // Wait if specified
-        if (options.waitFor) {
-            if (typeof options.waitFor === "number") {
-                await new Promise(resolve => setTimeout(resolve, options.waitFor));
-            }
-            else {
-                const page = await browser.getPage();
-                await page.waitForSelector(options.waitFor, { timeout: 10000 }).catch(() => { });
-            }
-        }
-        // Take screenshot
-        const screenshotsPath = getVisualScreenshotsPath();
-        const id = `${name.toLowerCase().replace(/[^a-z0-9]+/g, "-")}-${Date.now()}`;
-        const screenshotPath = (0, path_1.join)(screenshotsPath, `${id}.png`);
-        const page = await browser.getPage();
-        if (options.selector) {
-            const element = page.locator(options.selector).first();
-            await element.screenshot({ path: screenshotPath });
-        }
-        else {
-            await page.screenshot({ path: screenshotPath, fullPage: false });
-        }
-        // Get dimensions
-        const viewport = page.viewportSize() || { width: 1920, height: 1080 };
-        const baseline = {
-            id,
-            name,
-            url,
-            screenshotPath,
-            dimensions: viewport,
-            viewport,
-            device: options.device,
-            timestamp: new Date().toISOString(),
-            selector: options.selector,
-        };
-        // Save to index
-        const baselines = loadVisualBaselines();
-        // Remove existing baseline with same name (update)
-        const filtered = baselines.filter(b => b.name !== name);
-        filtered.push(baseline);
-        saveVisualBaselines(filtered);
-        return baseline;
-    }
-    finally {
-        await browser.close();
-    }
-}
-/**
- * List all visual baselines
- */
-function listVisualBaselines() {
-    return loadVisualBaselines();
-}
-/**
- * Get a visual baseline by name
- */
-function getVisualBaseline(name) {
-    const baselines = loadVisualBaselines();
-    return baselines.find(b => b.name === name);
-}
-/**
- * Delete a visual baseline
- */
-function deleteVisualBaseline(name) {
-    const baselines = loadVisualBaselines();
-    const baseline = baselines.find(b => b.name === name);
-    if (!baseline) {
-        return false;
-    }
-    // Delete screenshot file
-    if ((0, fs_1.existsSync)(baseline.screenshotPath)) {
-        (0, fs_1.unlinkSync)(baseline.screenshotPath);
-    }
-    // Update index
-    const filtered = baselines.filter(b => b.name !== name);
-    saveVisualBaselines(filtered);
-    return true;
-}
-/**
- * Analyze visual differences using AI
- */
-async function analyzeVisualDifferences(baselinePath, currentPath, options = {}) {
-    // Read both images as base64
-    const baselineImage = (0, fs_1.readFileSync)(baselinePath).toString("base64");
-    const currentImage = (0, fs_1.readFileSync)(currentPath).toString("base64");
-    // Build the AI prompt for analysis
-    const sensitivityDesc = {
-        low: "Only flag significant, obvious changes that would clearly impact users",
-        medium: "Flag notable changes in layout, content, or style",
-        high: "Flag any visible differences, including subtle spacing or color changes",
-    };
-    const prompt = `You are a visual regression testing AI. Compare these two screenshots and identify any differences.
-
-BASELINE IMAGE: The first/reference screenshot
-CURRENT IMAGE: The second/new screenshot
-
-Sensitivity level: ${options.sensitivity || "medium"} - ${sensitivityDesc[options.sensitivity || "medium"]}
-
-${options.ignoreRegions?.length ? `Ignore changes in these regions: ${JSON.stringify(options.ignoreRegions)}` : ""}
-
-Analyze the visual differences and respond in this exact JSON format:
-{
-  "overallStatus": "pass" | "warning" | "fail",
-  "summary": "Brief 1-2 sentence summary of changes found",
-  "changes": [
-    {
-      "type": "layout" | "content" | "style" | "missing" | "added" | "moved",
-      "severity": "breaking" | "warning" | "info" | "acceptable",
-      "region": { "x": 0, "y": 0, "width": 100, "height": 100 },
-      "description": "What changed",
-      "reasoning": "Why this matters",
-      "confidence": 0.95,
-      "suggestion": "Optional suggestion to fix or accept"
-    }
-  ],
-  "similarityScore": 0.85,
-  "productionReady": true | false,
-  "confidence": 0.9
-}
-
-Change severity guidelines:
-- "breaking": Layout shifts, missing critical elements, broken functionality indicators
-- "warning": Noticeable content changes, significant style differences
-- "info": Minor spacing changes, subtle color adjustments
-- "acceptable": Expected dynamic content (timestamps, ads), minor rendering differences
-
-For overallStatus:
-- "pass": No changes or only acceptable/info-level changes
-- "warning": Some warning-level changes that should be reviewed
-- "fail": Any breaking changes detected
-
-Respond ONLY with the JSON, no other text.`;
-    // Use Claude to analyze the images
-    // For now, we'll use a simulated response since we don't have direct API access
-    // In production, this would call the Anthropic API with vision
-    try {
-        // Try to use the inference tool if available
-        const { execSync } = await import("child_process");
-        const inferenceScript = (0, path_1.join)(process.env.HOME || "", ".claude/skills/Tools/Inference.ts");
-        if ((0, fs_1.existsSync)(inferenceScript)) {
-            // Create a temporary file with the images and prompt
-            const tempDir = (0, path_1.join)(getVisualBaselinesPath(), "temp");
-            if (!(0, fs_1.existsSync)(tempDir)) {
-                (0, fs_1.mkdirSync)(tempDir, { recursive: true });
-            }
-            const requestPath = (0, path_1.join)(tempDir, `analysis-${Date.now()}.json`);
-            (0, fs_1.writeFileSync)(requestPath, JSON.stringify({
-                prompt,
-                images: [
-                    { type: "base64", media_type: "image/png", data: baselineImage },
-                    { type: "base64", media_type: "image/png", data: currentImage },
-                ],
-            }));
-            // For now, perform a heuristic comparison since we can't easily call Claude with images
-            // This can be enhanced when proper API integration is available
-            const analysis = performHeuristicAnalysis(baselinePath, currentPath, options);
-            // Clean up
-            if ((0, fs_1.existsSync)(requestPath)) {
-                (0, fs_1.unlinkSync)(requestPath);
-            }
-            return analysis;
-        }
-    }
-    catch {
-        // Fall back to heuristic analysis
-    }
-    // Fallback: Heuristic analysis based on file comparison
-    return performHeuristicAnalysis(baselinePath, currentPath, options);
-}
-/**
- * Perform heuristic visual analysis when AI is not available
- */
-function performHeuristicAnalysis(baselinePath, currentPath, options = {}) {
-    const baselineStats = (0, fs_1.statSync)(baselinePath);
-    const currentStats = (0, fs_1.statSync)(currentPath);
-    // Simple heuristic: compare file sizes
-    const sizeDiff = Math.abs(baselineStats.size - currentStats.size);
-    const sizeRatio = sizeDiff / baselineStats.size;
-    const changes = [];
-    let overallStatus = "pass";
-    let similarityScore = 1.0;
-    // Size-based heuristics
-    if (sizeRatio > 0.3) {
-        changes.push({
-            type: "layout",
-            severity: "breaking",
-            region: { x: 0, y: 0, width: 1920, height: 1080 },
-            description: "Significant visual change detected (>30% size difference)",
-            reasoning: "Large file size difference indicates substantial visual changes",
-            confidence: 0.7,
-            suggestion: "Review the visual changes manually",
-        });
-        overallStatus = "fail";
-        similarityScore = 0.5;
-    }
-    else if (sizeRatio > 0.1) {
-        changes.push({
-            type: "content",
-            severity: "warning",
-            region: { x: 0, y: 0, width: 1920, height: 1080 },
-            description: "Moderate visual change detected (10-30% size difference)",
-            reasoning: "Moderate file size difference suggests some visual changes",
-            confidence: 0.6,
-            suggestion: "Review to confirm changes are expected",
-        });
-        overallStatus = "warning";
-        similarityScore = 0.75;
-    }
-    else if (sizeRatio > 0.02) {
-        changes.push({
-            type: "style",
-            severity: "info",
-            region: { x: 0, y: 0, width: 1920, height: 1080 },
-            description: "Minor visual change detected (2-10% size difference)",
-            reasoning: "Small file size difference indicates minor rendering differences",
-            confidence: 0.5,
-        });
-        similarityScore = 0.9;
-    }
-    // Apply sensitivity adjustments
-    if (options.sensitivity === "low" && overallStatus === "warning") {
-        overallStatus = "pass";
-    }
-    else if (options.sensitivity === "high" && changes.length === 0 && sizeRatio > 0.005) {
-        changes.push({
-            type: "style",
-            severity: "info",
-            region: { x: 0, y: 0, width: 1920, height: 1080 },
-            description: "Very minor visual change detected",
-            reasoning: "Slight file size difference at high sensitivity",
-            confidence: 0.4,
-        });
-        similarityScore = 0.95;
-    }
-    return {
-        overallStatus,
-        summary: changes.length === 0
-            ? "No significant visual changes detected"
-            : `Found ${changes.length} visual change(s) with ${overallStatus} status`,
-        changes,
-        similarityScore,
-        productionReady: overallStatus !== "fail",
-        confidence: 0.6, // Lower confidence for heuristic analysis
-        rawAnalysis: "Heuristic analysis based on file comparison (AI analysis not available)",
-    };
-}
-/**
- * Run visual regression test against a baseline
- */
-async function runVisualRegression(url, baselineName, options = {}) {
-    const startTime = Date.now();
-    const baseline = getVisualBaseline(baselineName);
-    if (!baseline) {
-        return {
-            passed: false,
-            baseline: null,
-            currentScreenshotPath: "",
-            analysis: {
-                overallStatus: "fail",
-                summary: `Baseline "${baselineName}" not found`,
-                changes: [],
-                similarityScore: 0,
-                productionReady: false,
-                confidence: 1.0,
-            },
-            duration: Date.now() - startTime,
-        };
-    }
-    // Capture current screenshot with same settings as baseline
-    const browser = new CBrowser({
-        device: baseline.device,
-        viewportWidth: baseline.viewport.width,
-        viewportHeight: baseline.viewport.height,
-    });
-    try {
-        await browser.launch();
-        await browser.navigate(url);
-        // Wait if specified in options
-        if (options.waitBeforeCapture) {
-            await new Promise(resolve => setTimeout(resolve, options.waitBeforeCapture));
-        }
-        // Take screenshot
-        const screenshotsPath = getVisualScreenshotsPath();
-        const currentScreenshotPath = (0, path_1.join)(screenshotsPath, `current-${baseline.id}-${Date.now()}.png`);
-        const page = await browser.getPage();
-        if (baseline.selector) {
-            const element = page.locator(baseline.selector).first();
-            await element.screenshot({ path: currentScreenshotPath });
-        }
-        else {
-            await page.screenshot({ path: currentScreenshotPath, fullPage: false });
-        }
-        // Analyze differences
-        const analysis = await analyzeVisualDifferences(baseline.screenshotPath, currentScreenshotPath, options);
-        // Determine pass/fail based on threshold
-        const threshold = options.threshold ?? 0.9;
-        const passed = analysis.similarityScore >= threshold && analysis.overallStatus !== "fail";
-        // Generate diff image path (if we had pixel-diff capability)
-        const diffImagePath = options.generateDiff
-            ? (0, path_1.join)(screenshotsPath, `diff-${baseline.id}-${Date.now()}.png`)
-            : undefined;
-        return {
-            passed,
-            baseline,
-            currentScreenshotPath,
-            diffImagePath,
-            analysis,
-            duration: Date.now() - startTime,
-        };
-    }
-    finally {
-        await browser.close();
-    }
-}
-/**
- * Run visual regression on multiple pages
- */
-async function runVisualRegressionSuite(suite, options = {}) {
-    const startTime = Date.now();
-    const results = [];
-    let passed = 0;
-    let failed = 0;
-    let warnings = 0;
-    console.log(`\n🔍 Running visual regression suite: ${suite.name}`);
-    console.log(`   Testing ${suite.pages.length} page(s)...\n`);
-    for (const page of suite.pages) {
-        console.log(`   📸 Testing: ${page.name}...`);
-        const result = await runVisualRegression(page.url, page.baselineName, { ...options, ...page.options });
-        results.push(result);
-        if (result.passed) {
-            if (result.analysis.overallStatus === "warning") {
-                warnings++;
-                console.log(`      ⚠️  Warning (similarity: ${(result.analysis.similarityScore * 100).toFixed(1)}%)`);
-            }
-            else {
-                passed++;
-                console.log(`      ✅ Passed (similarity: ${(result.analysis.similarityScore * 100).toFixed(1)}%)`);
-            }
-        }
-        else {
-            failed++;
-            console.log(`      ❌ Failed: ${result.analysis.summary}`);
-        }
-    }
-    const duration = Date.now() - startTime;
-    console.log(`\n${"─".repeat(60)}`);
-    console.log(`   Results: ${passed} passed, ${failed} failed, ${warnings} warnings`);
-    console.log(`   Duration: ${(duration / 1000).toFixed(1)}s`);
-    console.log(`${"─".repeat(60)}\n`);
-    return {
-        suite,
-        results,
-        summary: {
-            total: suite.pages.length,
-            passed,
-            failed,
-            warnings,
-        },
-        duration,
-        timestamp: new Date().toISOString(),
-    };
-}
-/**
- * Format visual regression result as text report
- */
-function formatVisualRegressionReport(result) {
-    const lines = [];
-    lines.push("╔══════════════════════════════════════════════════════════════════════════════╗");
-    lines.push("║                      AI VISUAL REGRESSION REPORT                             ║");
-    lines.push("╚══════════════════════════════════════════════════════════════════════════════╝");
-    lines.push("");
-    const statusIcon = result.passed ? "✅" : "❌";
-    const statusText = result.passed ? "PASSED" : "FAILED";
-    lines.push(`${statusIcon} Status: ${statusText}`);
-    lines.push(`📊 Similarity: ${(result.analysis.similarityScore * 100).toFixed(1)}%`);
-    lines.push(`🎯 Confidence: ${(result.analysis.confidence * 100).toFixed(0)}%`);
-    lines.push(`⏱️  Duration: ${(result.duration / 1000).toFixed(2)}s`);
-    lines.push("");
-    if (result.baseline) {
-        lines.push("───────────────────────────────────────────────────────────────────────────────");
-        lines.push("📸 BASELINE INFO");
-        lines.push("───────────────────────────────────────────────────────────────────────────────");
-        lines.push(`   Name: ${result.baseline.name}`);
-        lines.push(`   URL: ${result.baseline.url}`);
-        lines.push(`   Captured: ${result.baseline.timestamp}`);
-        lines.push(`   Viewport: ${result.baseline.viewport.width}x${result.baseline.viewport.height}`);
-        if (result.baseline.device) {
-            lines.push(`   Device: ${result.baseline.device}`);
-        }
-        lines.push("");
-    }
-    lines.push("───────────────────────────────────────────────────────────────────────────────");
-    lines.push("📝 ANALYSIS SUMMARY");
-    lines.push("───────────────────────────────────────────────────────────────────────────────");
-    lines.push(`   ${result.analysis.summary}`);
-    lines.push("");
-    if (result.analysis.changes.length > 0) {
-        lines.push("───────────────────────────────────────────────────────────────────────────────");
-        lines.push("🔄 DETECTED CHANGES");
-        lines.push("───────────────────────────────────────────────────────────────────────────────");
-        for (const change of result.analysis.changes) {
-            const severityIcon = {
-                breaking: "🚨",
-                warning: "⚠️",
-                info: "ℹ️",
-                acceptable: "✓",
-            }[change.severity];
-            lines.push("");
-            lines.push(`   ${severityIcon} [${change.severity.toUpperCase()}] ${change.type}`);
-            lines.push(`      ${change.description}`);
-            lines.push(`      Reasoning: ${change.reasoning}`);
-            if (change.suggestion) {
-                lines.push(`      Suggestion: ${change.suggestion}`);
-            }
-        }
-        lines.push("");
-    }
-    lines.push("───────────────────────────────────────────────────────────────────────────────");
-    lines.push(`🚀 Production Ready: ${result.analysis.productionReady ? "YES" : "NO"}`);
-    lines.push("───────────────────────────────────────────────────────────────────────────────");
-    return lines.join("\n");
-}
-/**
- * Generate HTML report for visual regression suite
- */
-function generateVisualRegressionHtmlReport(suiteResult) {
-    const { suite, results, summary, duration, timestamp } = suiteResult;
-    return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Visual Regression Report - ${suite.name}</title>
-  <style>
-    * { box-sizing: border-box; margin: 0; padding: 0; }
-    body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; background: #0f172a; color: #e2e8f0; line-height: 1.6; }
-    .container { max-width: 1200px; margin: 0 auto; padding: 2rem; }
-    h1 { font-size: 2rem; margin-bottom: 0.5rem; }
-    h2 { font-size: 1.25rem; margin-bottom: 1rem; color: #94a3b8; }
-    .header { text-align: center; margin-bottom: 2rem; }
-    .summary { display: grid; grid-template-columns: repeat(4, 1fr); gap: 1rem; margin-bottom: 2rem; }
-    .stat { background: #1e293b; padding: 1.5rem; border-radius: 0.5rem; text-align: center; }
-    .stat-value { font-size: 2rem; font-weight: bold; }
-    .stat-label { color: #94a3b8; font-size: 0.875rem; }
-    .passed { color: #22c55e; }
-    .failed { color: #ef4444; }
-    .warning { color: #eab308; }
-    .results { display: flex; flex-direction: column; gap: 1rem; }
-    .result-card { background: #1e293b; border-radius: 0.5rem; overflow: hidden; }
-    .result-header { padding: 1rem; display: flex; justify-content: space-between; align-items: center; border-bottom: 1px solid #334155; }
-    .result-body { padding: 1rem; }
-    .badge { padding: 0.25rem 0.75rem; border-radius: 9999px; font-size: 0.75rem; font-weight: 600; }
-    .badge-pass { background: #166534; color: #22c55e; }
-    .badge-fail { background: #7f1d1d; color: #ef4444; }
-    .badge-warning { background: #713f12; color: #eab308; }
-    .similarity { font-size: 1.5rem; font-weight: bold; }
-    .changes { margin-top: 1rem; }
-    .change { padding: 0.75rem; background: #0f172a; border-radius: 0.25rem; margin-bottom: 0.5rem; }
-    .change-breaking { border-left: 3px solid #ef4444; }
-    .change-warning { border-left: 3px solid #eab308; }
-    .change-info { border-left: 3px solid #3b82f6; }
-    .change-acceptable { border-left: 3px solid #22c55e; }
-    footer { text-align: center; color: #64748b; margin-top: 2rem; padding-top: 2rem; border-top: 1px solid #334155; }
-  </style>
-</head>
-<body>
-  <div class="container">
-    <div class="header">
-      <h1>🔍 Visual Regression Report</h1>
-      <h2>${suite.name}</h2>
-      <p style="color: #64748b;">Generated: ${new Date(timestamp).toLocaleString()}</p>
-    </div>
-
-    <div class="summary">
-      <div class="stat">
-        <div class="stat-value">${summary.total}</div>
-        <div class="stat-label">Total Tests</div>
-      </div>
-      <div class="stat">
-        <div class="stat-value passed">${summary.passed}</div>
-        <div class="stat-label">Passed</div>
-      </div>
-      <div class="stat">
-        <div class="stat-value failed">${summary.failed}</div>
-        <div class="stat-label">Failed</div>
-      </div>
-      <div class="stat">
-        <div class="stat-value warning">${summary.warnings}</div>
-        <div class="stat-label">Warnings</div>
-      </div>
-    </div>
-
-    <div class="results">
-      ${results.map((result, i) => {
-        const page = suite.pages[i];
-        const statusClass = result.passed ? (result.analysis.overallStatus === "warning" ? "warning" : "passed") : "failed";
-        const badgeClass = result.passed ? (result.analysis.overallStatus === "warning" ? "badge-warning" : "badge-pass") : "badge-fail";
-        const statusText = result.passed ? (result.analysis.overallStatus === "warning" ? "WARNING" : "PASSED") : "FAILED";
-        return `
-          <div class="result-card">
-            <div class="result-header">
-              <div>
-                <strong>${page.name}</strong>
-                <div style="color: #64748b; font-size: 0.875rem;">${page.url}</div>
-              </div>
-              <div style="display: flex; align-items: center; gap: 1rem;">
-                <div class="similarity ${statusClass}">${(result.analysis.similarityScore * 100).toFixed(1)}%</div>
-                <span class="badge ${badgeClass}">${statusText}</span>
-              </div>
-            </div>
-            <div class="result-body">
-              <p>${result.analysis.summary}</p>
-              ${result.analysis.changes.length > 0 ? `
-                <div class="changes">
-                  ${result.analysis.changes.map(change => `
-                    <div class="change change-${change.severity}">
-                      <strong>[${change.severity.toUpperCase()}] ${change.type}</strong>
-                      <p>${change.description}</p>
-                      ${change.suggestion ? `<p style="color: #94a3b8;"><em>Suggestion: ${change.suggestion}</em></p>` : ""}
-                    </div>
-                  `).join("")}
-                </div>
-              ` : ""}
-            </div>
-          </div>
-        `;
-    }).join("")}
-    </div>
-
-    <footer>
-      Generated by CBrowser v7.1.0 | Suite completed in ${(duration / 1000).toFixed(1)}s
-    </footer>
-  </div>
-</body>
-</html>`;
-}
-// =========================================================================
-// Tier 7.1: Cross-Browser Visual Testing (v7.1.0)
-// =========================================================================
-/**
- * Get the path for cross-browser screenshots
- */
-function getCrossBrowserScreenshotsPath() {
-    const baseDir = process.env.CBROWSER_DATA_DIR || (0, path_1.join)(process.cwd(), ".cbrowser");
-    const dir = (0, path_1.join)(baseDir, "cross-browser");
-    if (!(0, fs_1.existsSync)(dir)) {
-        (0, fs_1.mkdirSync)(dir, { recursive: true });
-    }
-    return dir;
-}
-/**
- * Capture screenshot with a specific browser
- */
-async function captureWithBrowser(url, browserType, options = {}) {
-    const startTime = Date.now();
-    const browser = new CBrowser({
-        browser: browserType,
-        viewportWidth: options.viewport?.width || 1920,
-        viewportHeight: options.viewport?.height || 1080,
-    });
-    try {
-        await browser.launch();
-        await browser.navigate(url);
-        // Wait if specified
-        if (options.waitForSelector) {
-            const page = await browser.getPage();
-            await page.waitForSelector(options.waitForSelector, { timeout: 10000 }).catch(() => { });
-        }
-        if (options.waitBeforeCapture) {
-            await new Promise(resolve => setTimeout(resolve, options.waitBeforeCapture));
-        }
-        // Take screenshot
-        const screenshotsPath = getCrossBrowserScreenshotsPath();
-        const filename = `${browserType}-${Date.now()}.png`;
-        const screenshotPath = (0, path_1.join)(screenshotsPath, filename);
-        const page = await browser.getPage();
-        await page.screenshot({ path: screenshotPath, fullPage: false });
-        // Get user agent
-        const userAgent = await page.evaluate(() => navigator.userAgent);
-        const viewport = page.viewportSize() || { width: 1920, height: 1080 };
-        return {
-            browser: browserType,
-            screenshotPath,
-            viewport,
-            userAgent,
-            timestamp: new Date().toISOString(),
-            captureTime: Date.now() - startTime,
-        };
-    }
-    finally {
-        await browser.close();
-    }
-}
-/**
- * Run cross-browser visual test for a single URL
- */
-async function runCrossBrowserTest(url, options = {}) {
-    const startTime = Date.now();
-    const browsers = options.browsers || ["chromium", "firefox", "webkit"];
-    console.log(`\n🌐 Cross-Browser Visual Test`);
-    console.log(`   URL: ${url}`);
-    console.log(`   Browsers: ${browsers.join(", ")}\n`);
-    // Capture screenshots from each browser
-    const screenshots = [];
-    for (const browserType of browsers) {
-        console.log(`   📸 Capturing ${browserType}...`);
-        try {
-            const screenshot = await captureWithBrowser(url, browserType, options);
-            screenshots.push(screenshot);
-            console.log(`      ✅ Captured in ${screenshot.captureTime}ms`);
-        }
-        catch (error) {
-            console.log(`      ❌ Failed: ${error instanceof Error ? error.message : "Unknown error"}`);
-        }
-    }
-    if (screenshots.length < 2) {
-        return {
-            url,
-            screenshots,
-            comparisons: [],
-            overallStatus: "major_differences",
-            summary: "Could not capture enough screenshots for comparison",
-            problematicBrowsers: [],
-            duration: Date.now() - startTime,
-            timestamp: new Date().toISOString(),
-        };
-    }
-    // Compare all pairs of browsers
-    const comparisons = [];
-    let hasMinorDifferences = false;
-    let hasMajorDifferences = false;
-    const problematicBrowsers = new Set();
-    console.log(`\n   🔍 Comparing browsers...`);
-    for (let i = 0; i < screenshots.length; i++) {
-        for (let j = i + 1; j < screenshots.length; j++) {
-            const a = screenshots[i];
-            const b = screenshots[j];
-            console.log(`      ${a.browser} vs ${b.browser}...`);
-            // Use the existing AI visual analysis
-            const analysis = await analyzeVisualDifferences(a.screenshotPath, b.screenshotPath, { sensitivity: options.sensitivity || "medium" });
-            comparisons.push({
-                browserA: a.browser,
-                browserB: b.browser,
-                analysis,
-                screenshots: {
-                    a: a.screenshotPath,
-                    b: b.screenshotPath,
-                },
-            });
-            if (analysis.overallStatus === "fail") {
-                hasMajorDifferences = true;
-                problematicBrowsers.add(a.browser);
-                problematicBrowsers.add(b.browser);
-                console.log(`         ❌ Major differences (${(analysis.similarityScore * 100).toFixed(1)}%)`);
-            }
-            else if (analysis.overallStatus === "warning") {
-                hasMinorDifferences = true;
-                console.log(`         ⚠️  Minor differences (${(analysis.similarityScore * 100).toFixed(1)}%)`);
-            }
-            else {
-                console.log(`         ✅ Consistent (${(analysis.similarityScore * 100).toFixed(1)}%)`);
-            }
-        }
-    }
-    const overallStatus = hasMajorDifferences
-        ? "major_differences"
-        : hasMinorDifferences
-            ? "minor_differences"
-            : "consistent";
-    const summary = overallStatus === "consistent"
-        ? "Page renders consistently across all tested browsers"
-        : overallStatus === "minor_differences"
-            ? "Minor rendering differences detected between browsers"
-            : "Significant rendering differences detected between browsers";
-    return {
-        url,
-        screenshots,
-        comparisons,
-        overallStatus,
-        summary,
-        problematicBrowsers: Array.from(problematicBrowsers),
-        duration: Date.now() - startTime,
-        timestamp: new Date().toISOString(),
-    };
-}
-/**
- * Run cross-browser test suite
- */
-async function runCrossBrowserSuite(suite) {
-    const startTime = Date.now();
-    const results = [];
-    let consistent = 0;
-    let minorDifferences = 0;
-    let majorDifferences = 0;
-    console.log(`\n🌐 Cross-Browser Visual Test Suite: ${suite.name}`);
-    console.log(`   Testing ${suite.urls.length} URL(s)...\n`);
-    for (const url of suite.urls) {
-        const result = await runCrossBrowserTest(url, suite.options);
-        results.push(result);
-        switch (result.overallStatus) {
-            case "consistent":
-                consistent++;
-                break;
-            case "minor_differences":
-                minorDifferences++;
-                break;
-            case "major_differences":
-                majorDifferences++;
-                break;
-        }
-    }
-    return {
-        suite,
-        results,
-        summary: {
-            total: suite.urls.length,
-            consistent,
-            minorDifferences,
-            majorDifferences,
-        },
-        duration: Date.now() - startTime,
-        timestamp: new Date().toISOString(),
-    };
-}
-/**
- * Format cross-browser result as text report
- */
-function formatCrossBrowserReport(result) {
-    const lines = [];
-    lines.push("╔══════════════════════════════════════════════════════════════════════════════╗");
-    lines.push("║                    CROSS-BROWSER VISUAL TEST REPORT                         ║");
-    lines.push("╚══════════════════════════════════════════════════════════════════════════════╝");
-    lines.push("");
-    const statusIcon = {
-        consistent: "✅",
-        minor_differences: "⚠️",
-        major_differences: "❌",
-    }[result.overallStatus];
-    const statusText = {
-        consistent: "CONSISTENT",
-        minor_differences: "MINOR DIFFERENCES",
-        major_differences: "MAJOR DIFFERENCES",
-    }[result.overallStatus];
-    lines.push(`${statusIcon} Status: ${statusText}`);
-    lines.push(`🔗 URL: ${result.url}`);
-    lines.push(`⏱️  Duration: ${(result.duration / 1000).toFixed(2)}s`);
-    lines.push("");
-    lines.push("───────────────────────────────────────────────────────────────────────────────");
-    lines.push("📸 BROWSER SCREENSHOTS");
-    lines.push("───────────────────────────────────────────────────────────────────────────────");
-    for (const screenshot of result.screenshots) {
-        lines.push(`   ${screenshot.browser.toUpperCase()}`);
-        lines.push(`      Viewport: ${screenshot.viewport.width}x${screenshot.viewport.height}`);
-        lines.push(`      Capture time: ${screenshot.captureTime}ms`);
-        lines.push(`      Path: ${screenshot.screenshotPath}`);
-        lines.push("");
-    }
-    lines.push("───────────────────────────────────────────────────────────────────────────────");
-    lines.push("🔍 BROWSER COMPARISONS");
-    lines.push("───────────────────────────────────────────────────────────────────────────────");
-    for (const comparison of result.comparisons) {
-        const compIcon = {
-            pass: "✅",
-            warning: "⚠️",
-            fail: "❌",
-        }[comparison.analysis.overallStatus];
-        lines.push(`   ${comparison.browserA.toUpperCase()} vs ${comparison.browserB.toUpperCase()}: ${compIcon}`);
-        lines.push(`      Similarity: ${(comparison.analysis.similarityScore * 100).toFixed(1)}%`);
-        lines.push(`      ${comparison.analysis.summary}`);
-        if (comparison.analysis.changes.length > 0) {
-            for (const change of comparison.analysis.changes) {
-                lines.push(`      - [${change.severity.toUpperCase()}] ${change.description}`);
-            }
-        }
-        lines.push("");
-    }
-    if (result.problematicBrowsers.length > 0) {
-        lines.push("───────────────────────────────────────────────────────────────────────────────");
-        lines.push("⚠️  BROWSERS WITH ISSUES");
-        lines.push("───────────────────────────────────────────────────────────────────────────────");
-        for (const browser of result.problematicBrowsers) {
-            lines.push(`   • ${browser}`);
-        }
-        lines.push("");
-    }
-    lines.push("───────────────────────────────────────────────────────────────────────────────");
-    lines.push(`📝 SUMMARY: ${result.summary}`);
-    lines.push("───────────────────────────────────────────────────────────────────────────────");
-    return lines.join("\n");
-}
-/**
- * Generate HTML report for cross-browser test suite
- */
-function generateCrossBrowserHtmlReport(suiteResult) {
-    const { suite, results, summary, duration, timestamp } = suiteResult;
-    return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Cross-Browser Visual Report - ${suite.name}</title>
-  <style>
-    * { box-sizing: border-box; margin: 0; padding: 0; }
-    body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; background: #0f172a; color: #e2e8f0; line-height: 1.6; }
-    .container { max-width: 1400px; margin: 0 auto; padding: 2rem; }
-    h1 { font-size: 2rem; margin-bottom: 0.5rem; }
-    h2 { font-size: 1.25rem; margin-bottom: 1rem; color: #94a3b8; }
-    .header { text-align: center; margin-bottom: 2rem; }
-    .summary { display: grid; grid-template-columns: repeat(4, 1fr); gap: 1rem; margin-bottom: 2rem; }
-    .stat { background: #1e293b; padding: 1.5rem; border-radius: 0.5rem; text-align: center; }
-    .stat-value { font-size: 2rem; font-weight: bold; }
-    .stat-label { color: #94a3b8; font-size: 0.875rem; }
-    .consistent { color: #22c55e; }
-    .minor { color: #eab308; }
-    .major { color: #ef4444; }
-    .results { display: flex; flex-direction: column; gap: 2rem; }
-    .result-card { background: #1e293b; border-radius: 0.5rem; overflow: hidden; }
-    .result-header { padding: 1rem; border-bottom: 1px solid #334155; display: flex; justify-content: space-between; align-items: center; }
-    .result-body { padding: 1rem; }
-    .screenshots { display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 1rem; margin-bottom: 1rem; }
-    .screenshot-card { background: #0f172a; border-radius: 0.25rem; padding: 1rem; text-align: center; }
-    .screenshot-card img { max-width: 100%; border-radius: 0.25rem; margin-top: 0.5rem; }
-    .browser-name { font-weight: bold; text-transform: capitalize; }
-    .comparisons { margin-top: 1rem; }
-    .comparison { padding: 0.75rem; background: #0f172a; border-radius: 0.25rem; margin-bottom: 0.5rem; }
-    .comparison-header { display: flex; justify-content: space-between; align-items: center; }
-    .badge { padding: 0.25rem 0.75rem; border-radius: 9999px; font-size: 0.75rem; font-weight: 600; }
-    .badge-consistent { background: #166534; color: #22c55e; }
-    .badge-minor { background: #713f12; color: #eab308; }
-    .badge-major { background: #7f1d1d; color: #ef4444; }
-    footer { text-align: center; color: #64748b; margin-top: 2rem; padding-top: 2rem; border-top: 1px solid #334155; }
-  </style>
-</head>
-<body>
-  <div class="container">
-    <div class="header">
-      <h1>🌐 Cross-Browser Visual Report</h1>
-      <h2>${suite.name}</h2>
-      <p style="color: #64748b;">Generated: ${new Date(timestamp).toLocaleString()}</p>
-    </div>
-
-    <div class="summary">
-      <div class="stat">
-        <div class="stat-value">${summary.total}</div>
-        <div class="stat-label">URLs Tested</div>
-      </div>
-      <div class="stat">
-        <div class="stat-value consistent">${summary.consistent}</div>
-        <div class="stat-label">Consistent</div>
-      </div>
-      <div class="stat">
-        <div class="stat-value minor">${summary.minorDifferences}</div>
-        <div class="stat-label">Minor Differences</div>
-      </div>
-      <div class="stat">
-        <div class="stat-value major">${summary.majorDifferences}</div>
-        <div class="stat-label">Major Differences</div>
-      </div>
-    </div>
-
-    <div class="results">
-      ${results.map(result => {
-        const statusClass = result.overallStatus === "consistent" ? "consistent" : result.overallStatus === "minor_differences" ? "minor" : "major";
-        const badgeClass = result.overallStatus === "consistent" ? "badge-consistent" : result.overallStatus === "minor_differences" ? "badge-minor" : "badge-major";
-        const statusText = result.overallStatus === "consistent" ? "Consistent" : result.overallStatus === "minor_differences" ? "Minor Differences" : "Major Differences";
-        return `
-          <div class="result-card">
-            <div class="result-header">
-              <div>
-                <strong>${result.url}</strong>
-                <div style="color: #64748b; font-size: 0.875rem;">${result.summary}</div>
-              </div>
-              <span class="badge ${badgeClass}">${statusText}</span>
-            </div>
-            <div class="result-body">
-              <h3 style="margin-bottom: 1rem; color: #94a3b8;">Screenshots</h3>
-              <div class="screenshots">
-                ${result.screenshots.map(s => `
-                  <div class="screenshot-card">
-                    <div class="browser-name">${s.browser}</div>
-                    <div style="color: #64748b; font-size: 0.75rem;">${s.viewport.width}x${s.viewport.height} • ${s.captureTime}ms</div>
-                  </div>
-                `).join("")}
-              </div>
-
-              <h3 style="margin: 1rem 0; color: #94a3b8;">Comparisons</h3>
-              <div class="comparisons">
-                ${result.comparisons.map(c => {
-            const cBadgeClass = c.analysis.overallStatus === "pass" ? "badge-consistent" : c.analysis.overallStatus === "warning" ? "badge-minor" : "badge-major";
-            return `
-                    <div class="comparison">
-                      <div class="comparison-header">
-                        <span>${c.browserA} vs ${c.browserB}</span>
-                        <span class="badge ${cBadgeClass}">${(c.analysis.similarityScore * 100).toFixed(1)}%</span>
-                      </div>
-                      <p style="color: #94a3b8; font-size: 0.875rem; margin-top: 0.5rem;">${c.analysis.summary}</p>
-                    </div>
-                  `;
-        }).join("")}
-              </div>
-            </div>
-          </div>
-        `;
-    }).join("")}
-    </div>
-
-    <footer>
-      Generated by CBrowser v7.2.0 | Test completed in ${(duration / 1000).toFixed(1)}s
-    </footer>
-  </div>
-</body>
-</html>`;
-}
-// ============================================================================
-// Responsive Visual Testing (v7.2.0)
-// ============================================================================
-/**
- * Get viewport presets by name or return custom preset
- */
-function resolveViewports(viewports) {
-    if (!viewports || viewports.length === 0) {
-        // Default: mobile, tablet, desktop
-        return types_js_1.VIEWPORT_PRESETS.filter(v => v.name === "mobile" || v.name === "tablet" || v.name === "desktop");
-    }
-    return viewports.map(v => {
-        if (typeof v === "string") {
-            const preset = types_js_1.VIEWPORT_PRESETS.find(p => p.name === v);
-            if (!preset) {
-                throw new Error(`Unknown viewport preset: ${v}. Available: ${types_js_1.VIEWPORT_PRESETS.map(p => p.name).join(", ")}`);
-            }
-            return preset;
-        }
-        return v;
-    });
-}
-/**
- * Get the path for responsive testing screenshots
- */
-function getResponsiveScreenshotsPath() {
-    const basePath = process.cwd();
-    const screenshotsPath = (0, path_1.join)(basePath, ".cbrowser", "responsive");
-    if (!(0, fs_1.existsSync)(screenshotsPath)) {
-        (0, fs_1.mkdirSync)(screenshotsPath, { recursive: true });
-    }
-    return screenshotsPath;
-}
-/**
- * Capture screenshot at a specific viewport
- */
-async function captureAtViewport(url, viewport, options = {}) {
-    const startTime = Date.now();
-    const browser = new CBrowser({
-        viewportWidth: viewport.width,
-        viewportHeight: viewport.height,
-    });
-    try {
-        await browser.launch();
-        const page = await browser.getPage();
-        // Set mobile emulation if needed
-        if (viewport.isMobile || viewport.hasTouch) {
-            await page.emulateMedia({ reducedMotion: "reduce" });
-        }
-        await browser.navigate(url);
-        // Wait if specified
-        if (options.waitForSelector) {
-            await page.waitForSelector(options.waitForSelector, { timeout: 10000 }).catch(() => { });
-        }
-        if (options.waitBeforeCapture) {
-            await new Promise(resolve => setTimeout(resolve, options.waitBeforeCapture));
-        }
-        // Take screenshot
-        const screenshotsPath = getResponsiveScreenshotsPath();
-        const filename = `${viewport.name}-${Date.now()}.png`;
-        const screenshotPath = (0, path_1.join)(screenshotsPath, filename);
-        await page.screenshot({ path: screenshotPath, fullPage: false });
-        return {
-            viewport,
-            screenshotPath,
-            timestamp: new Date().toISOString(),
-            captureTime: Date.now() - startTime,
-        };
-    }
-    finally {
-        await browser.close();
-    }
-}
-/**
- * Analyze responsive issues from comparisons
- */
-function analyzeResponsiveIssues(comparisons, screenshots) {
-    const issues = [];
-    for (const comparison of comparisons) {
-        if (comparison.analysis.overallStatus !== "pass") {
-            const changes = comparison.analysis.changes || [];
-            for (const change of changes) {
-                let issueType = "other";
-                const desc = change.description.toLowerCase();
-                if (desc.includes("overflow") || desc.includes("scroll")) {
-                    issueType = "overflow";
-                }
-                else if (desc.includes("truncat") || desc.includes("cut off")) {
-                    issueType = "truncation";
-                }
-                else if (desc.includes("overlap")) {
-                    issueType = "overlap";
-                }
-                else if (desc.includes("hidden") || desc.includes("disappear")) {
-                    issueType = "hidden_content";
-                }
-                else if (desc.includes("text") && (desc.includes("small") || desc.includes("read"))) {
-                    issueType = "unreadable_text";
-                }
-                else if (desc.includes("layout") || desc.includes("break") || desc.includes("shift")) {
-                    issueType = "layout_break";
-                }
-                // Map VisualChange severity to ResponsiveIssue severity
-                const severityMap = {
-                    breaking: "critical",
-                    warning: "major",
-                    info: "minor",
-                    acceptable: "minor",
-                };
-                issues.push({
-                    type: issueType,
-                    severity: severityMap[change.severity] || "minor",
-                    description: change.description,
-                    affectedViewports: [comparison.viewportA.name, comparison.viewportB.name],
-                    breakpointRange: {
-                        min: Math.min(comparison.viewportA.width, comparison.viewportB.width),
-                        max: Math.max(comparison.viewportA.width, comparison.viewportB.width),
-                    },
-                });
-            }
-        }
-    }
-    return issues;
-}
-/**
- * Run responsive visual test for a single URL
- */
-async function runResponsiveTest(url, options = {}) {
-    const startTime = Date.now();
-    const viewports = resolveViewports(options.viewports);
-    console.log(`\n📱 Responsive Visual Test`);
-    console.log(`   URL: ${url}`);
-    console.log(`   Viewports: ${viewports.map(v => v.name).join(", ")}\n`);
-    // Capture screenshots at each viewport
-    const screenshots = [];
-    for (const viewport of viewports) {
-        console.log(`   📸 Capturing ${viewport.name} (${viewport.width}x${viewport.height})...`);
-        try {
-            const screenshot = await captureAtViewport(url, viewport, options);
-            screenshots.push(screenshot);
-            console.log(`      ✅ Captured in ${screenshot.captureTime}ms`);
-        }
-        catch (error) {
-            console.log(`      ❌ Failed: ${error instanceof Error ? error.message : "Unknown error"}`);
-        }
-    }
-    if (screenshots.length < 2) {
-        return {
-            url,
-            screenshots,
-            comparisons: [],
-            issues: [],
-            overallStatus: "major_issues",
-            summary: "Could not capture enough screenshots for comparison",
-            problematicViewports: [],
-            duration: Date.now() - startTime,
-            timestamp: new Date().toISOString(),
-        };
-    }
-    // Compare adjacent viewport sizes (small to large)
-    const sortedScreenshots = [...screenshots].sort((a, b) => a.viewport.width - b.viewport.width);
-    const comparisons = [];
-    let hasMinorIssues = false;
-    let hasMajorIssues = false;
-    const problematicViewports = new Set();
-    console.log(`\n   🔍 Comparing viewports...`);
-    for (let i = 0; i < sortedScreenshots.length - 1; i++) {
-        const a = sortedScreenshots[i];
-        const b = sortedScreenshots[i + 1];
-        console.log(`      ${a.viewport.name} → ${b.viewport.name}...`);
-        const analysis = await analyzeVisualDifferences(a.screenshotPath, b.screenshotPath, { sensitivity: options.sensitivity || "medium" });
-        comparisons.push({
-            viewportA: a.viewport,
-            viewportB: b.viewport,
-            analysis,
-            screenshots: {
-                a: a.screenshotPath,
-                b: b.screenshotPath,
-            },
-        });
-        if (analysis.overallStatus === "fail") {
-            hasMajorIssues = true;
-            problematicViewports.add(a.viewport.name);
-            problematicViewports.add(b.viewport.name);
-            console.log(`         ❌ Major issues (${(analysis.similarityScore * 100).toFixed(1)}%)`);
-        }
-        else if (analysis.overallStatus === "warning") {
-            hasMinorIssues = true;
-            console.log(`         ⚠️  Minor issues (${(analysis.similarityScore * 100).toFixed(1)}%)`);
-        }
-        else {
-            console.log(`         ✅ Responsive (${(analysis.similarityScore * 100).toFixed(1)}%)`);
-        }
-    }
-    // Analyze issues
-    const issues = analyzeResponsiveIssues(comparisons, screenshots);
-    const overallStatus = hasMajorIssues
-        ? "major_issues"
-        : hasMinorIssues
-            ? "minor_issues"
-            : "responsive";
-    const summary = overallStatus === "responsive"
-        ? "Page is fully responsive across all tested viewports"
-        : overallStatus === "minor_issues"
-            ? "Minor responsive issues detected"
-            : "Significant responsive issues detected";
-    return {
-        url,
-        screenshots,
-        comparisons,
-        issues,
-        overallStatus,
-        summary,
-        problematicViewports: Array.from(problematicViewports),
-        duration: Date.now() - startTime,
-        timestamp: new Date().toISOString(),
-    };
-}
-/**
- * Run responsive test suite for multiple URLs
- */
-async function runResponsiveSuite(suite) {
-    const startTime = Date.now();
-    const results = [];
-    console.log(`\n📱 Responsive Test Suite: ${suite.name}`);
-    console.log(`   Testing ${suite.urls.length} URLs\n`);
-    for (const url of suite.urls) {
-        const result = await runResponsiveTest(url, suite.options);
-        results.push(result);
-    }
-    // Aggregate common issues
-    const issueMap = new Map();
-    for (const result of results) {
-        for (const issue of result.issues) {
-            const key = `${issue.type}-${issue.description}`;
-            if (issueMap.has(key)) {
-                const existing = issueMap.get(key);
-                existing.affectedViewports = [...new Set([...existing.affectedViewports, ...issue.affectedViewports])];
-            }
-            else {
-                issueMap.set(key, { ...issue });
-            }
-        }
-    }
-    return {
-        suite,
-        results,
-        summary: {
-            total: results.length,
-            responsive: results.filter(r => r.overallStatus === "responsive").length,
-            minorIssues: results.filter(r => r.overallStatus === "minor_issues").length,
-            majorIssues: results.filter(r => r.overallStatus === "major_issues").length,
-            totalIssues: results.reduce((sum, r) => sum + r.issues.length, 0),
-        },
-        commonIssues: Array.from(issueMap.values()),
-        duration: Date.now() - startTime,
-        timestamp: new Date().toISOString(),
-    };
-}
-/**
- * Format responsive test result as console report
- */
-function formatResponsiveReport(result) {
-    const lines = [];
-    const duration = (result.duration / 1000).toFixed(2);
-    lines.push(`╔${"═".repeat(78)}╗`);
-    lines.push(`║${" ".repeat(20)}RESPONSIVE VISUAL TEST REPORT${" ".repeat(29)}║`);
-    lines.push(`╚${"═".repeat(78)}╝`);
-    lines.push("");
-    const statusIcon = result.overallStatus === "responsive" ? "✅" : result.overallStatus === "minor_issues" ? "⚠️" : "❌";
-    const statusText = result.overallStatus.toUpperCase().replace("_", " ");
-    lines.push(`${statusIcon} Status: ${statusText}`);
-    lines.push(`🔗 URL: ${result.url}`);
-    lines.push(`⏱️  Duration: ${duration}s`);
-    lines.push("");
-    lines.push("─".repeat(79));
-    lines.push("📸 VIEWPORT SCREENSHOTS");
-    lines.push("─".repeat(79));
-    for (const screenshot of result.screenshots) {
-        const v = screenshot.viewport;
-        lines.push(`   ${v.name.toUpperCase()} (${v.deviceType})`);
-        lines.push(`      Dimensions: ${v.width}x${v.height}`);
-        if (v.deviceName)
-            lines.push(`      Device: ${v.deviceName}`);
-        lines.push(`      Capture time: ${screenshot.captureTime}ms`);
-        lines.push(`      Path: ${screenshot.screenshotPath}`);
-        lines.push("");
-    }
-    lines.push("─".repeat(79));
-    lines.push("🔍 VIEWPORT COMPARISONS");
-    lines.push("─".repeat(79));
-    for (const comparison of result.comparisons) {
-        const icon = comparison.analysis.overallStatus === "pass" ? "✅" : comparison.analysis.overallStatus === "warning" ? "⚠️" : "❌";
-        lines.push(`   ${comparison.viewportA.name} → ${comparison.viewportB.name}: ${icon}`);
-        lines.push(`      Similarity: ${(comparison.analysis.similarityScore * 100).toFixed(1)}%`);
-        lines.push(`      ${comparison.analysis.summary}`);
-        lines.push("");
-    }
-    if (result.issues.length > 0) {
-        lines.push("─".repeat(79));
-        lines.push("⚠️  RESPONSIVE ISSUES DETECTED");
-        lines.push("─".repeat(79));
-        for (const issue of result.issues) {
-            const severityIcon = issue.severity === "critical" ? "🔴" : issue.severity === "major" ? "🟠" : "🟡";
-            lines.push(`   ${severityIcon} [${issue.type.toUpperCase()}] ${issue.description}`);
-            lines.push(`      Affected: ${issue.affectedViewports.join(", ")}`);
-            if (issue.breakpointRange) {
-                lines.push(`      Breakpoint range: ${issue.breakpointRange.min}px - ${issue.breakpointRange.max}px`);
-            }
-            lines.push("");
-        }
-    }
-    lines.push("─".repeat(79));
-    lines.push(`📝 SUMMARY: ${result.summary}`);
-    lines.push("─".repeat(79));
-    return lines.join("\n");
-}
-/**
- * Generate HTML report for responsive test suite
- */
-function generateResponsiveHtmlReport(suiteResult) {
-    const { suite, results, summary, duration } = suiteResult;
-    return `<!DOCTYPE html>
-<html>
-<head>
-  <title>Responsive Test Report - ${suite.name}</title>
-  <style>
-    * { margin: 0; padding: 0; box-sizing: border-box; }
-    body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; background: #0f172a; color: #e2e8f0; line-height: 1.6; }
-    .container { max-width: 1200px; margin: 0 auto; padding: 2rem; }
-    header { text-align: center; margin-bottom: 2rem; }
-    h1 { font-size: 2rem; margin-bottom: 0.5rem; background: linear-gradient(135deg, #8b5cf6, #06b6d4); -webkit-background-clip: text; -webkit-text-fill-color: transparent; }
-    .subtitle { color: #94a3b8; }
-    .summary-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); gap: 1rem; margin-bottom: 2rem; }
-    .summary-card { background: #1e293b; border-radius: 0.5rem; padding: 1.5rem; text-align: center; }
-    .summary-value { font-size: 2rem; font-weight: bold; }
-    .summary-label { color: #94a3b8; font-size: 0.875rem; }
-    .responsive { color: #22c55e; }
-    .minor { color: #f59e0b; }
-    .major { color: #ef4444; }
-    .result-card { background: #1e293b; border-radius: 0.5rem; padding: 1.5rem; margin-bottom: 1rem; }
-    .result-header { display: flex; justify-content: space-between; align-items: center; margin-bottom: 1rem; }
-    .badge { padding: 0.25rem 0.75rem; border-radius: 9999px; font-size: 0.75rem; font-weight: 600; }
-    .badge-responsive { background: rgba(34, 197, 94, 0.2); color: #22c55e; }
-    .badge-minor { background: rgba(245, 158, 11, 0.2); color: #f59e0b; }
-    .badge-major { background: rgba(239, 68, 68, 0.2); color: #ef4444; }
-    .viewport-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 0.5rem; margin-top: 1rem; }
-    .viewport-item { background: #0f172a; padding: 0.75rem; border-radius: 0.375rem; font-size: 0.875rem; }
-    .viewport-name { font-weight: 600; color: #8b5cf6; }
-    .issue { background: #0f172a; padding: 0.75rem; border-radius: 0.375rem; margin-top: 0.5rem; border-left: 3px solid; }
-    .issue-critical { border-color: #ef4444; }
-    .issue-major { border-color: #f59e0b; }
-    .issue-minor { border-color: #22c55e; }
-    footer { text-align: center; color: #64748b; padding: 2rem 0; font-size: 0.875rem; }
-  </style>
-</head>
-<body>
-  <div class="container">
-    <header>
-      <h1>📱 Responsive Test Report</h1>
-      <p class="subtitle">${suite.name}</p>
-    </header>
-
-    <div class="summary-grid">
-      <div class="summary-card">
-        <div class="summary-value">${summary.total}</div>
-        <div class="summary-label">Total URLs</div>
-      </div>
-      <div class="summary-card">
-        <div class="summary-value responsive">${summary.responsive}</div>
-        <div class="summary-label">Fully Responsive</div>
-      </div>
-      <div class="summary-card">
-        <div class="summary-value minor">${summary.minorIssues}</div>
-        <div class="summary-label">Minor Issues</div>
-      </div>
-      <div class="summary-card">
-        <div class="summary-value major">${summary.majorIssues}</div>
-        <div class="summary-label">Major Issues</div>
-      </div>
-      <div class="summary-card">
-        <div class="summary-value">${summary.totalIssues}</div>
-        <div class="summary-label">Total Issues</div>
-      </div>
-    </div>
-
-    <div class="results">
-      ${results.map(result => {
-        const badgeClass = result.overallStatus === "responsive" ? "badge-responsive" : result.overallStatus === "minor_issues" ? "badge-minor" : "badge-major";
-        return `
-          <div class="result-card">
-            <div class="result-header">
-              <div>
-                <strong>${result.url}</strong>
-                <p style="color: #94a3b8; font-size: 0.875rem;">${result.summary}</p>
-              </div>
-              <span class="badge ${badgeClass}">${result.overallStatus.replace("_", " ").toUpperCase()}</span>
-            </div>
-            <div class="viewport-grid">
-              ${result.screenshots.map(s => `
-                <div class="viewport-item">
-                  <span class="viewport-name">${s.viewport.name}</span>
-                  <span style="color: #94a3b8;"> ${s.viewport.width}×${s.viewport.height}</span>
-                </div>
-              `).join("")}
-            </div>
-            ${result.issues.length > 0 ? `
-              <div style="margin-top: 1rem;">
-                <strong style="color: #f59e0b;">Issues:</strong>
-                ${result.issues.map(issue => `
-                  <div class="issue issue-${issue.severity}">
-                    <strong>[${issue.type.toUpperCase()}]</strong> ${issue.description}
-                    <br><span style="color: #94a3b8; font-size: 0.75rem;">Affected: ${issue.affectedViewports.join(", ")}</span>
-                  </div>
-                `).join("")}
-              </div>
-            ` : ""}
-          </div>
-        `;
-    }).join("")}
-    </div>
-
-    <footer>
-      Generated by CBrowser v7.2.0 | Test completed in ${(duration / 1000).toFixed(1)}s
-    </footer>
-  </div>
-</body>
-</html>`;
-}
-/**
- * List available viewport presets
- */
-function listViewportPresets() {
-    return types_js_1.VIEWPORT_PRESETS;
-}
 //# sourceMappingURL=browser.js.map