cbrowser 2.3.0 → 3.0.0

package/dist/browser.js

@@ -5,12 +5,16 @@
  * AI-powered browser automation with constitutional safety.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CBrowser = void 0;
+exports.FluentCBrowser = exports.CBrowser = void 0;
+exports.parseNaturalLanguage = parseNaturalLanguage;
+exports.executeNaturalLanguage = executeNaturalLanguage;
+exports.executeNaturalLanguageScript = executeNaturalLanguageScript;
 const playwright_1 = require("playwright");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const config_js_1 = require("./config.js");
 const personas_js_1 = require("./personas.js");
+const types_js_1 = require("./types.js");
 class CBrowser {
     config;
     paths;
@@ -18,6 +22,10 @@ class CBrowser {
     context = null;
     page = null;
     currentPersona = null;
+    networkRequests = [];
+    networkResponses = new Map();
+    harEntries = [];
+    isRecordingHar = false;
     constructor(userConfig = {}) {
         this.config = (0, config_js_1.mergeConfig)(userConfig);
         this.paths = (0, config_js_1.ensureDirectories)((0, config_js_1.getPaths)(this.config.dataDir));
@@ -40,13 +48,77 @@ class CBrowser {
         this.browser = await browserType.launch({
             headless: this.config.headless,
         });
-        this.context = await this.browser.newContext({
+        // Build context options
+        const contextOptions = {
             viewport: {
                 width: this.config.viewportWidth,
                 height: this.config.viewportHeight,
             },
-        });
+        };
+        // Apply device emulation if configured
+        if (this.config.device && types_js_1.DEVICE_PRESETS[this.config.device]) {
+            const device = types_js_1.DEVICE_PRESETS[this.config.device];
+            contextOptions.viewport = device.viewport;
+            contextOptions.userAgent = device.userAgent;
+            contextOptions.deviceScaleFactor = device.deviceScaleFactor;
+            contextOptions.isMobile = device.isMobile;
+            contextOptions.hasTouch = device.hasTouch;
+        }
+        else if (this.config.deviceDescriptor) {
+            const device = this.config.deviceDescriptor;
+            contextOptions.viewport = device.viewport;
+            contextOptions.userAgent = device.userAgent;
+            contextOptions.deviceScaleFactor = device.deviceScaleFactor;
+            contextOptions.isMobile = device.isMobile;
+            contextOptions.hasTouch = device.hasTouch;
+        }
+        // Apply custom user agent if set (overrides device)
+        if (this.config.userAgent) {
+            contextOptions.userAgent = this.config.userAgent;
+        }
+        // Apply geolocation if configured
+        if (this.config.geolocation) {
+            contextOptions.geolocation = {
+                latitude: this.config.geolocation.latitude,
+                longitude: this.config.geolocation.longitude,
+                accuracy: this.config.geolocation.accuracy,
+            };
+            contextOptions.permissions = ["geolocation"];
+        }
+        // Apply locale if configured
+        if (this.config.locale) {
+            contextOptions.locale = this.config.locale;
+        }
+        // Apply timezone if configured
+        if (this.config.timezone) {
+            contextOptions.timezoneId = this.config.timezone;
+        }
+        // Apply color scheme if configured
+        if (this.config.colorScheme) {
+            contextOptions.colorScheme = this.config.colorScheme;
+        }
+        // Enable video recording if configured
+        if (this.config.recordVideo) {
+            const videoDir = this.config.videoDir || (0, path_1.join)(this.paths.dataDir, "videos");
+            if (!(0, fs_1.existsSync)(videoDir)) {
+                (0, fs_1.mkdirSync)(videoDir, { recursive: true });
+            }
+            contextOptions.recordVideo = {
+                dir: videoDir,
+                size: {
+                    width: contextOptions.viewport?.width || 1280,
+                    height: contextOptions.viewport?.height || 800,
+                },
+            };
+        }
+        this.context = await this.browser.newContext(contextOptions);
         this.page = await this.context.newPage();
+        // Apply network mocks if configured
+        if (this.config.networkMocks && this.config.networkMocks.length > 0) {
+            await this.setupNetworkMocks(this.config.networkMocks);
+        }
+        // Set up network request/response tracking for HAR
+        this.setupNetworkTracking();
     }
     /**
      * Close the browser.
@@ -69,6 +141,423 @@ class CBrowser {
         return this.page;
     }
     // =========================================================================
+    // Network Mocking
+    // =========================================================================
+    /**
+     * Set up network mocks for API interception.
+     */
+    async setupNetworkMocks(mocks) {
+        const page = this.page;
+        for (const mock of mocks) {
+            const pattern = typeof mock.urlPattern === "string"
+                ? new RegExp(mock.urlPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+                : mock.urlPattern;
+            await page.route(pattern, async (route) => {
+                const request = route.request();
+                // Check method match if specified
+                if (mock.method && request.method() !== mock.method.toUpperCase()) {
+                    await route.continue();
+                    return;
+                }
+                // Handle abort
+                if (mock.abort) {
+                    await route.abort();
+                    return;
+                }
+                // Apply delay if specified
+                if (mock.delay) {
+                    await new Promise((r) => setTimeout(r, mock.delay));
+                }
+                // Fulfill with mock response
+                const body = typeof mock.body === "object"
+                    ? JSON.stringify(mock.body)
+                    : mock.body || "";
+                await route.fulfill({
+                    status: mock.status || 200,
+                    headers: mock.headers || { "Content-Type": "application/json" },
+                    body,
+                });
+            });
+        }
+    }
+    /**
+     * Add a network mock at runtime.
+     */
+    async addNetworkMock(mock) {
+        const page = await this.getPage();
+        await this.setupNetworkMocks([mock]);
+    }
+    /**
+     * Clear all network mocks.
+     */
+    async clearNetworkMocks() {
+        const page = await this.getPage();
+        await page.unrouteAll();
+    }
+    // =========================================================================
+    // Network Tracking & HAR Export
+    // =========================================================================
+    /**
+     * Set up network request/response tracking for HAR.
+     */
+    setupNetworkTracking() {
+        if (!this.page)
+            return;
+        this.page.on("request", (request) => {
+            const networkRequest = {
+                url: request.url(),
+                method: request.method(),
+                headers: request.headers(),
+                postData: request.postData() || undefined,
+                resourceType: request.resourceType(),
+                timestamp: new Date().toISOString(),
+            };
+            this.networkRequests.push(networkRequest);
+            if (this.isRecordingHar) {
+                // Start HAR entry
+                const harEntry = {
+                    startedDateTime: new Date().toISOString(),
+                    request: {
+                        method: request.method(),
+                        url: request.url(),
+                        httpVersion: "HTTP/1.1",
+                        headers: Object.entries(request.headers()).map(([name, value]) => ({ name, value })),
+                        queryString: [],
+                        headersSize: -1,
+                        bodySize: request.postData()?.length || 0,
+                    },
+                };
+                this.networkResponses.set(request.url() + request.method(), harEntry);
+            }
+        });
+        this.page.on("response", async (response) => {
+            const key = response.url() + response.request().method();
+            const networkResponse = {
+                url: response.url(),
+                status: response.status(),
+                statusText: response.statusText(),
+                headers: response.headers(),
+            };
+            if (this.isRecordingHar && this.networkResponses.has(key)) {
+                const partial = this.networkResponses.get(key);
+                const startTime = new Date(partial.startedDateTime).getTime();
+                const endTime = Date.now();
+                const harEntry = {
+                    ...partial,
+                    time: endTime - startTime,
+                    response: {
+                        status: response.status(),
+                        statusText: response.statusText(),
+                        httpVersion: "HTTP/1.1",
+                        headers: Object.entries(response.headers()).map(([name, value]) => ({ name, value })),
+                        content: {
+                            size: parseInt(response.headers()["content-length"] || "0"),
+                            mimeType: response.headers()["content-type"] || "application/octet-stream",
+                        },
+                        redirectURL: response.headers()["location"] || "",
+                        headersSize: -1,
+                        bodySize: parseInt(response.headers()["content-length"] || "-1"),
+                    },
+                    cache: {},
+                    timings: {
+                        blocked: 0,
+                        dns: -1,
+                        connect: -1,
+                        send: 0,
+                        wait: endTime - startTime,
+                        receive: 0,
+                        ssl: -1,
+                    },
+                };
+                this.harEntries.push(harEntry);
+                this.networkResponses.delete(key);
+            }
+        });
+    }
+    /**
+     * Start recording HAR.
+     */
+    startHarRecording() {
+        this.isRecordingHar = true;
+        this.harEntries = [];
+    }
+    /**
+     * Stop recording and export HAR.
+     */
+    async exportHar(outputPath) {
+        this.isRecordingHar = false;
+        const harLog = {
+            version: "1.2",
+            creator: { name: "CBrowser", version: "2.4.0" },
+            entries: this.harEntries,
+        };
+        const har = { log: harLog };
+        const harDir = (0, path_1.join)(this.paths.dataDir, "har");
+        if (!(0, fs_1.existsSync)(harDir)) {
+            (0, fs_1.mkdirSync)(harDir, { recursive: true });
+        }
+        const filename = outputPath || (0, path_1.join)(harDir, `har-${Date.now()}.har`);
+        (0, fs_1.writeFileSync)(filename, JSON.stringify(har, null, 2));
+        return filename;
+    }
+    /**
+     * Get all captured network requests.
+     */
+    getNetworkRequests() {
+        return [...this.networkRequests];
+    }
+    /**
+     * Clear network request history.
+     */
+    clearNetworkHistory() {
+        this.networkRequests = [];
+        this.harEntries = [];
+    }
+    // =========================================================================
+    // Performance Metrics
+    // =========================================================================
+    /**
+     * Collect Core Web Vitals and performance metrics.
+     */
+    async getPerformanceMetrics() {
+        const page = await this.getPage();
+        const metrics = await page.evaluate(() => {
+            const result = {};
+            // Navigation timing
+            const navTiming = performance.getEntriesByType("navigation")[0];
+            if (navTiming) {
+                result.ttfb = navTiming.responseStart - navTiming.requestStart;
+                result.domContentLoaded = navTiming.domContentLoadedEventEnd - navTiming.startTime;
+                result.load = navTiming.loadEventEnd - navTiming.startTime;
+            }
+            // Paint timing
+            const paintEntries = performance.getEntriesByType("paint");
+            for (const entry of paintEntries) {
+                if (entry.name === "first-contentful-paint") {
+                    result.fcp = entry.startTime;
+                }
+            }
+            // LCP from PerformanceObserver (if available)
+            const lcpEntries = performance.getEntriesByType("largest-contentful-paint");
+            if (lcpEntries.length > 0) {
+                result.lcp = lcpEntries[lcpEntries.length - 1].startTime;
+            }
+            // CLS from layout-shift entries
+            const clsEntries = performance.getEntriesByType("layout-shift");
+            let clsScore = 0;
+            for (const entry of clsEntries) {
+                if (!entry.hadRecentInput) {
+                    clsScore += entry.value || 0;
+                }
+            }
+            result.cls = clsScore;
+            // Resource counts
+            const resources = performance.getEntriesByType("resource");
+            result.resourceCount = resources.length;
+            result.transferSize = resources.reduce((sum, r) => sum + (r.transferSize || 0), 0);
+            return result;
+        });
+        // Rate the metrics
+        const lcpRating = metrics.lcp
+            ? metrics.lcp <= 2500 ? "good" : metrics.lcp <= 4000 ? "needs-improvement" : "poor"
+            : undefined;
+        const clsRating = metrics.cls !== undefined
+            ? metrics.cls <= 0.1 ? "good" : metrics.cls <= 0.25 ? "needs-improvement" : "poor"
+            : undefined;
+        return {
+            lcp: metrics.lcp,
+            cls: metrics.cls,
+            fcp: metrics.fcp,
+            ttfb: metrics.ttfb,
+            domContentLoaded: metrics.domContentLoaded,
+            load: metrics.load,
+            resourceCount: metrics.resourceCount,
+            transferSize: metrics.transferSize,
+            lcpRating: lcpRating,
+            clsRating: clsRating,
+        };
+    }
+    /**
+     * Run a performance audit against a budget.
+     */
+    async auditPerformance(url) {
+        if (url) {
+            await this.navigate(url);
+        }
+        const page = await this.getPage();
+        const metrics = await this.getPerformanceMetrics();
+        const budget = this.config.performanceBudget;
+        const violations = [];
+        let passed = true;
+        if (budget) {
+            if (budget.lcp && metrics.lcp && metrics.lcp > budget.lcp) {
+                violations.push(`LCP ${metrics.lcp}ms exceeds budget ${budget.lcp}ms`);
+                passed = false;
+            }
+            if (budget.fcp && metrics.fcp && metrics.fcp > budget.fcp) {
+                violations.push(`FCP ${metrics.fcp}ms exceeds budget ${budget.fcp}ms`);
+                passed = false;
+            }
+            if (budget.cls && metrics.cls && metrics.cls > budget.cls) {
+                violations.push(`CLS ${metrics.cls} exceeds budget ${budget.cls}`);
+                passed = false;
+            }
+            if (budget.ttfb && metrics.ttfb && metrics.ttfb > budget.ttfb) {
+                violations.push(`TTFB ${metrics.ttfb}ms exceeds budget ${budget.ttfb}ms`);
+                passed = false;
+            }
+            if (budget.transferSize && metrics.transferSize && metrics.transferSize > budget.transferSize) {
+                violations.push(`Transfer size ${metrics.transferSize}B exceeds budget ${budget.transferSize}B`);
+                passed = false;
+            }
+            if (budget.resourceCount && metrics.resourceCount && metrics.resourceCount > budget.resourceCount) {
+                violations.push(`Resource count ${metrics.resourceCount} exceeds budget ${budget.resourceCount}`);
+                passed = false;
+            }
+        }
+        return {
+            url: page.url(),
+            timestamp: new Date().toISOString(),
+            metrics,
+            budget,
+            passed,
+            violations,
+        };
+    }
+    // =========================================================================
+    // Cookie Management
+    // =========================================================================
+    /**
+     * Get all cookies for the current context.
+     */
+    async getCookies(urls) {
+        if (!this.context) {
+            await this.launch();
+        }
+        return await this.context.cookies(urls);
+    }
+    /**
+     * Set cookies.
+     */
+    async setCookies(cookies) {
+        if (!this.context) {
+            await this.launch();
+        }
+        await this.context.addCookies(cookies);
+    }
+    /**
+     * Clear all cookies.
+     */
+    async clearCookies() {
+        if (!this.context)
+            return;
+        await this.context.clearCookies();
+    }
+    /**
+     * Delete specific cookies by name.
+     */
+    async deleteCookie(name, domain) {
+        const cookies = await this.getCookies();
+        const filtered = cookies.filter((c) => {
+            if (c.name !== name)
+                return true;
+            if (domain && c.domain !== domain)
+                return true;
+            return false;
+        });
+        await this.clearCookies();
+        if (filtered.length > 0) {
+            await this.setCookies(filtered);
+        }
+    }
+    // =========================================================================
+    // Video Recording
+    // =========================================================================
+    /**
+     * Get the path to the video file (after browser closes).
+     */
+    async getVideoPath() {
+        if (!this.page)
+            return null;
+        const video = this.page.video();
+        if (!video)
+            return null;
+        return await video.path();
+    }
+    /**
+     * Save the video with a custom filename.
+     */
+    async saveVideo(outputPath) {
+        if (!this.page)
+            return null;
+        const video = this.page.video();
+        if (!video)
+            return null;
+        await video.saveAs(outputPath);
+        return outputPath;
+    }
+    // =========================================================================
+    // Device Emulation
+    // =========================================================================
+    /**
+     * Set device emulation (requires browser restart).
+     */
+    setDevice(deviceName) {
+        if (types_js_1.DEVICE_PRESETS[deviceName]) {
+            this.config.device = deviceName;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * List available device presets.
+     */
+    static listDevices() {
+        return Object.keys(types_js_1.DEVICE_PRESETS);
+    }
+    // =========================================================================
+    // Geolocation
+    // =========================================================================
+    /**
+     * Set geolocation (requires browser restart or use setGeolocationRuntime).
+     */
+    setGeolocation(location) {
+        if (typeof location === "string") {
+            if (types_js_1.LOCATION_PRESETS[location]) {
+                this.config.geolocation = types_js_1.LOCATION_PRESETS[location];
+                return true;
+            }
+            return false;
+        }
+        this.config.geolocation = location;
+        return true;
+    }
+    /**
+     * Set geolocation at runtime without restarting.
+     */
+    async setGeolocationRuntime(location) {
+        if (!this.context)
+            return false;
+        let geo;
+        if (typeof location === "string") {
+            if (!types_js_1.LOCATION_PRESETS[location])
+                return false;
+            geo = types_js_1.LOCATION_PRESETS[location];
+        }
+        else {
+            geo = location;
+        }
+        await this.context.setGeolocation(geo);
+        await this.context.grantPermissions(["geolocation"]);
+        return true;
+    }
+    /**
+     * List available location presets.
+     */
+    static listLocations() {
+        return Object.keys(types_js_1.LOCATION_PRESETS);
+    }
+    // =========================================================================
     // Navigation
     // =========================================================================
     /**
@@ -620,6 +1109,457 @@ class CBrowser {
         stats.audit = countDir(this.paths.auditDir, /\.json$/i);
         return stats;
     }
+    /**
+     * Get the data directory path.
+     */
+    getDataDir() {
+        return this.paths.dataDir;
+    }
+    // =========================================================================
+    // Tier 2: Visual Regression (v2.5.0)
+    // =========================================================================
+    /**
+     * Save a visual baseline screenshot.
+     */
+    async saveBaseline(name, url) {
+        const baselinesDir = (0, path_1.join)(this.paths.dataDir, "baselines");
+        if (!(0, fs_1.existsSync)(baselinesDir)) {
+            (0, fs_1.mkdirSync)(baselinesDir, { recursive: true });
+        }
+        const page = await this.getPage();
+        const screenshotPath = (0, path_1.join)(baselinesDir, `${name}.png`);
+        await page.screenshot({ path: screenshotPath, fullPage: true });
+        const baseline = {
+            name,
+            url: url || page.url(),
+            viewport: page.viewportSize() || { width: 1280, height: 800 },
+            screenshotPath,
+            created: new Date().toISOString(),
+            lastUsed: new Date().toISOString(),
+        };
+        const metaPath = (0, path_1.join)(baselinesDir, `${name}.json`);
+        (0, fs_1.writeFileSync)(metaPath, JSON.stringify(baseline, null, 2));
+        return screenshotPath;
+    }
+    /**
+     * Compare current page to a baseline.
+     */
+    async compareBaseline(name, threshold = 0.1) {
+        const baselinesDir = (0, path_1.join)(this.paths.dataDir, "baselines");
+        const metaPath = (0, path_1.join)(baselinesDir, `${name}.json`);
+        if (!(0, fs_1.existsSync)(metaPath)) {
+            throw new Error(`Baseline not found: ${name}`);
+        }
+        const baseline = JSON.parse((0, fs_1.readFileSync)(metaPath, "utf-8"));
+        const page = await this.getPage();
+        const currentPath = (0, path_1.join)(baselinesDir, `${name}-current-${Date.now()}.png`);
+        await page.screenshot({ path: currentPath, fullPage: true });
+        const baselineBuffer = (0, fs_1.readFileSync)(baseline.screenshotPath);
+        const currentBuffer = (0, fs_1.readFileSync)(currentPath);
+        const sizeDiff = Math.abs(baselineBuffer.length - currentBuffer.length);
+        const maxSize = Math.max(baselineBuffer.length, currentBuffer.length);
+        const diffPercentage = sizeDiff / maxSize;
+        return {
+            baseline: baseline.screenshotPath,
+            current: currentPath,
+            diffPercentage,
+            passed: diffPercentage <= threshold,
+        };
+    }
+    /**
+     * List all visual baselines.
+     */
+    listBaselines() {
+        const baselinesDir = (0, path_1.join)(this.paths.dataDir, "baselines");
+        if (!(0, fs_1.existsSync)(baselinesDir))
+            return [];
+        return (0, fs_1.readdirSync)(baselinesDir)
+            .filter(f => f.endsWith(".json"))
+            .map(f => f.replace(".json", ""));
+    }
+    // =========================================================================
+    // Tier 2: Accessibility Audit (v2.5.0)
+    // =========================================================================
+    /**
+     * Run accessibility audit on current page.
+     */
+    async auditAccessibility() {
+        const page = await this.getPage();
+        const results = await page.evaluate(() => {
+            const violations = [];
+            // Check images without alt
+            document.querySelectorAll("img").forEach(img => {
+                if (!img.alt && !img.getAttribute("aria-label")) {
+                    violations.push({
+                        id: "img-alt",
+                        impact: "serious",
+                        description: "Image missing alt text",
+                        helpUrl: "https://dequeuniversity.com/rules/axe/4.4/image-alt",
+                    });
+                }
+            });
+            // Check buttons without text
+            document.querySelectorAll("button").forEach(btn => {
+                if (!btn.textContent?.trim() && !btn.getAttribute("aria-label")) {
+                    violations.push({
+                        id: "button-name",
+                        impact: "critical",
+                        description: "Button has no accessible name",
+                        helpUrl: "https://dequeuniversity.com/rules/axe/4.4/button-name",
+                    });
+                }
+            });
+            // Check inputs without labels
+            document.querySelectorAll("input:not([type='hidden'])").forEach(input => {
+                const id = input.id;
+                const hasLabel = id && document.querySelector(`label[for="${id}"]`);
+                if (!hasLabel && !input.getAttribute("aria-label")) {
+                    violations.push({
+                        id: "label",
+                        impact: "serious",
+                        description: "Form input missing label",
+                        helpUrl: "https://dequeuniversity.com/rules/axe/4.4/label",
+                    });
+                }
+            });
+            // Check lang attribute
+            if (!document.documentElement.lang) {
+                violations.push({
+                    id: "html-has-lang",
+                    impact: "serious",
+                    description: "Page missing lang attribute",
+                    helpUrl: "https://dequeuniversity.com/rules/axe/4.4/html-has-lang",
+                });
+            }
+            const passes = document.querySelectorAll("img[alt], button:not(:empty), label").length;
+            return { violations, passes };
+        });
+        const score = results.passes > 0
+            ? Math.round((results.passes / (results.passes + results.violations.length)) * 100)
+            : 100;
+        return {
+            url: page.url(),
+            violations: results.violations,
+            passes: results.passes,
+            score,
+        };
+    }
+    // =========================================================================
+    // Tier 2: Test Recording (v2.5.0)
+    // =========================================================================
+    recordingActions = [];
+    isRecording = false;
+    /**
+     * Start recording user interactions.
+     */
+    async startRecording(url) {
+        this.isRecording = true;
+        this.recordingActions = [];
+        if (url) {
+            await this.navigate(url);
+            this.recordingActions.push({ type: "navigate", url, timestamp: Date.now() });
+        }
+    }
+    /**
+     * Stop recording and return actions.
+     */
+    stopRecording() {
+        this.isRecording = false;
+        return [...this.recordingActions];
+    }
+    /**
+     * Save recording to file.
+     */
+    saveRecording(name, actions) {
+        const recordingsDir = (0, path_1.join)(this.paths.dataDir, "recordings");
+        if (!(0, fs_1.existsSync)(recordingsDir)) {
+            (0, fs_1.mkdirSync)(recordingsDir, { recursive: true });
+        }
+        const recording = {
+            name,
+            actions: actions || this.recordingActions,
+            created: new Date().toISOString(),
+        };
+        const filePath = (0, path_1.join)(recordingsDir, `${name}.json`);
+        (0, fs_1.writeFileSync)(filePath, JSON.stringify(recording, null, 2));
+        return filePath;
+    }
+    /**
+     * Generate test code from recording.
+     */
+    generateTestCode(name, actions) {
+        let code = `// Generated test: ${name}\n\n`;
+        code += `import { CBrowser } from 'cbrowser';\n\n`;
+        code += `async function test_${name.replace(/[^a-zA-Z0-9]/g, "_")}() {\n`;
+        code += `  const browser = new CBrowser();\n\n`;
+        for (const action of actions) {
+            switch (action.type) {
+                case "navigate":
+                    code += `  await browser.navigate("${action.url}");\n`;
+                    break;
+                case "click":
+                    code += `  await browser.click("${action.selector}");\n`;
+                    break;
+                case "fill":
+                    code += `  await browser.fill("${action.selector}", "${action.value}");\n`;
+                    break;
+            }
+        }
+        code += `\n  await browser.close();\n`;
+        code += `}\n\n`;
+        code += `test_${name.replace(/[^a-zA-Z0-9]/g, "_")}();\n`;
+        return code;
+    }
+    // =========================================================================
+    // Tier 2: Test Export (v2.5.0)
+    // =========================================================================
+    /**
+     * Export test results as JUnit XML.
+     */
+    exportJUnit(suite, outputPath) {
+        const filename = outputPath || (0, path_1.join)(this.paths.dataDir, `junit-${Date.now()}.xml`);
+        let xml = `<?xml version="1.0" encoding="UTF-8"?>\n`;
+        xml += `<testsuite name="${suite.name}" tests="${suite.tests.length}">\n`;
+        for (const test of suite.tests) {
+            xml += `  <testcase name="${test.name}" time="${(test.duration / 1000).toFixed(3)}">\n`;
+            if (test.status === "failed" && test.error) {
+                xml += `    <failure message="${test.error.replace(/"/g, "&quot;")}">${test.error}</failure>\n`;
+            }
+            xml += `  </testcase>\n`;
+        }
+        xml += `</testsuite>\n`;
+        (0, fs_1.writeFileSync)(filename, xml);
+        return filename;
+    }
+    /**
+     * Export test results as TAP format.
+     */
+    exportTAP(suite, outputPath) {
+        const filename = outputPath || (0, path_1.join)(this.paths.dataDir, `tap-${Date.now()}.tap`);
+        let tap = `TAP version 13\n`;
+        tap += `1..${suite.tests.length}\n`;
+        suite.tests.forEach((test, i) => {
+            const status = test.status === "passed" ? "ok" : "not ok";
+            tap += `${status} ${i + 1} ${test.name}\n`;
+        });
+        (0, fs_1.writeFileSync)(filename, tap);
+        return filename;
+    }
+    // =========================================================================
+    // Tier 2: Parallel Execution (v2.5.0)
+    // =========================================================================
+    /**
+     * Run multiple browser tasks in parallel.
+     */
+    static async parallel(tasks, options = {}) {
+        const maxConcurrency = options.maxConcurrency || tasks.length;
+        const results = [];
+        // Process tasks in batches
+        for (let i = 0; i < tasks.length; i += maxConcurrency) {
+            const batch = tasks.slice(i, i + maxConcurrency);
+            const batchResults = await Promise.all(batch.map(async (task) => {
+                const startTime = Date.now();
+                const browser = new CBrowser(task.config || {});
+                try {
+                    const result = await task.run(browser);
+                    return {
+                        name: task.name,
+                        result,
+                        duration: Date.now() - startTime,
+                    };
+                }
+                catch (e) {
+                    return {
+                        name: task.name,
+                        error: e.message,
+                        duration: Date.now() - startTime,
+                    };
+                }
+                finally {
+                    await browser.close();
+                }
+            }));
+            results.push(...batchResults);
+        }
+        return results;
+    }
+    /**
+     * Run the same task across multiple device configurations in parallel.
+     */
+    static async parallelDevices(devices, run, options = {}) {
+        const tasks = devices.map(device => ({
+            name: device,
+            config: { device },
+            run: (browser) => run(browser, device),
+        }));
+        const results = await CBrowser.parallel(tasks, options);
+        return results.map(r => ({ device: r.name, ...r }));
+    }
+    /**
+     * Run the same task across multiple URLs in parallel.
+     */
+    static async parallelUrls(urls, run, options = {}) {
+        const tasks = urls.map(url => ({
+            name: url,
+            config: options.config,
+            run: (browser) => run(browser, url),
+        }));
+        const results = await CBrowser.parallel(tasks, options);
+        return results.map(r => ({ url: r.name, ...r }));
+    }
+    // =========================================================================
+    // Tier 3: Fluent API (v3.0.0)
+    // =========================================================================
+    /**
+     * Fluent API - navigate and return chainable instance.
+     */
+    async goto(url) {
+        await this.navigate(url);
+        return new FluentCBrowser(this);
+    }
 }
 exports.CBrowser = CBrowser;
+/**
+ * Fluent wrapper for chainable API.
+ */
+class FluentCBrowser {
+    browser;
+    constructor(browser) {
+        this.browser = browser;
+    }
+    async click(selector, options) {
+        await this.browser.click(selector, options);
+        return this;
+    }
+    async fill(selector, value) {
+        await this.browser.fill(selector, value);
+        return this;
+    }
+    async screenshot(path) {
+        await this.browser.screenshot(path);
+        return this;
+    }
+    async wait(ms) {
+        await new Promise(resolve => setTimeout(resolve, ms));
+        return this;
+    }
+    async extract(what) {
+        const result = await this.browser.extract(what);
+        return { data: result.data, fluent: this };
+    }
+    async close() {
+        await this.browser.close();
+    }
+    get instance() {
+        return this.browser;
+    }
+}
+exports.FluentCBrowser = FluentCBrowser;
+// ============================================================================
+// Tier 3: Natural Language API (v3.0.0)
+// ============================================================================
+/**
+ * Natural language command patterns.
+ */
+const NL_PATTERNS = [
+    // Navigation
+    { pattern: /^(?:go to|navigate to|open|visit)\s+(.+)$/i, action: "navigate", extract: (m) => ({ url: m[1] }) },
+    { pattern: /^(?:go\s+)?back$/i, action: "back", extract: () => ({}) },
+    { pattern: /^(?:go\s+)?forward$/i, action: "forward", extract: () => ({}) },
+    { pattern: /^refresh|reload$/i, action: "reload", extract: () => ({}) },
+    // Clicking
+    { pattern: /^click(?:\s+on)?\s+(?:the\s+)?["']?(.+?)["']?$/i, action: "click", extract: (m) => ({ selector: m[1] }) },
+    { pattern: /^press(?:\s+the)?\s+["']?(.+?)["']?(?:\s+button)?$/i, action: "click", extract: (m) => ({ selector: m[1] }) },
+    { pattern: /^tap(?:\s+on)?\s+["']?(.+?)["']?$/i, action: "click", extract: (m) => ({ selector: m[1] }) },
+    // Form filling
+    { pattern: /^(?:type|enter|input|fill(?:\s+in)?)\s+["'](.+?)["']\s+(?:in(?:to)?|on)\s+(?:the\s+)?["']?(.+?)["']?$/i, action: "fill", extract: (m) => ({ value: m[1], selector: m[2] }) },
+    { pattern: /^(?:fill(?:\s+in)?|set)\s+(?:the\s+)?["']?(.+?)["']?\s+(?:to|with|as)\s+["'](.+?)["']$/i, action: "fill", extract: (m) => ({ selector: m[1], value: m[2] }) },
+    // Selecting
+    { pattern: /^select\s+["'](.+?)["']\s+(?:from|in)\s+(?:the\s+)?["']?(.+?)["']?$/i, action: "select", extract: (m) => ({ value: m[1], selector: m[2] }) },
+    { pattern: /^choose\s+["'](.+?)["']$/i, action: "click", extract: (m) => ({ selector: m[1] }) },
+    // Screenshots
+    { pattern: /^(?:take\s+a?\s*)?screenshot(?:\s+as\s+["']?(.+?)["']?)?$/i, action: "screenshot", extract: (m) => ({ path: m[1] || "" }) },
+    { pattern: /^capture(?:\s+the)?\s+(?:page|screen)$/i, action: "screenshot", extract: () => ({}) },
+    // Waiting
+    { pattern: /^wait(?:\s+for)?\s+(\d+)\s*(?:ms|milliseconds?)?$/i, action: "wait", extract: (m) => ({ ms: m[1] }) },
+    { pattern: /^wait(?:\s+for)?\s+(\d+)\s*(?:s|seconds?)$/i, action: "waitSeconds", extract: (m) => ({ seconds: m[1] }) },
+    { pattern: /^wait(?:\s+for)?\s+["']?(.+?)["']?(?:\s+to\s+appear)?$/i, action: "waitFor", extract: (m) => ({ selector: m[1] }) },
+    // Scrolling
+    { pattern: /^scroll\s+(?:to\s+)?(?:the\s+)?(top|bottom)$/i, action: "scroll", extract: (m) => ({ direction: m[1] }) },
+    { pattern: /^scroll\s+(up|down)(?:\s+(\d+))?$/i, action: "scrollBy", extract: (m) => ({ direction: m[1], amount: m[2] || "300" }) },
+    // Extraction
+    { pattern: /^(?:get|extract|find)\s+(?:all\s+)?(?:the\s+)?(.+)$/i, action: "extract", extract: (m) => ({ what: m[1] }) },
+];
+/**
+ * Parse natural language into browser action.
+ */
+function parseNaturalLanguage(command) {
+    const trimmed = command.trim();
+    for (const { pattern, action, extract } of NL_PATTERNS) {
+        const match = trimmed.match(pattern);
+        if (match) {
+            return { action, params: extract(match) };
+        }
+    }
+    return null;
+}
+/**
+ * Execute a natural language command.
+ */
+async function executeNaturalLanguage(browser, command) {
+    const parsed = parseNaturalLanguage(command);
+    if (!parsed) {
+        return { success: false, action: "unknown", error: `Could not parse command: "${command}"` };
+    }
+    const { action, params } = parsed;
+    try {
+        let result;
+        switch (action) {
+            case "navigate":
+                result = await browser.navigate(params.url);
+                break;
+            case "click":
+                result = await browser.click(params.selector);
+                break;
+            case "fill":
+                result = await browser.fill(params.selector, params.value);
+                break;
+            case "screenshot":
+                result = await browser.screenshot(params.path || undefined);
+                break;
+            case "wait":
+                await new Promise(r => setTimeout(r, parseInt(params.ms)));
+                result = { waited: parseInt(params.ms) };
+                break;
+            case "waitSeconds":
+                await new Promise(r => setTimeout(r, parseInt(params.seconds) * 1000));
+                result = { waited: parseInt(params.seconds) * 1000 };
+                break;
+            case "extract":
+                result = await browser.extract(params.what);
+                break;
+            default:
+                return { success: false, action, error: `Unsupported action: ${action}` };
+        }
+        return { success: true, action, result };
+    }
+    catch (e) {
+        return { success: false, action, error: e.message };
+    }
+}
+/**
+ * Execute multiple natural language commands in sequence.
+ */
+async function executeNaturalLanguageScript(browser, commands) {
+    const results = [];
+    for (const command of commands) {
+        if (!command.trim() || command.startsWith("#"))
+            continue; // Skip empty lines and comments
+        const result = await executeNaturalLanguage(browser, command);
+        results.push({ command, ...result });
+        if (!result.success)
+            break; // Stop on first error
+    }
+    return results;
+}
 //# sourceMappingURL=browser.js.map