qa360 2.2.20 → 2.3.1

package/dist/core/adapters/playwright-ui.js

@@ -0,0 +1,2050 @@
+/**
+ * QA360 Playwright UI Adapter (Extended)
+ * Complete UI E2E testing with all Playwright actions
+ *
+ * Playwright++ Features:
+ * - Video recording (always/retain-on-fail/never)
+ * - Automatic screenshots (before/after steps, on error)
+ * - Trace capture for debugging
+ * - Artifacts management with CAS
+ * - HTML report generation
+ */
+import { chromium, firefox, webkit } from '@playwright/test';
+import { SecurityRedactor } from '../security/redactor.js';
+import { createAssertionsEngine } from '../assertions/index.js';
+import { UIArtifactsManager } from '../artifacts/index.js';
+import { HTMLReporter } from '../reporting/index.js';
+import { SiteProfiler } from '../crawler/site-profiler.js';
+import { IntelligentSelectorGenerator } from '../crawler/intelligent-selector-generator.js';
+import { ConsentHandler } from '../crawler/consent-handler.js';
+import { mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+export class PlaywrightUiAdapter {
+    browser;
+    context;
+    page;
+    redactor;
+    auth;
+    assertions;
+    // Storage for artifacts
+    artifactDir;
+    videoDir;
+    traceDir;
+    // Playwright++: Artifacts manager
+    artifactsManager;
+    failureCount = 0;
+    currentTestId;
+    allScreenshots = [];
+    allVideos = [];
+    allTraces = [];
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // DIALOG & POPUP HANDLING (Part 2 & 3)
+    // ═══════════════════════════════════════════════════════════════════════════════
+    lastDialog;
+    dialogBehavior = 'accept';
+    dialogPromptValue = 'test-value';
+    openPages = [];
+    currentPageIndex = 0;
+    globalDialogHandler; // Reference to global handler for temporary removal
+    pendingDialogHandler; // Stores pending expectDialog handler for next actions
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // INTELLIGENT CRAWLER (SiteProfiler, SelectorGenerator, ConsentHandler)
+    // ═══════════════════════════════════════════════════════════════════════════════
+    siteProfiler;
+    siteAnalysis;
+    siteProfile;
+    selectorGenerator;
+    consentHandler = ConsentHandler;
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // IFRAME SUPPORT (Part 5)
+    // ═══════════════════════════════════════════════════════════════════════════════
+    currentFrame;
+    constructor() {
+        this.redactor = SecurityRedactor.forLogs();
+        this.artifactDir = '.qa360/artifacts/ui';
+        this.videoDir = `${this.artifactDir}/videos`;
+        this.traceDir = `${this.artifactDir}/traces`;
+        // Initialize intelligent crawler components
+        this.siteProfiler = new SiteProfiler();
+        this.selectorGenerator = new IntelligentSelectorGenerator();
+    }
+    /**
+     * Set authentication credentials for requests
+     */
+    setAuth(credentials) {
+        this.auth = credentials;
+    }
+    /**
+     * Execute UI smoke tests with accessibility
+     * Playwright++: Supports artifacts, screenshots, video, trace, HTML reporting
+     */
+    async runSmokeTests(config) {
+        const startTime = Date.now();
+        const outputDir = config.artifacts?.outputDir || this.artifactDir;
+        // Ensure output directories exist
+        for (const dir of [outputDir, this.videoDir, this.traceDir]) {
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+        }
+        // Initialize artifacts manager if Playwright++ features enabled
+        const artifactsEnabled = config.artifacts?.screenshots !== 'never' ||
+            config.artifacts?.video !== 'never' ||
+            config.artifacts?.trace !== 'never';
+        if (artifactsEnabled) {
+            this.artifactsManager = new UIArtifactsManager(outputDir, '.qa360/runs/cas');
+        }
+        try {
+            // Store auth config
+            this.auth = config.auth;
+            this.failureCount = 0;
+            this.allScreenshots = [];
+            this.allVideos = [];
+            this.allTraces = [];
+            await this.setupBrowser(config);
+            const results = [];
+            const pages = config.target.pages || [config.target.baseUrl];
+            console.log(`🖥️  Running UI smoke tests (${pages.length} pages)`);
+            // Optional login first
+            if (config.login) {
+                await this.performLogin(config.login);
+            }
+            for (const pageUrl of pages) {
+                // Start artifacts for this test
+                this.currentTestId = `smoke-${this.failureCount}`;
+                this.artifactsManager?.startTest(this.currentTestId);
+                // Check if page has actions (object format) or is a simple URL string
+                let testResult;
+                if (typeof pageUrl === 'string') {
+                    testResult = await this.testPage(pageUrl, config);
+                }
+                else if (pageUrl && typeof pageUrl === 'object' && 'url' in pageUrl) {
+                    const pageObj = pageUrl;
+                    if (pageObj.actions && Array.isArray(pageObj.actions) && pageObj.actions.length > 0) {
+                        // Page with actions (journey format)
+                        testResult = await this.testPageWithActions(pageObj.url, pageObj.actions, config);
+                    }
+                    else {
+                        // Object format but no actions
+                        testResult = await this.testPage(pageObj.url, config);
+                    }
+                }
+                else {
+                    // Fallback
+                    testResult = await this.testPage(String(pageUrl), config);
+                }
+                results.push(testResult);
+                const displayUrl = typeof pageUrl === 'string' ? pageUrl : pageUrl.url;
+                if (testResult.success) {
+                    const a11yInfo = testResult.accessibility ?
+                        ` | A11y: ${testResult.accessibility.score}% (${testResult.accessibility.violations.length} issues)` : '';
+                    console.log(`  ✅ ${displayUrl} -> ${testResult.loadTime}ms${a11yInfo}`);
+                }
+                else {
+                    this.failureCount++;
+                    console.log(`  ❌ ${displayUrl} -> ${testResult.error}`);
+                    // Check bail condition
+                    if (config.bail && this.failureCount >= config.bail) {
+                        console.log(`  🛑 Bailing after ${this.failureCount} failures`);
+                        break;
+                    }
+                }
+                this.artifactsManager?.endTest();
+            }
+            // Run E2E tests if defined
+            let e2eResults = [];
+            if (config.target.uiTests && config.target.uiTests.length > 0) {
+                console.log(`🧪 Running E2E tests (${config.target.uiTests.length} tests)`);
+                for (const test of config.target.uiTests) {
+                    if (test.enabled !== false) {
+                        // Start artifacts for this test
+                        this.currentTestId = `e2e-${test.name}`;
+                        this.artifactsManager?.startTest(this.currentTestId);
+                        const result = await this.runE2eTest(test, config);
+                        e2eResults.push(result);
+                        const status = result.success ? '✅' : '❌';
+                        console.log(`  ${status} ${test.name} (${result.duration}ms)`);
+                        if (!result.success) {
+                            console.log(`      Error: ${result.error}`);
+                            this.failureCount++;
+                            // Check bail condition
+                            if (config.bail && this.failureCount >= config.bail) {
+                                console.log(`  🛑 Bailing after ${this.failureCount} failures`);
+                                this.artifactsManager?.endTest();
+                                break;
+                            }
+                        }
+                        this.artifactsManager?.endTest();
+                    }
+                }
+            }
+            const summary = this.calculateSummary(results, e2eResults);
+            const junit = this.generateJUnit(results, e2eResults);
+            // Playwright++: Generate HTML report if requested
+            if (config.htmlReport) {
+                await this.generateHtmlReport(config, results, e2eResults, summary);
+            }
+            return {
+                success: summary.failed === 0,
+                results,
+                e2eResults,
+                summary,
+                junit
+            };
+        }
+        finally {
+            await this.cleanup(config);
+        }
+    }
+    /**
+     * Run a single E2E test
+     * Playwright++: Takes before/after screenshots, captures artifacts on failure
+     */
+    async runE2eTest(test, config) {
+        const startTime = Date.now();
+        const steps = [];
+        const screenshotMode = config.artifacts?.screenshots || 'never';
+        try {
+            // Determine starting URL
+            const startUrl = test.url || `${config.target.baseUrl.replace(/\/$/, '')}${test.path || ''}`;
+            // Navigate to start URL
+            console.log(`    📍 Navigate to: ${startUrl}`);
+            await this.page.goto(startUrl, { timeout: test.timeout || config.timeout || 30000 });
+            // Take initial screenshot
+            if (screenshotMode === 'always') {
+                await this.artifactsManager?.takeScreenshot(this.page, {}, {
+                    testId: this.currentTestId || 'unknown',
+                    type: 'screenshot',
+                    tags: ['initial'],
+                });
+            }
+            // Initialize assertions engine
+            this.assertions = createAssertionsEngine(this.page);
+            // Execute each step
+            for (let i = 0; i < test.steps.length; i++) {
+                const step = test.steps[i];
+                // Take before screenshot if configured
+                if (screenshotMode === 'always') {
+                    await this.artifactsManager?.takeBeforeScreenshot(this.page, step.action || 'step', i);
+                }
+                const stepResult = await this.executeStep(step, config);
+                steps.push(stepResult);
+                // Take after screenshot (always on failure, or always if configured)
+                if (screenshotMode === 'always' || (screenshotMode === 'only-on-failure' && !stepResult.success)) {
+                    await this.artifactsManager?.takeAfterScreenshot(this.page, step.action || 'step', i, stepResult.success);
+                }
+                if (!stepResult.success) {
+                    // Take error screenshot
+                    await this.artifactsManager?.takeErrorScreenshot(this.page, new Error(stepResult.error || 'Step failed'), step.action);
+                    return {
+                        test,
+                        success: false,
+                        steps,
+                        duration: Date.now() - startTime,
+                        error: stepResult.error,
+                    };
+                }
+            }
+            return {
+                test,
+                success: true,
+                steps,
+                duration: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            // Take error screenshot
+            await this.artifactsManager?.takeErrorScreenshot(this.page, error);
+            return {
+                test,
+                success: false,
+                steps,
+                duration: Date.now() - startTime,
+                error: this.redactor.redact(error instanceof Error ? error.message : 'Unknown error'),
+            };
+        }
+    }
+    /**
+     * Execute a single UI test step
+     * Playwright++: Enhanced error handling with artifacts
+     */
+    async executeStep(step, config) {
+        const startTime = Date.now();
+        let screenshot;
+        try {
+            const { action, selector, value, options = {}, expected } = step;
+            const opts = { timeout: 10000, ...options };
+            switch (action) {
+                case 'navigate':
+                    await this.page.goto(value, opts);
+                    break;
+                case 'click':
+                    // If there's a pending dialog handler, the click should trigger it
+                    if (this.pendingDialogHandler && this.pendingDialogHandler.promise) {
+                        // Do the click and wait for the dialog to be handled
+                        await Promise.all([
+                            this.pendingDialogHandler.promise,
+                            this.page.click(selector, opts)
+                        ]);
+                        // Clear the pending handler after dialog is handled
+                        this.pendingDialogHandler = undefined;
+                    }
+                    else {
+                        await this.page.click(selector, opts);
+                    }
+                    break;
+                case 'dblClick':
+                    await this.page.dblclick(selector, opts);
+                    break;
+                case 'rightClick':
+                    await this.page.click(selector, { ...opts, button: 'right' });
+                    break;
+                case 'hover':
+                    await this.page.hover(selector, opts);
+                    break;
+                case 'focus':
+                    await this.page.focus(selector, opts);
+                    break;
+                case 'fill':
+                    await this.page.fill(selector, value, opts);
+                    break;
+                case 'type':
+                    await this.page.type(selector, value, opts);
+                    break;
+                case 'clear':
+                    await this.page.fill(selector, '', opts);
+                    break;
+                case 'select':
+                    if (value !== undefined) {
+                        await this.page.selectOption(selector, value, opts);
+                    }
+                    break;
+                case 'check':
+                    await this.page.check(selector, opts);
+                    break;
+                case 'uncheck':
+                    await this.page.uncheck(selector, opts);
+                    break;
+                case 'upload':
+                    if (value !== undefined) {
+                        await this.page.setInputFiles(selector, value, opts);
+                    }
+                    break;
+                case 'press': {
+                    const delay = options?.delay;
+                    const pressOpts = delay !== undefined ? { delay } : {};
+                    await this.page.keyboard.press(value, pressOpts);
+                    break;
+                }
+                case 'waitFor':
+                case 'waitForSelector':
+                    await this.page.waitForSelector(selector, opts);
+                    break;
+                case 'waitForNavigation':
+                    await this.page.waitForNavigation(opts);
+                    break;
+                case 'waitForTimeout':
+                    await this.page.waitForTimeout(parseInt(value, 10));
+                    break;
+                case 'scroll':
+                    if (selector) {
+                        await this.page.evaluate((sel) => {
+                            const el = document.querySelector(sel);
+                            if (el)
+                                el.scrollIntoView({ behavior: 'smooth', block: 'center' });
+                        }, selector);
+                    }
+                    break;
+                case 'dragAndDrop':
+                    await this.page.dragAndDrop(selector, value, opts);
+                    break;
+                case 'tap':
+                    await this.page.tap(selector, opts);
+                    break;
+                // ═══════════════════════════════════════════════════════════════════════════════
+                // PART 2: DIALOG ACTIONS
+                // ═══════════════════════════════════════════════════════════════════════════════
+                case 'expectDialog':
+                    // Set up expectation for a dialog that will be triggered by a subsequent action
+                    // This action completes immediately; the next action (click, etc.) will wait for the dialog
+                    const expectedDialogType = value || 'alert';
+                    const dialogTimeout = options?.timeout || 10000;
+                    const shouldDismiss = options?.dismiss === true;
+                    console.log(`  🔔 Expecting ${expectedDialogType} dialog on next action...`);
+                    // Temporarily remove global dialog handler to prevent interference
+                    if (this.globalDialogHandler) {
+                        this.page.off('dialog', this.globalDialogHandler);
+                    }
+                    // Variables to store handler and timeout for cleanup
+                    let dialogHandler;
+                    let timeoutId;
+                    // Create a promise that will resolve when the dialog appears
+                    const dialogPromise = new Promise((resolve, reject) => {
+                        timeoutId = setTimeout(() => {
+                            // Clean up on timeout
+                            if (dialogHandler)
+                                this.page.off('dialog', dialogHandler);
+                            this.pendingDialogHandler = undefined;
+                            // Re-attach global handler
+                            if (this.globalDialogHandler) {
+                                this.page.on('dialog', this.globalDialogHandler);
+                            }
+                            reject(new Error(`No ${expectedDialogType} dialog within ${dialogTimeout}ms`));
+                        }, dialogTimeout);
+                        dialogHandler = async (dialog) => {
+                            if (dialog.type() === expectedDialogType) {
+                                clearTimeout(timeoutId);
+                                // Remove this handler after it's been triggered
+                                this.page.off('dialog', dialogHandler);
+                                if (shouldDismiss) {
+                                    await dialog.dismiss();
+                                    console.log(`  🔔 Dialog [${expectedDialogType}] dismissed`);
+                                }
+                                else if (expectedDialogType === 'prompt' && options?.promptValue) {
+                                    await dialog.accept(options.promptValue);
+                                    console.log(`  🔔 Dialog [${expectedDialogType}] accepted with value`);
+                                }
+                                else {
+                                    await dialog.accept();
+                                    console.log(`  🔔 Dialog [${expectedDialogType}] accepted`);
+                                }
+                                // Re-attach global dialog handler after dialog is handled
+                                if (this.globalDialogHandler) {
+                                    this.page.on('dialog', this.globalDialogHandler);
+                                }
+                                resolve();
+                            }
+                        };
+                        // Attach the dialog handler
+                        this.page.on('dialog', dialogHandler);
+                    });
+                    // Store the pending handler and promise so subsequent actions can wait for it
+                    this.pendingDialogHandler = {
+                        expectedType: expectedDialogType,
+                        promise: dialogPromise,
+                        handler: dialogHandler,
+                        timeoutId
+                    };
+                    break;
+                // ═══════════════════════════════════════════════════════════════════════════════
+                // PART 3: POPUP/TAB ACTIONS
+                // ═══════════════════════════════════════════════════════════════════════════════
+                case 'clickAndWaitForPopup': {
+                    const [popup] = await Promise.all([
+                        this.context.waitForEvent('page', { timeout: options?.timeout || 30000 }),
+                        this.page.click(selector, opts),
+                    ]);
+                    await popup.waitForLoadState('domcontentloaded');
+                    this.openPages.push(popup);
+                    this.currentPageIndex = this.openPages.length - 1;
+                    this.page = popup;
+                    console.log(`  📑 Switched to new tab: ${popup.url().slice(0, 50)}...`);
+                    break;
+                }
+                case 'switchToTab': {
+                    const tabIndex = parseInt(value, 10);
+                    if (tabIndex >= 0 && tabIndex < this.openPages.length) {
+                        this.page = this.openPages[tabIndex];
+                        this.currentPageIndex = tabIndex;
+                        await this.page.bringToFront();
+                        console.log(`  📑 Switched to tab ${tabIndex}: ${this.page.url().slice(0, 50)}...`);
+                    }
+                    else {
+                        throw new Error(`Tab index ${tabIndex} out of range (0-${this.openPages.length - 1})`);
+                    }
+                    break;
+                }
+                case 'closeTab': {
+                    const closeIndex = value !== undefined ? parseInt(value, 10) : this.openPages.length - 1;
+                    if (closeIndex > 0) { // Never close first tab
+                        await this.openPages[closeIndex].close();
+                        this.openPages.splice(closeIndex, 1);
+                        this.currentPageIndex = this.openPages.length - 1;
+                        this.page = this.openPages[this.currentPageIndex];
+                        await this.page.bringToFront();
+                        console.log(`  📑 Closed tab ${closeIndex}, switched to tab ${this.currentPageIndex}`);
+                    }
+                    else if (closeIndex === 0 && this.openPages.length > 1) {
+                        throw new Error('Cannot close the first tab when multiple tabs are open');
+                    }
+                    break;
+                }
+                case 'waitForNewTab': {
+                    const newTab = await this.context.waitForEvent('page', { timeout: options?.timeout || 30000 });
+                    await newTab.waitForLoadState('domcontentloaded');
+                    this.openPages.push(newTab);
+                    if (options?.switchTo !== false) {
+                        this.currentPageIndex = this.openPages.length - 1;
+                        this.page = newTab;
+                        console.log(`  📑 Switched to new tab: ${newTab.url().slice(0, 50)}...`);
+                    }
+                    else {
+                        console.log(`  📑 New tab detected (not switched): ${newTab.url().slice(0, 50)}...`);
+                    }
+                    break;
+                }
+                // ═══════════════════════════════════════════════════════════════════════════════
+                // PART 5: IFRAME ACTIONS
+                // ═══════════════════════════════════════════════════════════════════════════════
+                case 'switchToFrame': {
+                    if (!selector) {
+                        throw new Error('switchToFrame requires a selector');
+                    }
+                    // Wait for iframe element and get its content frame
+                    const frameElement = await this.page.waitForSelector(selector, opts);
+                    if (!frameElement) {
+                        throw new Error(`Frame element not found: ${selector}`);
+                    }
+                    const contentFrame = await frameElement.contentFrame();
+                    if (!contentFrame) {
+                        throw new Error(`Frame has no content frame: ${selector}`);
+                    }
+                    // Store the current frame for subsequent operations
+                    this.currentFrame = contentFrame;
+                    console.log(`  🔲 Switched to frame: ${selector}`);
+                    break;
+                }
+                case 'switchToMainFrame':
+                    // Return to main page context
+                    this.currentFrame = undefined;
+                    console.log(`  🔲 Switched to main frame`);
+                    break;
+                case 'waitForFrame': {
+                    if (!selector) {
+                        throw new Error('waitForFrame requires a selector');
+                    }
+                    const frameElement = await this.page.waitForSelector(selector, opts);
+                    if (!frameElement) {
+                        throw new Error(`Frame element not found within timeout: ${selector}`);
+                    }
+                    const contentFrame = await frameElement.contentFrame();
+                    if (!contentFrame) {
+                        throw new Error(`Frame has no content: ${selector}`);
+                    }
+                    console.log(`  🔲 Frame detected: ${selector}`);
+                    break;
+                }
+                case 'clickInFrame': {
+                    if (!selector) {
+                        throw new Error('clickInFrame requires a selector');
+                    }
+                    const frameSelector = options?.frame;
+                    if (!frameSelector) {
+                        throw new Error('clickInFrame requires frame option');
+                    }
+                    const frameElement = await this.page.waitForSelector(frameSelector, opts);
+                    if (!frameElement) {
+                        throw new Error(`Frame element not found: ${frameSelector}`);
+                    }
+                    const contentFrame = await frameElement.contentFrame();
+                    if (!contentFrame) {
+                        throw new Error(`Frame has no content: ${frameSelector}`);
+                    }
+                    await contentFrame.click(selector, opts);
+                    console.log(`  🔲 Clicked in frame: ${frameSelector} > ${selector}`);
+                    break;
+                }
+                case 'fillInFrame': {
+                    if (!selector) {
+                        throw new Error('fillInFrame requires a selector');
+                    }
+                    const frameSelector = options?.frame;
+                    if (!frameSelector) {
+                        throw new Error('fillInFrame requires frame option');
+                    }
+                    const frameElement = await this.page.waitForSelector(frameSelector, opts);
+                    if (!frameElement) {
+                        throw new Error(`Frame element not found: ${frameSelector}`);
+                    }
+                    const contentFrame = await frameElement.contentFrame();
+                    if (!contentFrame) {
+                        throw new Error(`Frame has no content: ${frameSelector}`);
+                    }
+                    await contentFrame.fill(selector, value, opts);
+                    console.log(`  🔲 Filled in frame: ${frameSelector} > ${selector} = "${value}"`);
+                    break;
+                }
+                // ═══════════════════════════════════════════════════════════════════════════════
+                // PART 6: SHADOW DOM ACTIONS
+                // ═══════════════════════════════════════════════════════════════════════════════
+                case 'clickShadow': {
+                    if (!selector) {
+                        throw new Error('clickShadow requires a selector');
+                    }
+                    // Use pierce selector to penetrate shadow DOM
+                    const pierceSelector = `pierce/${selector}`;
+                    await this.page.click(pierceSelector, opts);
+                    console.log(`  🌑 Clicked shadow element: ${selector}`);
+                    break;
+                }
+                case 'fillShadow': {
+                    if (!selector) {
+                        throw new Error('fillShadow requires a selector');
+                    }
+                    const pierceSelector = `pierce/${selector}`;
+                    await this.page.fill(pierceSelector, value, opts);
+                    console.log(`  🌑 Filled shadow element: ${selector}`);
+                    break;
+                }
+                case 'waitForShadow': {
+                    if (!selector) {
+                        throw new Error('waitForShadow requires a selector');
+                    }
+                    const pierceSelector = `pierce/${selector}`;
+                    await this.page.waitForSelector(pierceSelector, opts);
+                    console.log(`  🌑 Shadow element detected: ${selector}`);
+                    break;
+                }
+                // ═══════════════════════════════════════════════════════════════════════════════
+                // PART 7: DOWNLOAD ACTIONS
+                // ═══════════════════════════════════════════════════════════════════════════════
+                case 'clickAndDownload': {
+                    if (!selector) {
+                        throw new Error('clickAndDownload requires a selector');
+                    }
+                    // Set up download handler before clicking
+                    const downloadPromise = this.page.waitForEvent('download', {
+                        timeout: options?.timeout || 30000,
+                    });
+                    await this.page.click(selector, opts);
+                    const download = await downloadPromise;
+                    const downloadPath = options?.savePath
+                        ? await download.saveAs(options.savePath)
+                        : await download.path();
+                    console.log(`  📥 Download started: ${download.suggestedFilename()}`);
+                    console.log(`  📥 Saved to: ${downloadPath || 'browser default location'}`);
+                    break;
+                }
+                case 'waitForDownload': {
+                    const download = await this.page.waitForEvent('download', {
+                        timeout: options?.timeout || 30000,
+                    });
+                    const downloadPath = options?.savePath
+                        ? await download.saveAs(options.savePath)
+                        : await download.path();
+                    console.log(`  📥 Download detected: ${download.suggestedFilename()}`);
+                    console.log(`  📥 Saved to: ${downloadPath || 'browser default location'}`);
+                    break;
+                }
+                // ═══════════════════════════════════════════════════════════════════════════════
+                // PART 8: NETWORK MOCKING/ACTIONS
+                // ═══════════════════════════════════════════════════════════════════════════════
+                case 'waitForResponse': {
+                    const urlPattern = value || selector;
+                    if (!urlPattern) {
+                        throw new Error('waitForResponse requires url pattern');
+                    }
+                    const response = await this.page.waitForResponse(urlPattern, opts);
+                    console.log(`  🌐 Response received: ${response.url()} (${response.status()})`);
+                    break;
+                }
+                case 'mockRoute': {
+                    const urlPattern = value;
+                    if (!urlPattern) {
+                        throw new Error('mockRoute requires url pattern');
+                    }
+                    const mockData = options?.mockData;
+                    const mockStatus = options?.mockStatus || 200;
+                    await this.page.route(urlPattern, (route) => {
+                        if (mockData) {
+                            route.fulfill({
+                                status: mockStatus,
+                                contentType: options?.contentType || 'application/json',
+                                body: typeof mockData === 'string' ? mockData : JSON.stringify(mockData),
+                            });
+                        }
+                        else {
+                            route.abort();
+                        }
+                    });
+                    console.log(`  🌐 Route mocked: ${urlPattern}`);
+                    break;
+                }
+                case 'unmockRoute': {
+                    const urlPattern = value || '**/*';
+                    await this.page.unroute(urlPattern);
+                    console.log(`  🌐 Route unmocked: ${urlPattern}`);
+                    break;
+                }
+                // ═══════════════════════════════════════════════════════════════════════════════
+                // PART 9: STORAGE ACTIONS
+                // ═══════════════════════════════════════════════════════════════════════════════
+                case 'setLocalStorage': {
+                    if (!selector || !value) {
+                        throw new Error('setLocalStorage requires key (selector) and value');
+                    }
+                    await this.page.evaluate((args) => localStorage.setItem(args.key, args.value), { key: selector, value });
+                    console.log(`  💾 LocalStorage set: ${selector}`);
+                    break;
+                }
+                case 'getLocalStorage': {
+                    if (!selector) {
+                        throw new Error('getLocalStorage requires key (selector)');
+                    }
+                    const result = await this.page.evaluate((key) => localStorage.getItem(key), selector);
+                    console.log(`  💾 LocalStorage get: ${selector} = ${result}`);
+                    break;
+                }
+                case 'clearLocalStorage':
+                    await this.page.evaluate(() => localStorage.clear());
+                    console.log(`  💾 LocalStorage cleared`);
+                    break;
+                case 'setSessionStorage': {
+                    if (!selector || !value) {
+                        throw new Error('setSessionStorage requires key (selector) and value');
+                    }
+                    await this.page.evaluate((args) => sessionStorage.setItem(args.key, args.value), { key: selector, value });
+                    console.log(`  💾 SessionStorage set: ${selector}`);
+                    break;
+                }
+                case 'getSessionStorage': {
+                    if (!selector) {
+                        throw new Error('getSessionStorage requires key (selector)');
+                    }
+                    const result = await this.page.evaluate((key) => sessionStorage.getItem(key), selector);
+                    console.log(`  💾 SessionStorage get: ${selector} = ${result}`);
+                    break;
+                }
+                case 'clearSessionStorage':
+                    await this.page.evaluate(() => sessionStorage.clear());
+                    console.log(`  💾 SessionStorage cleared`);
+                    break;
+                case 'setCookie': {
+                    const cookieName = selector;
+                    const cookieValue = value;
+                    if (!cookieName || !cookieValue) {
+                        throw new Error('setCookie requires name (selector) and value');
+                    }
+                    await this.context.addCookies([
+                        {
+                            name: cookieName,
+                            value: cookieValue,
+                            domain: new URL(this.page.url()).hostname,
+                            path: '/',
+                        },
+                    ]);
+                    console.log(`  🍪 Cookie set: ${cookieName}`);
+                    break;
+                }
+                case 'getCookie': {
+                    if (!selector) {
+                        throw new Error('getCookie requires cookie name (selector)');
+                    }
+                    const cookies = await this.context.cookies();
+                    const cookie = cookies.find(c => c.name === selector);
+                    console.log(`  🍪 Cookie get: ${selector} = ${cookie?.value || 'undefined'}`);
+                    break;
+                }
+                case 'clearCookies':
+                    await this.context.clearCookies();
+                    console.log(`  🍪 All cookies cleared`);
+                    break;
+                // ═══════════════════════════════════════════════════════════════════════════════
+                // PART 10: PERMISSIONS/GEOLOCATION ACTIONS
+                // ═══════════════════════════════════════════════════════════════════════════════
+                case 'grantPermissions': {
+                    const permissions = value ? value.split(',').map((p) => p.trim()) : ['geolocation'];
+                    await this.context.grantPermissions(permissions);
+                    console.log(`  🔐 Permissions granted: ${permissions.join(', ')}`);
+                    break;
+                }
+                case 'setGeolocation': {
+                    const coords = value ? JSON.parse(value) : { latitude: 48.8566, longitude: 2.3522 }; // Paris default
+                    await this.context.setGeolocation(coords);
+                    console.log(`  📍 Geolocation set: ${coords.latitude}, ${coords.longitude}`);
+                    break;
+                }
+                case 'clearGeolocation':
+                    await this.context.setGeolocation({ latitude: 0, longitude: 0 });
+                    console.log(`  📍 Geolocation cleared`);
+                    break;
+                // ═══════════════════════════════════════════════════════════════════════════════
+                // PART 11: MOBILE/VIEWPORT ACTIONS
+                // ═══════════════════════════════════════════════════════════════════════════════
+                case 'setViewport': {
+                    const viewportSize = value ? JSON.parse(value) : { width: 375, height: 667 };
+                    await this.page.setViewportSize(viewportSize);
+                    console.log(`  📱 Viewport set: ${viewportSize.width}x${viewportSize.height}`);
+                    break;
+                }
+                case 'emulateDevice': {
+                    const device = value || 'iPhone';
+                    // Playwright has built-in device descriptors
+                    const devices = {
+                        'iPhone': { viewport: { width: 375, height: 667 }, userAgent: 'iPhone' },
+                        'iPad': { viewport: { width: 768, height: 1024 }, userAgent: 'iPad' },
+                        'Pixel 5': { viewport: { width: 393, height: 851 }, userAgent: 'Pixel 5' },
+                    };
+                    const deviceConfig = devices[device];
+                    if (deviceConfig) {
+                        await this.page.setViewportSize(deviceConfig.viewport);
+                        if (deviceConfig.userAgent) {
+                            await this.page.setExtraHTTPHeaders({ 'User-Agent': deviceConfig.userAgent });
+                        }
+                        console.log(`  📱 Emulating device: ${device}`);
+                    }
+                    else {
+                        console.log(`  ⚠️  Unknown device: ${device}`);
+                    }
+                    break;
+                }
+                case 'touchAction':
+                    // Touch actions are handled by tap/click in Playwright
+                    await this.page.tap(selector, opts);
+                    console.log(`  👆 Touched: ${selector}`);
+                    break;
+                // ═══════════════════════════════════════════════════════════════════════════════
+                // PART 12: ADDITIONAL ACTIONS
+                // ═══════════════════════════════════════════════════════════════════════════════
+                case 'retry': {
+                    const maxRetries = options?.retries || 3;
+                    let lastError = null;
+                    for (let i = 0; i < maxRetries; i++) {
+                        try {
+                            if (selector) {
+                                await this.page.click(selector, opts);
+                            }
+                            console.log(`  🔄 Retry succeeded on attempt ${i + 1}`);
+                            break;
+                        }
+                        catch (error) {
+                            lastError = error;
+                            if (i < maxRetries - 1) {
+                                await this.page.waitForTimeout(options?.delay || 1000);
+                            }
+                        }
+                    }
+                    if (lastError && options?.retries !== 0) {
+                        throw lastError;
+                    }
+                    break;
+                }
+                case 'waitForFunction': {
+                    const script = value || selector;
+                    if (!script) {
+                        throw new Error('waitForFunction requires script (value or selector)');
+                    }
+                    await this.page.waitForFunction(script, undefined, opts);
+                    console.log(`  ⏳ Function completed: ${script.slice(0, 50)}...`);
+                    break;
+                }
+                case 'evaluate': {
+                    const script = value || selector;
+                    if (!script) {
+                        throw new Error('evaluate requires script (value or selector)');
+                    }
+                    // Use current frame if active, otherwise use main page
+                    const context = this.currentFrame || this.page;
+                    const result = await context.evaluate(script);
+                    const scriptPreview = script.slice(0, 50);
+                    const resultPreview = result !== undefined ? JSON.stringify(result).slice(0, 50) : 'undefined';
+                    console.log(`  📝 Evaluated: ${scriptPreview}... => ${resultPreview}...`);
+                    break;
+                }
+                case 'waitForURL': {
+                    const urlPattern = value || selector;
+                    if (!urlPattern) {
+                        throw new Error('waitForURL requires url pattern (value or selector)');
+                    }
+                    await this.page.waitForURL(urlPattern, opts);
+                    console.log(`  🔗 URL matched: ${urlPattern}`);
+                    break;
+                }
+                case 'reload':
+                    await this.page.reload(opts);
+                    console.log(`  🔄 Page reloaded`);
+                    break;
+                case 'goBack':
+                    await this.page.goBack(opts);
+                    console.log(`  ⬅️  Navigated back`);
+                    break;
+                case 'goForward':
+                    await this.page.goForward(opts);
+                    console.log(`  ➡️  Navigated forward`);
+                    break;
+                // ═══════════════════════════════════════════════════════════════════════════════
+                // PART 10: INTELLIGENT CRAWLER ACTIONS
+                // ═══════════════════════════════════════════════════════════════════════════════
+                case 'analyzeSite': {
+                    console.log(`  🔍 Analyzing site profile...`);
+                    // Run site analysis
+                    this.siteAnalysis = await this.siteProfiler.analyzeSite(this.page);
+                    this.siteProfile = this.siteProfiler.determineProfile(this.siteAnalysis);
+                    // Initialize selector generator with analysis
+                    this.selectorGenerator.initialize(this.siteAnalysis);
+                    // Store results in localStorage for verification
+                    const profileData = {
+                        profile: this.siteProfile,
+                        framework: this.siteAnalysis.framework,
+                        cssFramework: this.siteAnalysis.cssFramework,
+                        testabilityScore: this.siteAnalysis.testabilityScore,
+                        accessibilityScore: this.siteAnalysis.accessibilityScore,
+                        hasTestIds: this.siteAnalysis.hasTestIds,
+                        hasAriaLabels: this.siteAnalysis.hasAriaLabels,
+                    };
+                    await this.page.evaluate((data) => {
+                        localStorage.setItem('qa360_site_profile', JSON.stringify(data));
+                    }, profileData);
+                    console.log(`  🎯 Site Profile: ${this.siteProfile}`);
+                    console.log(`  📊 Framework: ${this.siteAnalysis.framework || 'none'}, CSS: ${this.siteAnalysis.cssFramework || 'none'}`);
+                    console.log(`  ✅ Testability: ${this.siteAnalysis.testabilityScore}%, A11y: ${this.siteAnalysis.accessibilityScore}%`);
+                    break;
+                }
+                case 'handleConsent': {
+                    const consentAction = value || 'accept';
+                    const consentTimeout = options?.timeout || 3000;
+                    const customSelector = options?.customSelector;
+                    console.log(`  🍪 Handling consent banners (${consentAction})...`);
+                    const handled = await this.consentHandler.handleConsent(this.page, {
+                        action: consentAction,
+                        timeout: consentTimeout,
+                        customSelector
+                    });
+                    if (handled) {
+                        console.log(`  ✅ Consent banner handled`);
+                    }
+                    else {
+                        console.log(`  ℹ️  No consent banner detected`);
+                    }
+                    break;
+                }
+                case 'generateSelector': {
+                    // Generate optimal selector for element
+                    if (!selector) {
+                        throw new Error('generateSelector requires a selector to analyze');
+                    }
+                    const element = await this.page.$(selector);
+                    if (!element) {
+                        throw new Error(`Element not found: ${selector}`);
+                    }
+                    // Extract element info
+                    const elementInfo = await element.evaluate((el) => ({
+                        tagName: el.tagName?.toLowerCase(),
+                        id: el.id,
+                        className: el.className,
+                        textContent: el.textContent?.trim().substring(0, 50),
+                        role: el.getAttribute('role'),
+                        name: el.getAttribute('name'),
+                        value: el.getAttribute('value'),
+                        type: el.getAttribute('type'),
+                        attributes: {
+                            'data-testid': el.getAttribute('data-testid'),
+                            'aria-label': el.getAttribute('aria-label'),
+                            'placeholder': el.getAttribute('placeholder'),
+                        }
+                    }));
+                    const result = this.selectorGenerator.generateSelector(elementInfo);
+                    console.log(`  🎯 Generated selector (tier ${result.tier}): ${result.selector}`);
+                    console.log(`     Type: ${result.type}, Weight: ${result.weight}`);
+                    // Store result in localStorage for verification
+                    await this.page.evaluate((data) => {
+                        localStorage.setItem('qa360_generated_selector', JSON.stringify(data));
+                    }, result);
+                    break;
+                }
+                // ═══════════════════════════════════════════════════════════════════════════════
+                // PART 14: ASSERTION ACTIONS
+                // ═══════════════════════════════════════════════════════════════════════════════
+                case 'assertVisible': {
+                    if (!selector)
+                        throw new Error('assertVisible requires selector');
+                    const element = await this.page.$(selector);
+                    const isVisible = element ? await element.isVisible().catch(() => false) : false;
+                    if (!isVisible) {
+                        throw new Error(`Element not visible: ${selector}`);
+                    }
+                    console.log(`  ✅ Element visible: ${selector}`);
+                    break;
+                }
+                case 'assertHidden': {
+                    if (!selector)
+                        throw new Error('assertHidden requires selector');
+                    const element = await this.page.$(selector);
+                    const isVisible = element ? await element.isVisible().catch(() => false) : false;
+                    if (isVisible) {
+                        throw new Error(`Element is visible (should be hidden): ${selector}`);
+                    }
+                    console.log(`  ✅ Element hidden: ${selector}`);
+                    break;
+                }
+                case 'assertAttached': {
+                    if (!selector)
+                        throw new Error('assertAttached requires selector');
+                    const element = await this.page.$(selector);
+                    if (!element) {
+                        throw new Error(`Element not attached to DOM: ${selector}`);
+                    }
+                    console.log(`  ✅ Element attached: ${selector}`);
+                    break;
+                }
+                case 'assertText': {
+                    if (!selector)
+                        throw new Error('assertText requires selector and expected value');
+                    const text = await this.page.textContent(selector) || '';
+                    const expectedText = value || '';
+                    if (text.trim() !== expectedText.trim()) {
+                        throw new Error(`Text mismatch for ${selector}: expected "${expectedText}", got "${text.trim()}"`);
+                    }
+                    console.log(`  ✅ Text matches: ${selector}`);
+                    break;
+                }
+                case 'assertContains': {
+                    if (!selector)
+                        throw new Error('assertContains requires selector and expected value');
+                    const text = await this.page.textContent(selector) || '';
+                    const expectedText = value || '';
+                    if (!text.includes(expectedText)) {
+                        throw new Error(`Text does not contain "${expectedText}" for ${selector}`);
+                    }
+                    console.log(`  ✅ Text contains: ${selector}`);
+                    break;
+                }
+                case 'assertValue': {
+                    if (!selector)
+                        throw new Error('assertValue requires selector');
+                    const inputValue = await this.page.inputValue(selector);
+                    const expectedValue = value || '';
+                    if (inputValue !== expectedValue) {
+                        throw new Error(`Value mismatch for ${selector}: expected "${expectedValue}", got "${inputValue}"`);
+                    }
+                    console.log(`  ✅ Value matches: ${selector}`);
+                    break;
+                }
+                case 'assertAttribute': {
+                    if (!selector)
+                        throw new Error('assertAttribute requires selector and attribute name');
+                    const attrName = value || '';
+                    const attrValue = options?.expected;
+                    const actualValue = await this.page.getAttribute(selector, attrName);
+                    if (attrValue !== undefined && actualValue !== attrValue) {
+                        throw new Error(`Attribute ${attrName} mismatch for ${selector}: expected "${attrValue}", got "${actualValue}"`);
+                    }
+                    console.log(`  ✅ Attribute ${attrName} matches: ${selector}`);
+                    break;
+                }
+                case 'assertClass': {
+                    if (!selector)
+                        throw new Error('assertClass requires selector and class name');
+                    const element = await this.page.$(selector);
+                    if (!element)
+                        throw new Error(`Element not found: ${selector}`);
+                    const hasClass = await element.evaluate((el, cls) => el.classList.contains(cls), value);
+                    if (!hasClass) {
+                        throw new Error(`Element does not have class "${value}": ${selector}`);
+                    }
+                    console.log(`  ✅ Element has class: ${selector} → ${value}`);
+                    break;
+                }
+                case 'assertCount': {
+                    if (!selector)
+                        throw new Error('assertCount requires selector');
+                    const count = await this.page.locator(selector).count();
+                    const expectedCount = parseInt(value || '0', 10);
+                    if (count !== expectedCount) {
+                        throw new Error(`Count mismatch for ${selector}: expected ${expectedCount}, got ${count}`);
+                    }
+                    console.log(`  ✅ Count matches: ${selector} → ${count} elements`);
+                    break;
+                }
+                case 'assertURL': {
+                    const url = this.page.url();
+                    const expectedURL = value || '';
+                    if (url !== expectedURL && !url.includes(expectedURL)) {
+                        throw new Error(`URL mismatch: expected "${expectedURL}", got "${url}"`);
+                    }
+                    console.log(`  ✅ URL matches: ${url}`);
+                    break;
+                }
+                case 'assertTitle': {
+                    const title = await this.page.title();
+                    const expectedTitle = value || '';
+                    if (title !== expectedTitle && !title.includes(expectedTitle)) {
+                        throw new Error(`Title mismatch: expected "${expectedTitle}", got "${title}"`);
+                    }
+                    console.log(`  ✅ Title matches: ${title}`);
+                    break;
+                }
+                case 'assertEnabled': {
+                    if (!selector)
+                        throw new Error('assertEnabled requires selector');
+                    const element = await this.page.$(selector);
+                    if (!element)
+                        throw new Error(`Element not found: ${selector}`);
+                    const isEnabled = await element.isEnabled().catch(() => false);
+                    if (!isEnabled) {
+                        throw new Error(`Element is disabled: ${selector}`);
+                    }
+                    console.log(`  ✅ Element enabled: ${selector}`);
+                    break;
+                }
+                case 'assertDisabled': {
+                    if (!selector)
+                        throw new Error('assertDisabled requires selector');
+                    const element = await this.page.$(selector);
+                    if (!element)
+                        throw new Error(`Element not found: ${selector}`);
+                    const isEnabled = await element.isEnabled().catch(() => true);
+                    if (isEnabled) {
+                        throw new Error(`Element is enabled (should be disabled): ${selector}`);
+                    }
+                    console.log(`  ✅ Element disabled: ${selector}`);
+                    break;
+                }
+                case 'assertChecked': {
+                    if (!selector)
+                        throw new Error('assertChecked requires selector');
+                    const isChecked = await this.page.isChecked(selector);
+                    if (!isChecked) {
+                        throw new Error(`Element is not checked: ${selector}`);
+                    }
+                    console.log(`  ✅ Element checked: ${selector}`);
+                    break;
+                }
+                case 'assertUnchecked': {
+                    if (!selector)
+                        throw new Error('assertUnchecked requires selector');
+                    const isChecked = await this.page.isChecked(selector);
+                    if (isChecked) {
+                        throw new Error(`Element is checked (should be unchecked): ${selector}`);
+                    }
+                    console.log(`  ✅ Element unchecked: ${selector}`);
+                    break;
+                }
+                case 'assertFocused': {
+                    if (!selector)
+                        throw new Error('assertFocused requires selector');
+                    const isFocused = await this.page.evaluate((sel) => {
+                        const el = document.querySelector(sel);
+                        return el === document.activeElement;
+                    }, selector);
+                    if (!isFocused) {
+                        throw new Error(`Element is not focused: ${selector}`);
+                    }
+                    console.log(`  ✅ Element focused: ${selector}`);
+                    break;
+                }
+                case 'assertEmpty': {
+                    if (!selector)
+                        throw new Error('assertEmpty requires selector');
+                    const text = await this.page.textContent(selector) || '';
+                    if (text.trim() !== '') {
+                        throw new Error(`Element is not empty: ${selector}`);
+                    }
+                    console.log(`  ✅ Element empty: ${selector}`);
+                    break;
+                }
+                case 'assertNotEmpty': {
+                    if (!selector)
+                        throw new Error('assertNotEmpty requires selector');
+                    const text = await this.page.textContent(selector) || '';
+                    if (text.trim() === '') {
+                        throw new Error(`Element is empty: ${selector}`);
+                    }
+                    console.log(`  ✅ Element not empty: ${selector}`);
+                    break;
+                }
+                case 'assertReadOnly': {
+                    if (!selector)
+                        throw new Error('assertReadOnly requires selector');
+                    const isReadOnly = await this.page.getAttribute(selector, 'readonly');
+                    if (!isReadOnly) {
+                        throw new Error(`Element is not read-only: ${selector}`);
+                    }
+                    console.log(`  ✅ Element read-only: ${selector}`);
+                    break;
+                }
+                case 'assertEditable': {
+                    if (!selector)
+                        throw new Error('assertEditable requires selector');
+                    const isReadOnly = await this.page.getAttribute(selector, 'readonly');
+                    if (isReadOnly) {
+                        throw new Error(`Element is read-only: ${selector}`);
+                    }
+                    console.log(`  ✅ Element editable: ${selector}`);
+                    break;
+                }
+                case 'assertInViewport': {
+                    if (!selector)
+                        throw new Error('assertInViewport requires selector');
+                    const isInViewport = await this.page.locator(selector).isVisible().catch(() => false);
+                    if (!isInViewport) {
+                        throw new Error(`Element not in viewport: ${selector}`);
+                    }
+                    console.log(`  ✅ Element in viewport: ${selector}`);
+                    break;
+                }
+                case 'assertHasAttribute': {
+                    if (!selector)
+                        throw new Error('assertHasAttribute requires selector and attribute name');
+                    const attrName = value || '';
+                    const attrValue = await this.page.getAttribute(selector, attrName);
+                    if (attrValue === null) {
+                        throw new Error(`Element does not have attribute "${attrName}": ${selector}`);
+                    }
+                    console.log(`  ✅ Element has attribute: ${selector} → ${attrName}="${attrValue}"`);
+                    break;
+                }
+                // ═══════════════════════════════════════════════════════════════════════════════
+                // PART 15: UTILITY ACTIONS
+                // ═══════════════════════════════════════════════════════════════════════════════
+                case 'screenshot': {
+                    const timestamp = Date.now();
+                    const filename = `screenshot-${timestamp}.png`;
+                    await this.page.screenshot({ path: filename });
+                    console.log(`  📸 Screenshot saved: ${filename}`);
+                    break;
+                }
+                case 'fullPageScreenshot': {
+                    const timestamp = Date.now();
+                    const filename = `screenshot-full-${timestamp}.png`;
+                    await this.page.screenshot({ path: filename, fullPage: true });
+                    console.log(`  📸 Full page screenshot saved: ${filename}`);
+                    break;
+                }
+                case 'waitForLoadState': {
+                    const state = value || 'load';
+                    await this.page.waitForLoadState(state);
+                    console.log(`  ⏳ Load state reached: ${state}`);
+                    break;
+                }
+                case 'waitForSelectorState': {
+                    if (!selector)
+                        throw new Error('waitForSelectorState requires selector');
+                    const state = value || 'attached';
+                    await this.page.waitForSelector(selector, { state: state });
+                    console.log(`  ⏳ Selector state reached: ${selector} → ${state}`);
+                    break;
+                }
+                case 'waitForText': {
+                    if (!selector)
+                        throw new Error('waitForText requires selector');
+                    const expectedText = value || '';
+                    await this.page.waitForSelector(selector);
+                    await this.page.waitForFunction((args) => {
+                        const el = document.querySelector(args.sel);
+                        return el?.textContent?.includes(args.text);
+                    }, { sel: selector, text: expectedText });
+                    console.log(`  ⏳ Text found: ${selector} contains "${expectedText}"`);
+                    break;
+                }
+                case 'waitForValue': {
+                    if (!selector)
+                        throw new Error('waitForValue requires selector');
+                    const expectedValue = value || '';
+                    await this.page.waitForSelector(selector);
+                    await this.page.waitForFunction((args) => {
+                        const el = document.querySelector(args.sel);
+                        return el?.value === args.val;
+                    }, { sel: selector, val: expectedValue });
+                    console.log(`  ⏳ Value found: ${selector} has value "${expectedValue}"`);
+                    break;
+                }
+                case 'getText': {
+                    if (!selector)
+                        throw new Error('getText requires selector');
+                    const text = await this.page.textContent(selector) || '';
+                    console.log(`  📄 Text content: ${selector} → "${text.trim()}"`);
+                    break;
+                }
+                case 'getAttribute': {
+                    if (!selector)
+                        throw new Error('getAttribute requires selector and attribute name');
+                    const attrName = value || '';
+                    const attrValue = await this.page.getAttribute(selector, attrName);
+                    console.log(`  📄 Attribute ${attrName}: ${selector} → "${attrValue}"`);
+                    break;
+                }
+                case 'getElementCount': {
+                    if (!selector)
+                        throw new Error('getElementCount requires selector');
+                    const count = await this.page.locator(selector).count();
+                    console.log(`  🔢 Element count: ${selector} → ${count} elements`);
+                    break;
+                }
+                case 'getHTML': {
+                    if (!selector)
+                        throw new Error('getHTML requires selector');
+                    const html = await this.page.innerHTML(selector);
+                    console.log(`  📄 HTML: ${selector} → ${html.substring(0, 100)}...`);
+                    break;
+                }
+                case 'getBoundingBox': {
+                    if (!selector)
+                        throw new Error('getBoundingBox requires selector');
+                    const box = await this.page.locator(selector).boundingBox();
+                    console.log(`  📐 Bounding box: ${selector} → ${JSON.stringify(box)}`);
+                    break;
+                }
+                case 'highlight': {
+                    if (!selector)
+                        throw new Error('highlight requires selector');
+                    await this.page.evaluate((sel) => {
+                        const el = document.querySelector(sel);
+                        if (el) {
+                            el.style.outline = '3px solid red';
+                            el.style.outlineOffset = '2px';
+                        }
+                    }, selector);
+                    console.log(`  🎨 Highlighted: ${selector}`);
+                    break;
+                }
+                default:
+                    throw new Error(`Unknown action: ${action}`);
+            }
+            // Add wait after action if specified
+            if (step.wait) {
+                await this.page.waitForTimeout(step.wait);
+            }
+            // Take screenshot on failure if configured (will be checked in catch block)
+            // or take screenshot if requested
+            // Verify expected outcomes
+            if (expected) {
+                await this.verifyExpected(expected);
+            }
+            return {
+                step,
+                success: true,
+                duration: Date.now() - startTime,
+                screenshot,
+            };
+        }
+        catch (error) {
+            // Take screenshot on failure
+            try {
+                const buffer = await this.page.screenshot({ type: 'png' });
+                screenshot = `data:image/png;base64,${buffer.toString('base64')}`;
+            }
+            catch { }
+            return {
+                step,
+                success: false,
+                duration: Date.now() - startTime,
+                error: this.redactor.redact(error instanceof Error ? error.message : 'Unknown error'),
+                screenshot,
+            };
+        }
+    }
+    /**
+     * Verify expected outcomes after a step
+     */
+    async verifyExpected(expected) {
+        if (!expected)
+            return;
+        if (expected.url !== undefined) {
+            const currentUrl = this.page.url();
+            if (currentUrl !== expected.url) {
+                throw new Error(`URL mismatch: expected "${expected.url}", got "${currentUrl}"`);
+            }
+        }
+        if (expected.urlContains !== undefined) {
+            const currentUrl = this.page.url();
+            if (!currentUrl.includes(expected.urlContains)) {
+                throw new Error(`URL does not contain "${expected.urlContains}": "${currentUrl}"`);
+            }
+        }
+        if (expected.visible !== undefined) {
+            const element = this.page.locator(expected.visible);
+            if (!(await element.isVisible())) {
+                throw new Error(`Expected element to be visible: ${expected.visible}`);
+            }
+        }
+        if (expected.hidden !== undefined) {
+            const element = this.page.locator(expected.hidden);
+            if (!(await element.isHidden())) {
+                throw new Error(`Expected element to be hidden: ${expected.hidden}`);
+            }
+        }
+        if (expected.elementText) {
+            const element = this.page.locator(expected.elementText.selector);
+            const text = await element.textContent();
+            if (text !== expected.elementText.text) {
+                throw new Error(`Text mismatch for ${expected.elementText.selector}: expected "${expected.elementText.text}", got "${text}"`);
+            }
+        }
+    }
+    /**
+     * Test single page with accessibility
+     */
+    async testPage(pageUrl, config) {
+        try {
+            const startTime = Date.now();
+            // Navigate to page
+            const response = await this.page.goto(pageUrl, {
+                timeout: config.timeout || 30000,
+                waitUntil: 'networkidle'
+            });
+            const loadTime = Date.now() - startTime;
+            if (!response || !response.ok()) {
+                return {
+                    page: pageUrl,
+                    success: false,
+                    loadTime,
+                    error: `HTTP ${response?.status() || 'unknown'}: Failed to load page`
+                };
+            }
+            // Take screenshot based on config
+            const screenshot = await this.takeScreenshot(pageUrl, config.target.screenshot);
+            // Get DOM snapshot
+            const domSnapshot = await this.getDomSnapshot();
+            // Run accessibility tests
+            const accessibility = await this.runAccessibilityTests(config.budgets);
+            // Check if accessibility meets budget
+            const a11yPassed = !config.budgets?.a11y_min ||
+                (accessibility?.score !== undefined && accessibility.score >= config.budgets.a11y_min);
+            return {
+                page: pageUrl,
+                success: a11yPassed,
+                loadTime,
+                screenshot,
+                accessibility,
+                domSnapshot,
+                error: a11yPassed ? undefined :
+                    `Accessibility score ${accessibility?.score || 0}% below budget ${config.budgets?.a11y_min}%`
+            };
+        }
+        catch (error) {
+            return {
+                page: pageUrl,
+                success: false,
+                loadTime: 0,
+                error: this.redactor.redact(error instanceof Error ? error.message : 'Unknown error')
+            };
+        }
+    }
+    /**
+     * Test page with actions (for user journeys)
+     */
+    async testPageWithActions(pageUrl, actions, config) {
+        try {
+            const startTime = Date.now();
+            // Navigate to page
+            const response = await this.page.goto(pageUrl, {
+                timeout: config.timeout || 30000,
+                waitUntil: 'networkidle'
+            });
+            const loadTime = Date.now() - startTime;
+            if (!response || !response.ok()) {
+                return {
+                    page: pageUrl,
+                    success: false,
+                    loadTime,
+                    error: `HTTP ${response?.status() || 'unknown'}: Failed to load page`
+                };
+            }
+            // Execute actions
+            for (const action of actions) {
+                try {
+                    await this.executeAction(action);
+                }
+                catch (actionError) {
+                    return {
+                        page: pageUrl,
+                        success: false,
+                        loadTime,
+                        error: `Action failed (${action.type}): ${this.redactor.redact(actionError instanceof Error ? actionError.message : 'Unknown error')}`
+                    };
+                }
+            }
+            // Take screenshot based on config
+            const screenshot = await this.takeScreenshot(pageUrl, config.target.screenshot);
+            // Get DOM snapshot
+            const domSnapshot = await this.getDomSnapshot();
+            // Run accessibility tests
+            const accessibility = await this.runAccessibilityTests(config.budgets);
+            // Check if accessibility meets budget
+            const a11yPassed = !config.budgets?.a11y_min ||
+                (accessibility?.score !== undefined && accessibility.score >= config.budgets.a11y_min);
+            return {
+                page: pageUrl,
+                success: a11yPassed,
+                loadTime,
+                screenshot,
+                accessibility,
+                domSnapshot,
+                error: a11yPassed ? undefined :
+                    `Accessibility score ${accessibility?.score || 0}% below budget ${config.budgets?.a11y_min}%`
+            };
+        }
+        catch (error) {
+            return {
+                page: pageUrl,
+                success: false,
+                loadTime: 0,
+                error: this.redactor.redact(error instanceof Error ? error.message : 'Unknown error')
+            };
+        }
+    }
+    /**
+     * Execute a single page action
+     */
+    async executeAction(action) {
+        const timeout = action.options?.timeout ? Number(action.options.timeout) : 10000;
+        switch (action.type) {
+            case 'goto':
+            case 'navigate':
+                // Navigation is handled separately (page.goto is called before actions)
+                break;
+            case 'click':
+                if (!action.selector) {
+                    throw new Error('Click action requires a selector');
+                }
+                await this.page.click(action.selector, { timeout });
+                break;
+            case 'fill':
+                if (!action.selector) {
+                    throw new Error('Fill action requires a selector');
+                }
+                await this.page.fill(action.selector, action.value || '', { timeout });
+                break;
+            case 'select':
+                if (!action.selector) {
+                    throw new Error('Select action requires a selector');
+                }
+                await this.page.selectOption(action.selector, action.value || '', { timeout });
+                break;
+            case 'check':
+                if (!action.selector) {
+                    throw new Error('Check action requires a selector');
+                }
+                await this.page.check(action.selector, { timeout });
+                break;
+            case 'uncheck':
+                if (!action.selector) {
+                    throw new Error('Uncheck action requires a selector');
+                }
+                await this.page.uncheck(action.selector, { timeout });
+                break;
+            case 'wait':
+            case 'waitFor':
+                if (action.selector) {
+                    await this.page.waitForSelector(action.selector, { timeout });
+                }
+                else {
+                    await this.page.waitForTimeout(timeout);
+                }
+                break;
+            case 'screenshot':
+                await this.page.screenshot({
+                    path: action.options?.path ? String(action.options.path) : undefined
+                });
+                break;
+            case 'assert':
+                if (action.selector) {
+                    const element = await this.page.$(action.selector);
+                    if (!element) {
+                        throw new Error(`Element not found: ${action.selector}`);
+                    }
+                }
+                break;
+            default:
+                console.warn(`Unknown action type: ${action.type}`);
+        }
+    }
+    /**
+     * Setup browser with all options
+     * Playwright++: Enhanced video/trace recording support
+     */
+    async setupBrowser(config) {
+        // Determine browser type
+        const browserType = config.target.browser || 'chromium';
+        const browserTypeObj = browserType === 'firefox' ? firefox : browserType === 'webkit' ? webkit : chromium;
+        // Determine headed mode (CLI override > target config > default headless)
+        const headless = config.cliHeaded ?? config.target.headless ?? true;
+        // Launch browser
+        this.browser = await browserTypeObj.launch({
+            headless,
+            args: ['--no-sandbox', '--disable-dev-shm-usage'],
+            slowMo: config.target.slowMo || 0,
+        });
+        // Build extra HTTP headers with auth
+        const extraHTTPHeaders = {
+            'User-Agent': 'QA360-UI-Test/1.0'
+        };
+        if (this.auth?.headers) {
+            Object.assign(extraHTTPHeaders, this.auth.headers);
+        }
+        // Setup viewport based on device or explicit config
+        let viewport = { width: 1280, height: 720 };
+        if (config.target.device === 'mobile') {
+            viewport = { width: 375, height: 667 };
+        }
+        else if (config.target.device === 'tablet') {
+            viewport = { width: 768, height: 1024 };
+        }
+        else if (config.target.viewport) {
+            viewport = config.target.viewport;
+        }
+        // Playwright++: Determine video recording mode
+        const videoMode = config.artifacts?.video ?? config.target.video;
+        const shouldRecordVideo = videoMode === 'always' || videoMode === 'retain-on-failure';
+        // Create context with video recording if enabled
+        const recordVideo = shouldRecordVideo
+            ? { dir: this.videoDir, size: viewport }
+            : undefined;
+        // P0: HTTP credentials for native browser Basic Auth popup (WWW-Authenticate)
+        const httpCredentials = this.auth?.httpCredentials
+            ? { username: this.auth.httpCredentials.username, password: this.auth.httpCredentials.password }
+            : undefined;
+        this.context = await this.browser.newContext({
+            viewport,
+            userAgent: 'QA360-UI-Test/1.0',
+            extraHTTPHeaders,
+            recordVideo,
+            httpCredentials, // P0: Native Basic Auth popup support
+        });
+        // Playwright++: Start tracing if enabled
+        const traceMode = config.artifacts?.trace ?? config.target.trace;
+        if (traceMode === 'always' || traceMode === 'on-first-failure' || traceMode === 'retain-on-failure') {
+            // Start tracing - will be saved in cleanup
+            // Note: Playwright's trace API is context.startTracing()
+            // Implementation depends on Playwright version
+        }
+        // Add cookies from auth credentials after context creation
+        if (this.auth?.cookies && this.auth.cookies.length > 0) {
+            await this.context.addCookies(this.auth.cookies.map(c => ({
+                name: c.name,
+                value: c.value,
+                domain: c.domain || '',
+                path: c.path || '/',
+                httpOnly: c.httpOnly || false,
+                secure: c.secure || false
+            })));
+        }
+        this.page = await this.context.newPage();
+        // ═══════════════════════════════════════════════════════════════════════════════
+        // PART 2: AUTO-HANDLE JAVASCRIPT DIALOGS
+        // ═══════════════════════════════════════════════════════════════════════════════
+        // Note: Only attach handlers if page.on exists (not present in all mocks)
+        if (typeof this.page.on === 'function') {
+            this.globalDialogHandler = async (dialog) => {
+                const type = dialog.type(); // 'alert' | 'confirm' | 'prompt' | 'beforeunload'
+                const message = dialog.message();
+                console.log(`  🔔 Dialog [${type}]: "${message.slice(0, 50)}${message.length > 50 ? '...' : ''}"`);
+                // Store for assertions
+                this.lastDialog = { type, message, timestamp: Date.now() };
+                // Default behavior based on config
+                const dialogConfig = config.target.dialogs || this.dialogBehavior;
+                if (dialogConfig === 'dismiss') {
+                    await dialog.dismiss();
+                    console.log(`  ↪️  Dialog dismissed`);
+                }
+                else if (type === 'prompt') {
+                    const promptValue = config.target.dialogPromptValue || this.dialogPromptValue;
+                    await dialog.accept(promptValue);
+                    console.log(`  ↪️  Dialog accepted with value: "${promptValue}"`);
+                }
+                else {
+                    await dialog.accept();
+                    console.log(`  ↪️  Dialog accepted`);
+                }
+            };
+            this.page.on('dialog', this.globalDialogHandler);
+        }
+        // ═══════════════════════════════════════════════════════════════════════════════
+        // PART 3: TRACK NEW TABS/PAGES
+        // ═══════════════════════════════════════════════════════════════════════════════
+        this.openPages = [this.page];
+        this.currentPageIndex = 0;
+        if (typeof this.context.on === 'function') {
+            this.context.on('page', async (newPage) => {
+                console.log(`  📑 New tab opened: ${newPage.url()}`);
+                this.openPages.push(newPage);
+                // Auto-attach dialog handler to new pages
+                if (typeof newPage.on === 'function') {
+                    newPage.on('dialog', async (dialog) => {
+                        const type = dialog.type();
+                        const message = dialog.message();
+                        console.log(`  🔔 Dialog [${type}] in new tab: "${message.slice(0, 50)}..."`);
+                        this.lastDialog = { type, message, timestamp: Date.now() };
+                        const dialogConfig = config.target.dialogs || this.dialogBehavior;
+                        if (dialogConfig === 'dismiss') {
+                            await dialog.dismiss();
+                        }
+                        else if (type === 'prompt') {
+                            await dialog.accept(config.target.dialogPromptValue || this.dialogPromptValue);
+                        }
+                        else {
+                            await dialog.accept();
+                        }
+                    });
+                }
+            });
+        }
+    }
+    /**
+     * Determine if video should be recorded
+     */
+    shouldRecordVideo(mode) {
+        return mode === 'always' || mode === 'retain-on-fail';
+    }
+    /**
+     * Playwright++: Generate HTML report
+     */
+    async generateHtmlReport(config, results, e2eResults, summary) {
+        const reportPath = config.htmlReport || join(config.artifacts?.outputDir || this.artifactDir, 'report.html');
+        const timestamp = new Date().toISOString();
+        const reportData = {
+            title: `QA360 UI Test Report - ${timestamp}`,
+            summary: {
+                total: summary.total,
+                passed: summary.passed,
+                failed: summary.failed,
+                skipped: 0,
+                duration: summary.avgLoadTime * summary.total,
+                timestamp,
+            },
+            tests: [
+                ...results.map((r, i) => ({
+                    id: `smoke-${i}`,
+                    name: `UI Smoke: ${r.page}`,
+                    status: (r.success ? 'passed' : 'failed'),
+                    duration: r.loadTime,
+                    error: r.error,
+                    steps: [],
+                    artifacts: r.artifacts,
+                })),
+                ...e2eResults.map((r, i) => ({
+                    id: `e2e-${i}`,
+                    name: r.test.name || 'E2E Test',
+                    status: (r.success ? 'passed' : 'failed'),
+                    duration: r.duration,
+                    error: r.error,
+                    steps: r.steps.map((s, j) => ({
+                        name: s.step.action || `Step ${j + 1}`,
+                        action: s.step.action || 'step',
+                        selector: s.step.selector,
+                        value: s.step.value,
+                        status: (s.success ? 'passed' : 'failed'),
+                        duration: s.duration,
+                        error: s.error,
+                    })),
+                    artifacts: undefined,
+                })),
+            ],
+            artifacts: {
+                screenshots: this.allScreenshots.map(s => ({
+                    path: s.localPath,
+                    timestamp: s.metadata.timestamp,
+                    type: 'after',
+                })),
+                videos: this.allVideos.map(v => ({ path: v, duration: 0 })),
+                traces: this.allTraces.map(t => ({ path: t, format: 'zip' })),
+            },
+            environment: {
+                browser: config.target.browser || 'chromium',
+                platform: process.platform,
+                nodeVersion: process.version,
+            },
+        };
+        HTMLReporter.generate(reportData, reportPath);
+        console.log(`\n📊 HTML report generated: ${reportPath}`);
+    }
+    /**
+     * Perform login if configured
+     */
+    async performLogin(login) {
+        if (!login || !login.username || !login.password) {
+            return;
+        }
+        console.log(`  🔐 Performing login...`);
+        const loginUrl = login.url || this.page.url();
+        await this.page.goto(loginUrl);
+        // Fill login form
+        const usernameSelector = login.usernameSelector ||
+            'input[name="username"], input[name="email"], input[type="email"], #username, #email';
+        const passwordSelector = login.passwordSelector ||
+            'input[name="password"], input[type="password"], #password';
+        const submitSelector = login.submitSelector ||
+            'button[type="submit"], input[type="submit"], button:has-text("Login"), button:has-text("Sign in")';
+        await this.page.fill(usernameSelector, login.username);
+        await this.page.fill(passwordSelector, login.password);
+        await this.page.click(submitSelector);
+        // Wait for navigation or login completion
+        try {
+            await this.page.waitForLoadState('networkidle', { timeout: 10000 });
+        }
+        catch {
+            // Continue even if navigation doesn't complete
+        }
+    }
+    /**
+     * Run accessibility tests using axe-core
+     */
+    async runAccessibilityTests(budgets) {
+        try {
+            // Inject axe-core
+            await this.page.addScriptTag({
+                url: 'https://unpkg.com/axe-core@4.8.2/axe.min.js'
+            });
+            // Run axe analysis
+            const axeResults = await this.page.evaluate(() => {
+                return new Promise((resolve) => {
+                    // @ts-ignore - axe is injected
+                    if (typeof axe !== 'undefined') {
+                        // @ts-ignore
+                        axe.run((err, results) => {
+                            if (err) {
+                                resolve({ violations: [], passes: [], incomplete: [] });
+                            }
+                            else {
+                                resolve(results);
+                            }
+                        });
+                    }
+                    else {
+                        resolve({ violations: [], passes: [], incomplete: [] });
+                    }
+                });
+            });
+            // Process violations
+            const violations = axeResults.violations?.map((violation) => ({
+                id: violation.id,
+                impact: violation.impact || 'minor',
+                description: violation.description || violation.help || 'Accessibility issue',
+                nodes: violation.nodes?.length || 0
+            })) || [];
+            // Calculate score (simple scoring: 100 - weighted violations)
+            const criticalCount = violations.filter((v) => v.impact === 'critical').length;
+            const seriousCount = violations.filter((v) => v.impact === 'serious').length;
+            const moderateCount = violations.filter((v) => v.impact === 'moderate').length;
+            const minorCount = violations.filter((v) => v.impact === 'minor').length;
+            const score = Math.max(0, 100 - (criticalCount * 25 +
+                seriousCount * 10 +
+                moderateCount * 5 +
+                minorCount * 1));
+            return {
+                score: Math.round(score),
+                violations
+            };
+        }
+        catch (error) {
+            console.log(`    ⚠️  Accessibility test failed: ${error}`);
+            return {
+                score: 0,
+                violations: [{
+                        id: 'axe-error',
+                        impact: 'critical',
+                        description: 'Failed to run accessibility analysis',
+                        nodes: 0
+                    }]
+            };
+        }
+    }
+    /**
+     * Get DOM snapshot for debugging
+     */
+    async getDomSnapshot() {
+        try {
+            const snapshot = await this.page.evaluate(() => {
+                return {
+                    title: document.title,
+                    url: window.location.href,
+                    elements: {
+                        buttons: document.querySelectorAll('button, input[type="button"], input[type="submit"]').length,
+                        links: document.querySelectorAll('a[href]').length,
+                        forms: document.querySelectorAll('form').length,
+                        inputs: document.querySelectorAll('input, textarea, select').length
+                    }
+                };
+            });
+            return snapshot;
+        }
+        catch {
+            return {
+                title: 'Unknown',
+                url: this.page.url(),
+                elements: { buttons: 0, links: 0, forms: 0, inputs: 0 }
+            };
+        }
+    }
+    /**
+     * Take screenshot for debugging
+     */
+    async takeScreenshot(pageUrl, mode) {
+        const shouldTake = mode === 'always' || mode === 'only-on-fail';
+        if (!shouldTake)
+            return '';
+        try {
+            const screenshot = await this.page.screenshot({
+                type: 'png',
+                fullPage: false // Just viewport for performance
+            });
+            // Return base64 data URL for embedding
+            return `data:image/png;base64,${screenshot.toString('base64')}`;
+        }
+        catch {
+            return '';
+        }
+    }
+    /**
+     * Calculate test summary
+     */
+    calculateSummary(results, e2eResults = []) {
+        const smokeTests = results.length;
+        const e2eTests = e2eResults.length;
+        const total = smokeTests + e2eTests;
+        const smokePassed = results.filter(r => r.success).length;
+        const e2ePassed = e2eResults.filter(r => r.success).length;
+        const passed = smokePassed + e2ePassed;
+        const failed = total - passed;
+        const avgLoadTime = smokeTests > 0 ?
+            Math.round(results.reduce((sum, r) => sum + r.loadTime, 0) / smokeTests) : 0;
+        const a11yScores = results
+            .map(r => r.accessibility?.score)
+            .filter((score) => typeof score === 'number');
+        const avgA11yScore = a11yScores.length > 0 ?
+            Math.round(a11yScores.reduce((sum, score) => sum + score, 0) / a11yScores.length) : 0;
+        return {
+            total,
+            passed,
+            failed,
+            avgLoadTime,
+            avgA11yScore
+        };
+    }
+    /**
+     * Generate JUnit XML fragment
+     */
+    generateJUnit(results, e2eResults = []) {
+        const summary = this.calculateSummary(results, e2eResults);
+        const timestamp = new Date().toISOString();
+        let junit = `<?xml version="1.0" encoding="UTF-8"?>
+<testsuites>
+  <testsuite name="UI Smoke Tests" tests="${results.length}" failures="${results.filter(r => !r.success).length}" time="${summary.avgLoadTime / 1000}" timestamp="${timestamp}">
+`;
+        for (const result of results) {
+            const testName = `UI Test: ${result.page}`;
+            const time = result.loadTime / 1000;
+            junit += `    <testcase name="${this.escapeXml(testName)}" time="${time}">
+`;
+            if (!result.success) {
+                junit += `      <failure message="${this.escapeXml(result.error || 'Test failed')}">${this.escapeXml(JSON.stringify(result, null, 2))}</failure>
+`;
+            }
+            junit += `    </testcase>
+`;
+        }
+        junit += `  </testsuite>
+`;
+        // Add E2E test suite
+        if (e2eResults.length > 0) {
+            const e2eFailed = e2eResults.filter(r => !r.success).length;
+            const e2eDuration = e2eResults.reduce((sum, r) => sum + r.duration, 0) / 1000;
+            junit += `  <testsuite name="E2E Tests" tests="${e2eResults.length}" failures="${e2eFailed}" time="${e2eDuration}" timestamp="${timestamp}">
+`;
+            for (const result of e2eResults) {
+                const testName = result.test.name;
+                const time = result.duration / 1000;
+                junit += `    <testcase name="${this.escapeXml(testName)}" time="${time}">
+`;
+                if (!result.success) {
+                    const failedSteps = result.steps.filter(s => !s.success);
+                    const failureDetails = failedSteps.map(s => `${s.step.action}: ${s.error}`).join('; ');
+                    junit += `      <failure message="${this.escapeXml(result.error || 'Test failed')}">${this.escapeXml(failureDetails)}</failure>
+`;
+                }
+                junit += `    </testcase>
+`;
+            }
+            junit += `  </testsuite>
+`;
+        }
+        junit += `</testsuites>`;
+        return junit;
+    }
+    /**
+     * Escape XML special characters
+     */
+    escapeXml(str) {
+        return str
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&apos;');
+    }
+    /**
+     * Cleanup browser resources and manage artifacts
+     */
+    async cleanup(config) {
+        const videoMode = config.artifacts?.video ?? config.target.video;
+        const traceMode = config.artifacts?.trace ?? config.target.trace;
+        const hasFailures = this.failureCount > 0;
+        // Save video artifacts if configured and failures occurred
+        if (this.context && videoMode === 'retain-on-failure') {
+            if (hasFailures) {
+                // Retain videos for failed tests - video is saved automatically by Playwright
+                console.log('  📹 Video artifacts retained on failure');
+            }
+            else {
+                // No failures, video will be automatically deleted by Playwright
+                console.log('  ✓ No failures - video artifacts cleaned up');
+            }
+        }
+        // Save trace artifacts if configured and failures occurred
+        if (this.context && (traceMode === 'retain-on-failure' || traceMode === 'on-first-failure')) {
+            if (hasFailures && traceMode === 'retain-on-failure') {
+                // Stop tracing and save for failed tests
+                const tracePath = join(this.artifactDir, 'traces', `trace-${Date.now()}.zip`);
+                await this.context.tracing.stop({ path: tracePath });
+                console.log(`  📊 Trace retained: ${tracePath}`);
+            }
+            else if (!hasFailures) {
+                // Stop tracing without saving
+                await this.context.tracing.stop();
+                console.log('  ✓ No failures - trace artifacts cleaned up');
+            }
+            else if (traceMode === 'on-first-failure') {
+                // Already saved on first failure, just stop
+                await this.context.tracing.stop();
+            }
+        }
+        // Close browser resources
+        if (this.page) {
+            await this.page.close();
+        }
+        if (this.context) {
+            await this.context.close();
+        }
+        if (this.browser) {
+            await this.browser.close();
+        }
+    }
+    /**
+     * Validate UI target configuration
+     */
+    static validateConfig(target) {
+        const errors = [];
+        if (!target.baseUrl) {
+            errors.push('UI target requires baseUrl');
+        }
+        else {
+            try {
+                new URL(target.baseUrl);
+            }
+            catch {
+                errors.push('UI target baseUrl must be a valid URL');
+            }
+        }
+        if (target.pages) {
+            for (const page of target.pages) {
+                try {
+                    // Handle both string URLs and object format { url, actions }
+                    const pageUrl = typeof page === 'string' ? page : (page && typeof page === 'object' && 'url' in page ? page.url : null);
+                    if (!pageUrl) {
+                        errors.push(`Invalid page: missing URL`);
+                        continue;
+                    }
+                    new URL(pageUrl, target.baseUrl);
+                }
+                catch {
+                    errors.push(`Invalid page URL: ${page}`);
+                }
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+}