cbrowser 8.7.3 → 8.9.0

package/dist/browser.js

@@ -1,17 +1,14 @@
-"use strict";
 /**
  * CBrowser - Main Browser Class
  *
  * AI-powered browser automation with constitutional safety.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FluentCBrowser = exports.CBrowser = void 0;
-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");
+import { chromium, firefox, webkit } from "playwright";
+import { existsSync, readFileSync, writeFileSync, readdirSync, statSync, unlinkSync, mkdirSync } from "fs";
+import { join } from "path";
+import { mergeConfig, getPaths, ensureDirectories } from "./config.js";
+import { BUILTIN_PERSONAS, getPersona } from "./personas.js";
+import { DEVICE_PRESETS, LOCATION_PRESETS } from "./types.js";
 // Browser-specific fast launch args for performance optimization
 const BROWSER_LAUNCH_ARGS = {
     // Chromium args - reduces cold start time significantly
@@ -44,7 +41,7 @@ const BROWSER_LAUNCH_ARGS = {
 };
 // Legacy alias for backward compatibility
 const FAST_LAUNCH_ARGS = BROWSER_LAUNCH_ARGS.chromium;
-class CBrowser {
+export class CBrowser {
     config;
     paths;
     browser = null;
@@ -57,14 +54,14 @@ class CBrowser {
     isRecordingHar = false;
     skipSessionRestore = 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));
+        this.config = mergeConfig(userConfig);
+        this.paths = ensureDirectories(getPaths(this.config.dataDir));
     }
     // =========================================================================
     // Session State Persistence
     // =========================================================================
     get sessionStateFile() {
-        return (0, path_1.join)(this.paths.dataDir, "browser-state", "last-session.json");
+        return join(this.paths.dataDir, "browser-state", "last-session.json");
     }
     saveSessionState(url, viewport) {
         try {
@@ -76,11 +73,11 @@ class CBrowser {
                 timestamp: Date.now(),
                 viewport,
             };
-            const stateDir = (0, path_1.join)(this.paths.dataDir, "browser-state");
-            if (!(0, fs_1.existsSync)(stateDir)) {
-                (0, fs_1.mkdirSync)(stateDir, { recursive: true });
+            const stateDir = join(this.paths.dataDir, "browser-state");
+            if (!existsSync(stateDir)) {
+                mkdirSync(stateDir, { recursive: true });
             }
-            (0, fs_1.writeFileSync)(this.sessionStateFile, JSON.stringify(state, null, 2));
+            writeFileSync(this.sessionStateFile, JSON.stringify(state, null, 2));
         }
         catch (e) {
             // Silently fail - this is a best-effort feature
@@ -88,14 +85,14 @@ class CBrowser {
     }
     loadSessionState() {
         try {
-            if (!(0, fs_1.existsSync)(this.sessionStateFile))
+            if (!existsSync(this.sessionStateFile))
                 return null;
-            const content = (0, fs_1.readFileSync)(this.sessionStateFile, "utf-8");
+            const content = readFileSync(this.sessionStateFile, "utf-8");
             const state = JSON.parse(content);
             // Expire sessions older than 1 hour
             const oneHour = 60 * 60 * 1000;
             if (Date.now() - state.timestamp > oneHour) {
-                (0, fs_1.unlinkSync)(this.sessionStateFile);
+                unlinkSync(this.sessionStateFile);
                 return null;
             }
             return state;
@@ -106,8 +103,8 @@ class CBrowser {
     }
     clearSessionState() {
         try {
-            if ((0, fs_1.existsSync)(this.sessionStateFile)) {
-                (0, fs_1.unlinkSync)(this.sessionStateFile);
+            if (existsSync(this.sessionStateFile)) {
+                unlinkSync(this.sessionStateFile);
             }
         }
         catch (e) {
@@ -125,10 +122,10 @@ class CBrowser {
             return;
         // Select browser engine based on config
         const browserType = this.config.browser === "firefox"
-            ? playwright_1.firefox
+            ? firefox
             : this.config.browser === "webkit"
-                ? playwright_1.webkit
-                : playwright_1.chromium;
+                ? webkit
+                : chromium;
         // Build context options
         const contextOptions = {
             viewport: {
@@ -137,8 +134,8 @@ class CBrowser {
             },
         };
         // 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];
+        if (this.config.device && DEVICE_PRESETS[this.config.device]) {
+            const device = DEVICE_PRESETS[this.config.device];
             contextOptions.viewport = device.viewport;
             contextOptions.userAgent = device.userAgent;
             contextOptions.deviceScaleFactor = device.deviceScaleFactor;
@@ -180,9 +177,9 @@ class CBrowser {
         }
         // 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 });
+            const videoDir = this.config.videoDir || join(this.paths.dataDir, "videos");
+            if (!existsSync(videoDir)) {
+                mkdirSync(videoDir, { recursive: true });
             }
             contextOptions.recordVideo = {
                 dir: videoDir,
@@ -196,9 +193,9 @@ class CBrowser {
         // Use browser-specific launch args for optimal performance
         const launchArgs = BROWSER_LAUNCH_ARGS[this.config.browser];
         if (this.config.persistent) {
-            const browserStateDir = (0, path_1.join)(this.paths.dataDir, "browser-state");
-            if (!(0, fs_1.existsSync)(browserStateDir)) {
-                (0, fs_1.mkdirSync)(browserStateDir, { recursive: true });
+            const browserStateDir = join(this.paths.dataDir, "browser-state");
+            if (!existsSync(browserStateDir)) {
+                mkdirSync(browserStateDir, { recursive: true });
             }
             this.context = await browserType.launchPersistentContext(browserStateDir, {
                 headless: this.config.headless,
@@ -285,11 +282,11 @@ class CBrowser {
         // Clear session state first (to prevent close() from saving)
         this.clearSessionState();
         await this.close();
-        const browserStateDir = (0, path_1.join)(this.paths.dataDir, "browser-state");
-        if ((0, fs_1.existsSync)(browserStateDir)) {
+        const browserStateDir = join(this.paths.dataDir, "browser-state");
+        if (existsSync(browserStateDir)) {
             const { rmSync } = await import("fs");
             rmSync(browserStateDir, { recursive: true, force: true });
-            (0, fs_1.mkdirSync)(browserStateDir, { recursive: true });
+            mkdirSync(browserStateDir, { recursive: true });
         }
         if (this.config.verbose) {
             console.log("🔄 Browser state reset");
@@ -486,12 +483,12 @@ class CBrowser {
             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 harDir = join(this.paths.dataDir, "har");
+        if (!existsSync(harDir)) {
+            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));
+        const filename = outputPath || join(harDir, `har-${Date.now()}.har`);
+        writeFileSync(filename, JSON.stringify(har, null, 2));
         return filename;
     }
     /**
@@ -697,7 +694,7 @@ class CBrowser {
      * Set device emulation (requires browser restart).
      */
     setDevice(deviceName) {
-        if (types_js_1.DEVICE_PRESETS[deviceName]) {
+        if (DEVICE_PRESETS[deviceName]) {
             this.config.device = deviceName;
             return true;
         }
@@ -707,7 +704,7 @@ class CBrowser {
      * List available device presets.
      */
     static listDevices() {
-        return Object.keys(types_js_1.DEVICE_PRESETS);
+        return Object.keys(DEVICE_PRESETS);
     }
     // =========================================================================
     // Geolocation
@@ -717,8 +714,8 @@ class CBrowser {
      */
     setGeolocation(location) {
         if (typeof location === "string") {
-            if (types_js_1.LOCATION_PRESETS[location]) {
-                this.config.geolocation = types_js_1.LOCATION_PRESETS[location];
+            if (LOCATION_PRESETS[location]) {
+                this.config.geolocation = LOCATION_PRESETS[location];
                 return true;
             }
             return false;
@@ -734,9 +731,9 @@ class CBrowser {
             return false;
         let geo;
         if (typeof location === "string") {
-            if (!types_js_1.LOCATION_PRESETS[location])
+            if (!LOCATION_PRESETS[location])
                 return false;
-            geo = types_js_1.LOCATION_PRESETS[location];
+            geo = LOCATION_PRESETS[location];
         }
         else {
             geo = location;
@@ -749,7 +746,7 @@ class CBrowser {
      * List available location presets.
      */
     static listLocations() {
-        return Object.keys(types_js_1.LOCATION_PRESETS);
+        return Object.keys(LOCATION_PRESETS);
     }
     // =========================================================================
     // Navigation
@@ -1072,6 +1069,382 @@ class CBrowser {
             };
         }
     }
+    // =========================================================================
+    // Custom Dropdown Handling (v8.8.0)
+    // Handles hidden <select> elements with custom dropdown UIs (Alpine.js, React Select, etc.)
+    // =========================================================================
+    /**
+     * Check if an element is visually hidden (but exists in DOM).
+     * Common patterns: display:none, visibility:hidden, opacity:0, zero dimensions,
+     * or positioned off-screen.
+     */
+    async isElementHidden(element) {
+        try {
+            const isHidden = await element.evaluate((el) => {
+                const style = getComputedStyle(el);
+                // Check common hiding methods
+                if (style.display === 'none')
+                    return true;
+                if (style.visibility === 'hidden')
+                    return true;
+                if (style.opacity === '0')
+                    return true;
+                // Check for zero dimensions
+                const rect = el.getBoundingClientRect();
+                if (rect.width === 0 || rect.height === 0)
+                    return true;
+                // Check for off-screen positioning
+                if (rect.right < 0 || rect.bottom < 0)
+                    return true;
+                if (rect.left > window.innerWidth || rect.top > window.innerHeight)
+                    return true;
+                // Check for clip-path hiding
+                if (style.clipPath === 'inset(100%)' || style.clip === 'rect(0, 0, 0, 0)')
+                    return true;
+                // Check for sr-only / screen-reader-only patterns
+                if (style.position === 'absolute' &&
+                    (parseInt(style.width) === 1 || parseInt(style.height) === 1) &&
+                    style.overflow === 'hidden')
+                    return true;
+                return false;
+            });
+            return isHidden;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Find the visible custom dropdown trigger associated with a hidden select.
+     * Uses multiple heuristics to locate the clickable UI element.
+     */
+    async findCustomDropdownTrigger(hiddenSelect) {
+        const page = await this.getPage();
+        try {
+            // Get info about the hidden select to help find its trigger
+            const selectInfo = await hiddenSelect.evaluate((el) => {
+                const select = el;
+                return {
+                    id: select.id,
+                    name: select.name,
+                    parentId: select.parentElement?.id,
+                    parentClasses: select.parentElement?.className,
+                    // Check for Alpine.js x-model binding
+                    xModel: select.getAttribute('x-model'),
+                    // Check for aria associations
+                    ariaLabelledBy: select.getAttribute('aria-labelledby'),
+                };
+            });
+            // Strategy 1: Look for adjacent sibling that's visible (common Alpine pattern)
+            const adjacentTrigger = await page.evaluate((selectInfo) => {
+                let select = null;
+                // Find the select by various methods
+                if (selectInfo.id) {
+                    select = document.getElementById(selectInfo.id);
+                }
+                if (!select && selectInfo.name) {
+                    select = document.querySelector(`select[name="${selectInfo.name}"]`);
+                }
+                if (!select)
+                    return null;
+                // Check next sibling
+                let sibling = select.nextElementSibling;
+                while (sibling) {
+                    const style = getComputedStyle(sibling);
+                    if (style.display !== 'none' && style.visibility !== 'hidden') {
+                        // Check if it looks like a dropdown trigger
+                        const hasClickIndicator = sibling.querySelector('[class*="chevron"], [class*="arrow"], [class*="caret"], svg') !== null;
+                        const hasRole = sibling.getAttribute('role') === 'button' || sibling.getAttribute('role') === 'combobox';
+                        const isButton = sibling.tagName === 'BUTTON';
+                        const hasDropdownClass = /dropdown|select|trigger|toggle/i.test(sibling.className);
+                        if (hasClickIndicator || hasRole || isButton || hasDropdownClass) {
+                            // Return a selector for this element
+                            if (sibling.id)
+                                return `#${sibling.id}`;
+                            if (sibling.className)
+                                return `.${sibling.className.split(' ')[0]}`;
+                            return null;
+                        }
+                    }
+                    sibling = sibling.nextElementSibling;
+                }
+                return null;
+            }, selectInfo);
+            if (adjacentTrigger) {
+                const trigger = page.locator(adjacentTrigger).first();
+                if (await trigger.isVisible()) {
+                    return trigger;
+                }
+            }
+            // Strategy 2: Look for parent container with click handler/dropdown classes
+            const parentTrigger = await page.evaluate((selectInfo) => {
+                let select = null;
+                if (selectInfo.id) {
+                    select = document.getElementById(selectInfo.id);
+                }
+                if (!select && selectInfo.name) {
+                    select = document.querySelector(`select[name="${selectInfo.name}"]`);
+                }
+                if (!select)
+                    return null;
+                // Walk up to find a clickable parent container
+                let parent = select.parentElement;
+                let depth = 0;
+                while (parent && depth < 5) {
+                    const style = getComputedStyle(parent);
+                    if (style.display !== 'none' && style.visibility !== 'hidden') {
+                        // Check for Alpine x-data (indicates interactive component)
+                        const hasAlpineData = parent.hasAttribute('x-data');
+                        const hasDropdownClass = /dropdown|select|combobox|listbox/i.test(parent.className);
+                        const hasRole = parent.getAttribute('role') === 'combobox' || parent.getAttribute('role') === 'listbox';
+                        if (hasAlpineData || hasDropdownClass || hasRole) {
+                            // Look for a visible clickable child
+                            const clickable = parent.querySelector('button, [role="button"], [tabindex="0"], div[class*="trigger"], div[class*="selected"]');
+                            if (clickable) {
+                                const clickableStyle = getComputedStyle(clickable);
+                                if (clickableStyle.display !== 'none') {
+                                    if (clickable.id)
+                                        return `#${clickable.id}`;
+                                    if (clickable.className)
+                                        return `.${clickable.className.split(' ')[0]}`;
+                                }
+                            }
+                            // If parent itself looks clickable
+                            if (parent.id)
+                                return `#${parent.id}`;
+                            if (parent.className)
+                                return `.${parent.className.split(' ')[0]}`;
+                        }
+                    }
+                    parent = parent.parentElement;
+                    depth++;
+                }
+                return null;
+            }, selectInfo);
+            if (parentTrigger) {
+                const trigger = page.locator(parentTrigger).first();
+                if (await trigger.isVisible()) {
+                    return trigger;
+                }
+            }
+            // Strategy 3: Look for aria-controls or aria-labelledby relationships
+            if (selectInfo.ariaLabelledBy) {
+                const trigger = page.locator(`#${selectInfo.ariaLabelledBy}`).first();
+                if (await trigger.isVisible()) {
+                    return trigger;
+                }
+            }
+            // Strategy 4: Find any visible element with matching x-model (Alpine.js)
+            if (selectInfo.xModel) {
+                const alpineTrigger = await page.evaluate((xModel) => {
+                    // Look for visible elements with same x-model that aren't the select
+                    const elements = Array.from(document.querySelectorAll(`[x-model="${xModel}"], [\\@click*="${xModel}"]`));
+                    for (let i = 0; i < elements.length; i++) {
+                        const el = elements[i];
+                        if (el.tagName !== 'SELECT') {
+                            const style = getComputedStyle(el);
+                            if (style.display !== 'none' && style.visibility !== 'hidden') {
+                                if (el.id)
+                                    return `#${el.id}`;
+                                if (el.className)
+                                    return `.${el.className.split(' ')[0]}`;
+                            }
+                        }
+                    }
+                    return null;
+                }, selectInfo.xModel);
+                if (alpineTrigger) {
+                    const trigger = page.locator(alpineTrigger).first();
+                    if (await trigger.isVisible()) {
+                        return trigger;
+                    }
+                }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Find and select an option in a custom dropdown.
+     * Opens the dropdown, waits for options, and clicks the target option.
+     */
+    async selectCustomDropdownOption(trigger, optionValue, options = {}) {
+        const page = await this.getPage();
+        const timeout = options.timeout ?? 5000;
+        try {
+            // Click the trigger to open the dropdown
+            if (options.verbose)
+                console.log(`  Opening dropdown by clicking trigger`);
+            await trigger.click();
+            // Wait for dropdown options to appear
+            // Try multiple common patterns for option containers
+            const optionSelectors = [
+                // Alpine.js / Headless UI patterns
+                '[x-show]:not([x-show="false"])',
+                '[role="listbox"]',
+                '[role="menu"]',
+                '[role="option"]',
+                // Common class patterns
+                '[class*="dropdown-menu"]:not([class*="hidden"])',
+                '[class*="select-options"]',
+                '[class*="listbox-options"]',
+                '[class*="menu-items"]',
+                // Generic visible dropdown
+                '.dropdown-content:visible',
+                '.dropdown-options',
+                // React Select patterns
+                '[class*="menu"]',
+                '[class*="MenuList"]',
+            ];
+            await page.waitForTimeout(200); // Brief wait for animation
+            // Find the option with matching text
+            if (options.verbose)
+                console.log(`  Looking for option: "${optionValue}"`);
+            // Strategy 1: Find by exact text match
+            const optionByText = page.getByRole('option', { name: optionValue });
+            if (await optionByText.isVisible({ timeout: 500 }).catch(() => false)) {
+                await optionByText.click();
+                return { success: true, strategy: 'role-option-exact' };
+            }
+            // Strategy 2: Find by partial text match in role=option
+            const optionByPartial = page.locator('[role="option"]').filter({ hasText: optionValue }).first();
+            if (await optionByPartial.isVisible({ timeout: 500 }).catch(() => false)) {
+                await optionByPartial.click();
+                return { success: true, strategy: 'role-option-partial' };
+            }
+            // Strategy 3: Find by li elements (common dropdown pattern)
+            const liOption = page.locator('li').filter({ hasText: optionValue }).first();
+            if (await liOption.isVisible({ timeout: 500 }).catch(() => false)) {
+                await liOption.click();
+                return { success: true, strategy: 'li-element' };
+            }
+            // Strategy 4: Find any clickable element with the text
+            const anyOption = page.locator(`text="${optionValue}"`).first();
+            if (await anyOption.isVisible({ timeout: 500 }).catch(() => false)) {
+                await anyOption.click();
+                return { success: true, strategy: 'text-match' };
+            }
+            // Strategy 5: Find by data-value attribute
+            const dataValueOption = page.locator(`[data-value="${optionValue}"], [value="${optionValue}"]`).first();
+            if (await dataValueOption.isVisible({ timeout: 500 }).catch(() => false)) {
+                await dataValueOption.click();
+                return { success: true, strategy: 'data-value' };
+            }
+            // If we couldn't find the option, close dropdown and report
+            await page.keyboard.press('Escape');
+            return {
+                success: false,
+                error: `Could not find option "${optionValue}" in dropdown`
+            };
+        }
+        catch (e) {
+            // Try to close any open dropdown
+            await page.keyboard.press('Escape').catch(() => { });
+            return {
+                success: false,
+                error: `Custom dropdown selection failed: ${e instanceof Error ? e.message : String(e)}`
+            };
+        }
+    }
+    /**
+     * Handle filling a custom dropdown (hidden select with custom UI).
+     * Automatically detects and interacts with the visible dropdown component.
+     */
+    async handleCustomDropdown(hiddenSelect, value, options = {}) {
+        if (options.verbose)
+            console.log(`  Detected hidden select, looking for custom dropdown trigger`);
+        // Find the visible trigger element
+        const trigger = await this.findCustomDropdownTrigger(hiddenSelect);
+        if (!trigger) {
+            return {
+                success: false,
+                error: 'Could not find custom dropdown trigger for hidden select'
+            };
+        }
+        if (options.verbose)
+            console.log(`  Found dropdown trigger`);
+        // Try to select the option
+        const result = await this.selectCustomDropdownOption(trigger, value, options);
+        return result;
+    }
+    /**
+     * Find the best click candidate from multiple matches.
+     * Prioritizes: exact text match > non-sticky elements > shorter text (closer match)
+     */
+    async findBestClickCandidate(locator, searchText) {
+        const page = await this.getPage();
+        const count = await locator.count();
+        if (count === 0)
+            return null;
+        if (count === 1)
+            return locator.first();
+        // Score each candidate
+        const candidates = [];
+        const searchLower = searchText.toLowerCase();
+        for (let i = 0; i < count; i++) {
+            const el = locator.nth(i);
+            let score = 0;
+            try {
+                const info = await el.evaluate((element, search) => {
+                    const text = element.textContent?.trim() || '';
+                    const style = getComputedStyle(element);
+                    // Check if element is in a sticky/fixed container
+                    let inStickyContainer = false;
+                    let parent = element;
+                    while (parent) {
+                        const parentStyle = getComputedStyle(parent);
+                        if (parentStyle.position === 'fixed' || parentStyle.position === 'sticky') {
+                            inStickyContainer = true;
+                            break;
+                        }
+                        parent = parent.parentElement;
+                    }
+                    // Check for exact text match vs partial
+                    const textLower = text.toLowerCase();
+                    const isExactMatch = textLower === search.toLowerCase();
+                    const isPartialMatch = textLower.includes(search.toLowerCase());
+                    // Get element role/type info
+                    const tagName = element.tagName.toLowerCase();
+                    const role = element.getAttribute('role');
+                    const isInteractive = ['button', 'a', 'input', 'select'].includes(tagName) ||
+                        ['button', 'link', 'option'].includes(role || '');
+                    return {
+                        text,
+                        textLength: text.length,
+                        inStickyContainer,
+                        isExactMatch,
+                        isPartialMatch,
+                        isInteractive,
+                    };
+                }, searchLower);
+                // Scoring:
+                // +100: exact text match
+                // +50: not in sticky container
+                // +20: is interactive element
+                // -1 per extra character (prefer shorter matches)
+                if (info.isExactMatch)
+                    score += 100;
+                if (!info.inStickyContainer)
+                    score += 50;
+                if (info.isInteractive)
+                    score += 20;
+                score -= Math.abs(info.textLength - searchText.length);
+                candidates.push({ index: i, score });
+            }
+            catch {
+                // If evaluation fails, give low score
+                candidates.push({ index: i, score: -1000 });
+            }
+        }
+        // Sort by score descending and return the best match
+        candidates.sort((a, b) => b.score - a.score);
+        if (candidates.length > 0 && candidates[0].score > -1000) {
+            return locator.nth(candidates[0].index);
+        }
+        return locator.first();
+    }
     /**
      * Hover then click - useful for dropdown menus that need hover to reveal items.
      * ALWAYS hovers the parent menu and keeps it hovered while clicking the submenu item.
@@ -1203,6 +1576,44 @@ class CBrowser {
                 }
                 return result;
             }
+            // Check if the element is hidden (custom dropdown/input pattern)
+            const isHidden = await this.isElementHidden(element);
+            if (isHidden) {
+                if (options.verbose)
+                    console.log(`  Element "${selector}" is hidden, checking for custom UI component`);
+                // Get the tag name to determine handling strategy
+                const tagName = await element.evaluate((el) => el.tagName.toLowerCase());
+                if (tagName === 'select') {
+                    // Hidden select with custom dropdown UI
+                    const customResult = await this.handleCustomDropdown(element, value, options);
+                    if (customResult.success) {
+                        this.audit("fill", `${selector} (custom-dropdown:${customResult.strategy})`, "yellow", "success");
+                        return {
+                            success: true,
+                            screenshot: await this.screenshot(),
+                            message: `Filled custom dropdown: ${selector} (strategy: ${customResult.strategy})`,
+                        };
+                    }
+                    else {
+                        // Fall through to try standard fill anyway
+                        if (options.verbose)
+                            console.log(`  Custom dropdown handling failed: ${customResult.error}`);
+                    }
+                }
+                else if (tagName === 'input') {
+                    // Hidden input - might be part of autocomplete, datepicker, etc.
+                    const customResult = await this.handleCustomInput(element, value, options);
+                    if (customResult.success) {
+                        this.audit("fill", `${selector} (custom-input:${customResult.strategy})`, "yellow", "success");
+                        return {
+                            success: true,
+                            screenshot: await this.screenshot(),
+                            message: `Filled custom input: ${selector} (strategy: ${customResult.strategy})`,
+                        };
+                    }
+                }
+            }
+            // Standard fill - works for visible inputs and textareas
             await element.fill(value);
             this.audit("fill", selector, "yellow", "success");
             return {
@@ -1231,6 +1642,111 @@ class CBrowser {
             return result;
         }
     }
+    /**
+     * Handle filling a custom input (hidden input with custom UI).
+     * Handles autocomplete, datepickers, custom text inputs, etc.
+     */
+    async handleCustomInput(hiddenInput, value, options = {}) {
+        const page = await this.getPage();
+        try {
+            // Get input info to help find its visible counterpart
+            const inputInfo = await hiddenInput.evaluate((el) => {
+                const input = el;
+                return {
+                    id: input.id,
+                    name: input.name,
+                    type: input.type,
+                    ariaLabelledBy: input.getAttribute('aria-labelledby'),
+                    xModel: input.getAttribute('x-model'),
+                };
+            });
+            // Strategy 1: Look for visible sibling input or wrapper
+            const adjacentVisible = await page.evaluate((inputInfo) => {
+                let input = null;
+                if (inputInfo.id)
+                    input = document.getElementById(inputInfo.id);
+                if (!input && inputInfo.name)
+                    input = document.querySelector(`input[name="${inputInfo.name}"]`);
+                if (!input)
+                    return null;
+                // Check parent container for visible input
+                const parent = input.closest('[x-data], .form-group, .input-wrapper, .field-container');
+                if (parent) {
+                    const visibleInputs = Array.from(parent.querySelectorAll('input:not([type="hidden"])'));
+                    for (let i = 0; i < visibleInputs.length; i++) {
+                        const vi = visibleInputs[i];
+                        const style = getComputedStyle(vi);
+                        if (style.display !== 'none' && style.visibility !== 'hidden') {
+                            if (vi.id)
+                                return { selector: `#${vi.id}`, type: 'visible-input' };
+                            if (vi.name)
+                                return { selector: `input[name="${vi.name}"]`, type: 'visible-input' };
+                        }
+                    }
+                    // Check for text display element that might be the "face" of a custom input
+                    const textDisplay = parent.querySelector('[contenteditable="true"], .editable, .input-display');
+                    if (textDisplay) {
+                        const style = getComputedStyle(textDisplay);
+                        if (style.display !== 'none') {
+                            if (textDisplay.id)
+                                return { selector: `#${textDisplay.id}`, type: 'contenteditable' };
+                        }
+                    }
+                }
+                return null;
+            }, inputInfo);
+            if (adjacentVisible) {
+                if (adjacentVisible.type === 'visible-input') {
+                    const visibleInput = page.locator(adjacentVisible.selector).first();
+                    await visibleInput.fill(value);
+                    return { success: true, strategy: 'visible-sibling-input' };
+                }
+                else if (adjacentVisible.type === 'contenteditable') {
+                    const editableEl = page.locator(adjacentVisible.selector).first();
+                    await editableEl.click();
+                    await editableEl.fill(value);
+                    return { success: true, strategy: 'contenteditable' };
+                }
+            }
+            // Strategy 2: For datepickers, try clicking the wrapper and typing
+            if (inputInfo.type === 'date' || inputInfo.type === 'datetime-local' || inputInfo.type === 'time') {
+                const wrapper = await page.evaluate((inputInfo) => {
+                    let input = null;
+                    if (inputInfo.id)
+                        input = document.getElementById(inputInfo.id);
+                    if (!input && inputInfo.name)
+                        input = document.querySelector(`input[name="${inputInfo.name}"]`);
+                    if (!input)
+                        return null;
+                    const parent = input.closest('.datepicker, .date-input, [class*="picker"]');
+                    if (parent) {
+                        if (parent.id)
+                            return `#${parent.id}`;
+                    }
+                    return null;
+                }, inputInfo);
+                if (wrapper) {
+                    const wrapperEl = page.locator(wrapper).first();
+                    await wrapperEl.click();
+                    await page.keyboard.type(value);
+                    return { success: true, strategy: 'datepicker-type' };
+                }
+            }
+            // Strategy 3: Set value directly via JavaScript (last resort)
+            await hiddenInput.evaluate((el, val) => {
+                el.value = val;
+                el.dispatchEvent(new Event('input', { bubbles: true }));
+                el.dispatchEvent(new Event('change', { bubbles: true }));
+            }, value);
+            return { success: true, strategy: 'js-value-set' };
+        }
+        catch (e) {
+            return {
+                success: false,
+                error: `Custom input handling failed: ${e instanceof Error ? e.message : String(e)}`
+            };
+        }
+    }
     // =========================================================================
     // Tier 5: Smart Retry (v5.0.0)
     // =========================================================================
@@ -1672,7 +2188,7 @@ class CBrowser {
      * Get the selector cache file path.
      */
     getSelectorCachePath() {
-        return (0, path_1.join)(this.paths.dataDir, "selector-cache.json");
+        return join(this.paths.dataDir, "selector-cache.json");
     }
     /**
      * Load the selector cache from disk.
@@ -1681,9 +2197,9 @@ class CBrowser {
         if (this.selectorCache)
             return this.selectorCache;
         const cachePath = this.getSelectorCachePath();
-        if ((0, fs_1.existsSync)(cachePath)) {
+        if (existsSync(cachePath)) {
             try {
-                const data = (0, fs_1.readFileSync)(cachePath, "utf-8");
+                const data = readFileSync(cachePath, "utf-8");
                 this.selectorCache = JSON.parse(data);
                 return this.selectorCache;
             }
@@ -1701,7 +2217,7 @@ class CBrowser {
         if (!this.selectorCache)
             return;
         const cachePath = this.getSelectorCachePath();
-        (0, fs_1.writeFileSync)(cachePath, JSON.stringify(this.selectorCache, null, 2));
+        writeFileSync(cachePath, JSON.stringify(this.selectorCache, null, 2));
     }
     /**
      * Get cache key for a selector (includes domain for context).
@@ -2263,7 +2779,7 @@ class CBrowser {
             // Take screenshot
             const dir = options.debugDir || this.paths.screenshotsDir;
             const filename = `debug-${Date.now()}.png`;
-            const filepath = (0, path_1.join)(dir, filename);
+            const filepath = join(dir, filename);
             await page.screenshot({ path: filepath, fullPage: false });
             // Clean up highlights
             await page.evaluate(() => {
@@ -2448,10 +2964,30 @@ class CBrowser {
             const [role, name] = selector.slice(5).split("/");
             return page.getByRole(role, { name }).first();
         }
-        // Strategy 3: Text content
-        const byText = page.getByText(selector, { exact: false }).first();
-        if (await byText.count() > 0) {
-            return byText;
+        // Strategy 3: Text content - prefer exact matches over fuzzy, non-sticky over sticky
+        // First, try exact text match
+        const byTextExact = page.getByText(selector, { exact: true });
+        const exactCount = await byTextExact.count();
+        if (exactCount > 0) {
+            // If multiple exact matches, prefer non-sticky elements
+            if (exactCount > 1) {
+                const bestMatch = await this.findBestClickCandidate(byTextExact, selector);
+                if (bestMatch)
+                    return bestMatch;
+            }
+            return byTextExact.first();
+        }
+        // Then try partial/fuzzy text match (but with sticky deprioritization)
+        const byTextFuzzy = page.getByText(selector, { exact: false });
+        const fuzzyCount = await byTextFuzzy.count();
+        if (fuzzyCount > 0) {
+            // If multiple fuzzy matches, prefer non-sticky elements and shorter/exact matches
+            if (fuzzyCount > 1) {
+                const bestMatch = await this.findBestClickCandidate(byTextFuzzy, selector);
+                if (bestMatch)
+                    return bestMatch;
+            }
+            return byTextFuzzy.first();
         }
         // Strategy 4: Placeholder
         const byPlaceholder = page.getByPlaceholder(selector).first();
@@ -2631,7 +3167,7 @@ class CBrowser {
      */
     async screenshot(path) {
         const page = await this.getPage();
-        const filename = path || (0, path_1.join)(this.paths.screenshotsDir, `screenshot-${Date.now()}.png`);
+        const filename = path || join(this.paths.screenshotsDir, `screenshot-${Date.now()}.png`);
         await page.screenshot({ path: filename, fullPage: false });
         return filename;
     }
@@ -2691,18 +3227,18 @@ class CBrowser {
             localStorage,
             sessionStorage,
         };
-        const sessionPath = (0, path_1.join)(this.paths.sessionsDir, `${name}.json`);
-        (0, fs_1.writeFileSync)(sessionPath, JSON.stringify(session, null, 2));
+        const sessionPath = join(this.paths.sessionsDir, `${name}.json`);
+        writeFileSync(sessionPath, JSON.stringify(session, null, 2));
     }
     /**
      * Load a saved session.
      */
     async loadSession(name) {
-        const sessionPath = (0, path_1.join)(this.paths.sessionsDir, `${name}.json`);
-        if (!(0, fs_1.existsSync)(sessionPath)) {
+        const sessionPath = join(this.paths.sessionsDir, `${name}.json`);
+        if (!existsSync(sessionPath)) {
             return { success: false, name, cookiesRestored: 0, localStorageKeysRestored: 0, sessionStorageKeysRestored: 0 };
         }
-        const session = JSON.parse((0, fs_1.readFileSync)(sessionPath, "utf-8"));
+        const session = JSON.parse(readFileSync(sessionPath, "utf-8"));
         const page = await this.getPage();
         const context = this.context;
         const result = {
@@ -2747,29 +3283,29 @@ class CBrowser {
         await page.reload({ waitUntil: "networkidle" });
         // Update lastUsed
         session.lastUsed = new Date().toISOString();
-        (0, fs_1.writeFileSync)(sessionPath, JSON.stringify(session, null, 2));
+        writeFileSync(sessionPath, JSON.stringify(session, null, 2));
         return result;
     }
     /**
      * List all saved session names.
      */
     listSessions() {
-        const files = (0, fs_1.readdirSync)(this.paths.sessionsDir);
+        const files = readdirSync(this.paths.sessionsDir);
         return files.filter((f) => f.endsWith(".json") && f !== "last-session.json").map((f) => f.replace(".json", ""));
     }
     /**
      * List all saved sessions with rich metadata.
      */
     listSessionsDetailed() {
-        const files = (0, fs_1.readdirSync)(this.paths.sessionsDir);
+        const files = readdirSync(this.paths.sessionsDir);
         const sessions = [];
         for (const file of files) {
             if (!file.endsWith(".json") || file === "last-session.json")
                 continue;
-            const filePath = (0, path_1.join)(this.paths.sessionsDir, file);
+            const filePath = join(this.paths.sessionsDir, file);
             try {
-                const data = JSON.parse((0, fs_1.readFileSync)(filePath, "utf-8"));
-                const stats = (0, fs_1.statSync)(filePath);
+                const data = JSON.parse(readFileSync(filePath, "utf-8"));
+                const stats = statSync(filePath);
                 sessions.push({
                     name: data.name || file.replace(".json", ""),
                     created: data.created,
@@ -2792,11 +3328,11 @@ class CBrowser {
      * Get detailed info for a single session.
      */
     getSessionDetails(name) {
-        const sessionPath = (0, path_1.join)(this.paths.sessionsDir, `${name}.json`);
-        if (!(0, fs_1.existsSync)(sessionPath))
+        const sessionPath = join(this.paths.sessionsDir, `${name}.json`);
+        if (!existsSync(sessionPath))
             return null;
         try {
-            return JSON.parse((0, fs_1.readFileSync)(sessionPath, "utf-8"));
+            return JSON.parse(readFileSync(sessionPath, "utf-8"));
         }
         catch {
             return null;
@@ -2806,9 +3342,9 @@ class CBrowser {
      * Delete a saved session.
      */
     deleteSession(name) {
-        const sessionPath = (0, path_1.join)(this.paths.sessionsDir, `${name}.json`);
-        if ((0, fs_1.existsSync)(sessionPath)) {
-            (0, fs_1.unlinkSync)(sessionPath);
+        const sessionPath = join(this.paths.sessionsDir, `${name}.json`);
+        if (existsSync(sessionPath)) {
+            unlinkSync(sessionPath);
             return true;
         }
         return false;
@@ -2820,17 +3356,17 @@ class CBrowser {
         const cutoff = Date.now() - olderThanDays * 24 * 60 * 60 * 1000;
         const deleted = [];
         const kept = [];
-        const files = (0, fs_1.readdirSync)(this.paths.sessionsDir);
+        const files = readdirSync(this.paths.sessionsDir);
         for (const file of files) {
             if (!file.endsWith(".json") || file === "last-session.json")
                 continue;
-            const filePath = (0, path_1.join)(this.paths.sessionsDir, file);
+            const filePath = join(this.paths.sessionsDir, file);
             const name = file.replace(".json", "");
             try {
-                const data = JSON.parse((0, fs_1.readFileSync)(filePath, "utf-8"));
+                const data = JSON.parse(readFileSync(filePath, "utf-8"));
                 const lastUsed = new Date(data.lastUsed).getTime();
                 if (lastUsed < cutoff) {
-                    (0, fs_1.unlinkSync)(filePath);
+                    unlinkSync(filePath);
                     deleted.push(name);
                 }
                 else {
@@ -2847,24 +3383,24 @@ class CBrowser {
      * Export a session to a portable JSON file.
      */
     exportSession(name, outputPath) {
-        const sessionPath = (0, path_1.join)(this.paths.sessionsDir, `${name}.json`);
-        if (!(0, fs_1.existsSync)(sessionPath))
+        const sessionPath = join(this.paths.sessionsDir, `${name}.json`);
+        if (!existsSync(sessionPath))
             return false;
-        const data = (0, fs_1.readFileSync)(sessionPath, "utf-8");
-        (0, fs_1.writeFileSync)(outputPath, data);
+        const data = readFileSync(sessionPath, "utf-8");
+        writeFileSync(outputPath, data);
         return true;
     }
     /**
      * Import a session from a JSON file.
      */
     importSession(inputPath, name) {
-        if (!(0, fs_1.existsSync)(inputPath))
+        if (!existsSync(inputPath))
             return false;
         try {
-            const data = JSON.parse((0, fs_1.readFileSync)(inputPath, "utf-8"));
+            const data = JSON.parse(readFileSync(inputPath, "utf-8"));
             data.name = name;
-            const sessionPath = (0, path_1.join)(this.paths.sessionsDir, `${name}.json`);
-            (0, fs_1.writeFileSync)(sessionPath, JSON.stringify(data, null, 2));
+            const sessionPath = join(this.paths.sessionsDir, `${name}.json`);
+            writeFileSync(sessionPath, JSON.stringify(data, null, 2));
             return true;
         }
         catch {
@@ -2879,7 +3415,7 @@ class CBrowser {
      */
     async journey(options) {
         const { persona: personaName, startUrl, goal, maxSteps = 20 } = options;
-        const persona = (0, personas_js_1.getPersona)(personaName) || personas_js_1.BUILTIN_PERSONAS["first-timer"];
+        const persona = getPersona(personaName) || BUILTIN_PERSONAS["first-timer"];
         this.currentPersona = persona;
         // Set viewport based on persona
         if (persona.context?.viewport) {
@@ -2969,8 +3505,8 @@ class CBrowser {
             consoleLogs,
         };
         // Save journey results
-        const journeyFile = (0, path_1.join)(this.paths.dataDir, `journey-${Date.now()}.json`);
-        (0, fs_1.writeFileSync)(journeyFile, JSON.stringify(result, null, 2));
+        const journeyFile = join(this.paths.dataDir, `journey-${Date.now()}.json`);
+        writeFileSync(journeyFile, JSON.stringify(result, null, 2));
         return result;
     }
     /**
@@ -3027,13 +3563,13 @@ class CBrowser {
             result,
             persona: this.currentPersona?.name,
         };
-        const auditFile = (0, path_1.join)(this.paths.auditDir, `audit-${new Date().toISOString().split("T")[0]}.json`);
+        const auditFile = join(this.paths.auditDir, `audit-${new Date().toISOString().split("T")[0]}.json`);
         let entries = [];
-        if ((0, fs_1.existsSync)(auditFile)) {
-            entries = JSON.parse((0, fs_1.readFileSync)(auditFile, "utf-8"));
+        if (existsSync(auditFile)) {
+            entries = JSON.parse(readFileSync(auditFile, "utf-8"));
         }
         entries.push(entry);
-        (0, fs_1.writeFileSync)(auditFile, JSON.stringify(entries, null, 2));
+        writeFileSync(auditFile, JSON.stringify(entries, null, 2));
     }
     // =========================================================================
     // Cleanup
@@ -3054,22 +3590,22 @@ class CBrowser {
             },
         };
         const cleanDir = (dir, pattern, keep, category) => {
-            if (!(0, fs_1.existsSync)(dir))
+            if (!existsSync(dir))
                 return;
-            const files = (0, fs_1.readdirSync)(dir)
+            const files = readdirSync(dir)
                 .filter((f) => pattern.test(f))
                 .map((f) => ({
                 name: f,
-                path: (0, path_1.join)(dir, f),
-                mtime: (0, fs_1.statSync)((0, path_1.join)(dir, f)).mtime,
-                size: (0, fs_1.statSync)((0, path_1.join)(dir, f)).size,
+                path: join(dir, f),
+                mtime: statSync(join(dir, f)).mtime,
+                size: statSync(join(dir, f)).size,
             }))
                 .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
             const cutoff = Date.now() - olderThan * 24 * 60 * 60 * 1000;
             const toDelete = files.slice(keep).filter((f) => f.mtime.getTime() < cutoff);
             for (const file of toDelete) {
                 if (!dryRun) {
-                    (0, fs_1.unlinkSync)(file.path);
+                    unlinkSync(file.path);
                 }
                 result.deleted++;
                 result.freedBytes += file.size;
@@ -3089,12 +3625,12 @@ class CBrowser {
     getStorageStats() {
         const stats = {};
         const countDir = (dir, pattern) => {
-            if (!(0, fs_1.existsSync)(dir))
+            if (!existsSync(dir))
                 return { count: 0, size: 0 };
-            const files = (0, fs_1.readdirSync)(dir).filter((f) => pattern.test(f));
+            const files = readdirSync(dir).filter((f) => pattern.test(f));
             let size = 0;
             for (const file of files) {
-                size += (0, fs_1.statSync)((0, path_1.join)(dir, file)).size;
+                size += statSync(join(dir, file)).size;
             }
             return { count: files.length, size };
         };
@@ -3117,12 +3653,12 @@ class CBrowser {
      * 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 baselinesDir = join(this.paths.dataDir, "baselines");
+        if (!existsSync(baselinesDir)) {
+            mkdirSync(baselinesDir, { recursive: true });
         }
         const page = await this.getPage();
-        const screenshotPath = (0, path_1.join)(baselinesDir, `${name}.png`);
+        const screenshotPath = join(baselinesDir, `${name}.png`);
         await page.screenshot({ path: screenshotPath, fullPage: true });
         const baseline = {
             name,
@@ -3132,25 +3668,25 @@ class CBrowser {
             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));
+        const metaPath = join(baselinesDir, `${name}.json`);
+        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)) {
+        const baselinesDir = join(this.paths.dataDir, "baselines");
+        const metaPath = join(baselinesDir, `${name}.json`);
+        if (!existsSync(metaPath)) {
             throw new Error(`Baseline not found: ${name}`);
         }
-        const baseline = JSON.parse((0, fs_1.readFileSync)(metaPath, "utf-8"));
+        const baseline = JSON.parse(readFileSync(metaPath, "utf-8"));
         const page = await this.getPage();
-        const currentPath = (0, path_1.join)(baselinesDir, `${name}-current-${Date.now()}.png`);
+        const currentPath = 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 baselineBuffer = readFileSync(baseline.screenshotPath);
+        const currentBuffer = readFileSync(currentPath);
         const sizeDiff = Math.abs(baselineBuffer.length - currentBuffer.length);
         const maxSize = Math.max(baselineBuffer.length, currentBuffer.length);
         const diffPercentage = sizeDiff / maxSize;
@@ -3165,10 +3701,10 @@ class CBrowser {
      * List all visual baselines.
      */
     listBaselines() {
-        const baselinesDir = (0, path_1.join)(this.paths.dataDir, "baselines");
-        if (!(0, fs_1.existsSync)(baselinesDir))
+        const baselinesDir = join(this.paths.dataDir, "baselines");
+        if (!existsSync(baselinesDir))
             return [];
-        return (0, fs_1.readdirSync)(baselinesDir)
+        return readdirSync(baselinesDir)
             .filter(f => f.endsWith(".json"))
             .map(f => f.replace(".json", ""));
     }
@@ -3266,17 +3802,17 @@ class CBrowser {
      * 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 recordingsDir = join(this.paths.dataDir, "recordings");
+        if (!existsSync(recordingsDir)) {
+            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));
+        const filePath = join(recordingsDir, `${name}.json`);
+        writeFileSync(filePath, JSON.stringify(recording, null, 2));
         return filePath;
     }
     /**
@@ -3312,7 +3848,7 @@ class CBrowser {
      * Export test results as JUnit XML.
      */
     exportJUnit(suite, outputPath) {
-        const filename = outputPath || (0, path_1.join)(this.paths.dataDir, `junit-${Date.now()}.xml`);
+        const filename = outputPath || 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) {
@@ -3323,21 +3859,21 @@ class CBrowser {
             xml += `  </testcase>\n`;
         }
         xml += `</testsuite>\n`;
-        (0, fs_1.writeFileSync)(filename, xml);
+        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`);
+        const filename = outputPath || 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);
+        writeFileSync(filename, tap);
         return filename;
     }
     // =========================================================================
@@ -3413,11 +3949,10 @@ class CBrowser {
         return new FluentCBrowser(this);
     }
 }
-exports.CBrowser = CBrowser;
 /**
  * Fluent wrapper for chainable API.
  */
-class FluentCBrowser {
+export class FluentCBrowser {
     browser;
     constructor(browser) {
         this.browser = browser;
@@ -3449,5 +3984,4 @@ class FluentCBrowser {
         return this.browser;
     }
 }
-exports.FluentCBrowser = FluentCBrowser;
 //# sourceMappingURL=browser.js.map