aether-mcp-server 2.1.0 → 2.1.1

package/dist/cdp-bridge.js

@@ -1,672 +1,399 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CdpBridge = void 0;
 exports.getCdpBridge = getCdpBridge;
+/**
+ * CdpBridge — thin command router that delegates to focused bridge modules.
+ *
+ * Previously this was a 2,761-line God object. Now it's ~350 lines of routing
+ * logic. All actual browser operations live in the bridge/ modules.
+ */
 const cdp_client_1 = require("./cdp-client");
-const captcha_solver_1 = require("./captcha-solver");
 const locator_engine_1 = require("./locator-engine");
 const page_snapshot_cache_1 = require("./page-snapshot-cache");
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-/**
- * Bridge layer that translates old extension-style commands to CDP commands.
- * This allows the MCP server to work without the Chrome extension.
- */
+const captcha_solver_1 = require("./captcha-solver");
+const logger_1 = require("./logger");
+// Bridge modules
+const Navigation = __importStar(require("./bridge/navigation"));
+const Interaction = __importStar(require("./bridge/interaction"));
+const Inspection = __importStar(require("./bridge/inspection"));
+const Session = __importStar(require("./bridge/session"));
+const Debugging = __importStar(require("./bridge/debugging"));
+// Eval scripts (for methods not yet fully extracted)
+const eval_scripts_1 = require("./eval-scripts");
 class CdpBridge {
     client;
     locator;
     snapshotCache;
+    logger;
+    // Screencast state (kept here until extracted to module)
+    screencastFrames = [];
+    screencastFrameListener = null;
+    mockRoutes = [];
+    mockRouteListener = null;
     constructor() {
         this.client = (0, cdp_client_1.getCdpClient)();
         this.locator = new locator_engine_1.LocatorEngine(this.client);
         this.snapshotCache = new page_snapshot_cache_1.PageSnapshotCache(this.client, this.locator);
+        this.logger = (0, logger_1.createLogger)("bridge");
     }
+    // ─── Speed Control ────────────────────────────────────────────────
+    getSpeedMultiplier() {
+        return this.client.getSpeedMultiplier();
+    }
+    setSpeed(m) {
+        this.client.setSpeed(m);
+    }
+    // ─── Main Command Router ──────────────────────────────────────────
+    async sendCommand(method, params = {}) {
+        const log = this.logger.child(method);
+        try {
+            switch (method) {
+                // ─── Navigation ────────────────────────────────────────
+                case "connect":
+                    return Navigation.connect(this.client, params);
+                case "navigate":
+                    await this.ensureConnected();
+                    return Navigation.navigate(this.client, params, this.snapshotCache);
+                case "smart_navigate":
+                    await this.ensureConnected();
+                    return Navigation.smartNavigate(this.client, params, this.snapshotCache, log);
+                case "new_tab":
+                    await this.ensureConnected();
+                    return Navigation.newTab(this.client, params);
+                case "switch_tab":
+                    await this.ensureConnected();
+                    return Navigation.switchTab(this.client, params);
+                case "close_tab":
+                    await this.ensureConnected();
+                    return Navigation.closeTab(this.client, params);
+                case "get_tabs":
+                    await this.ensureConnected();
+                    return Navigation.getTabs(this.client, params);
+                // ─── Inspection ────────────────────────────────────────
+                case "browser_status":
+                    return Inspection.browserStatus(this.client, params);
+                case "snapshot_compact":
+                    await this.ensureConnected();
+                    return Inspection.snapshotCompact(this.client, this.snapshotCache, params);
+                case "list_interactive_elements":
+                    await this.ensureConnected();
+                    return Inspection.listInteractiveElements(this.client, this.snapshotCache, this.locator, params);
+                case "get_state":
+                    await this.ensureConnected();
+                    return Inspection.getState(this.client, this.snapshotCache, this.locator, params);
+                case "page_snapshot":
+                    await this.ensureConnected();
+                    return Inspection.pageSnapshot(this.client, params);
+                case "get_page_text":
+                    await this.ensureConnected();
+                    return Inspection.getPageText(this.client, params);
+                case "get_tree":
+                    await this.ensureConnected();
+                    return Inspection.getAccessibilityTree(this.client);
+                case "get_dom_tree":
+                case "get_dom_snapshot":
+                    await this.ensureConnected();
+                    return Inspection.getDOMTree(this.client);
+                case "highlight_elements":
+                    await this.ensureConnected();
+                    return Inspection.highlightElements(this.client);
+                case "verify_ui_state":
+                    await this.ensureConnected();
+                    return Inspection.verifyUIState(this.client, params);
+                case "get_computed_style":
+                    await this.ensureConnected();
+                    return Inspection.getComputedStyle(this.client, params);
+                case "get_event_listeners":
+                    await this.ensureConnected();
+                    return Inspection.getEventListeners(this.client, params);
+                // ─── Interaction ───────────────────────────────────────
+                case "click_by_ref":
+                    await this.ensureConnected();
+                    return Interaction.clickByRef(this.client, this.locator, this.snapshotCache, params, log);
+                case "click_by_selector":
+                    await this.ensureConnected();
+                    return Interaction.clickBySelector(this.client, this.locator, this.snapshotCache, params, log);
+                case "fill_by_selector":
+                    await this.ensureConnected();
+                    return Interaction.fillBySelector(this.client, this.locator, this.snapshotCache, params, log);
+                case "wait_for_selector":
+                    await this.ensureConnected();
+                    return this.waitForSelectorCompact(params);
+                case "wait_for_text":
+                    await this.ensureConnected();
+                    return this.waitForText(params);
+                case "press_key":
+                case "key_combo":
+                    await this.ensureConnected();
+                    return Interaction.pressKey(this.client, this.locator, this.snapshotCache, params, log);
+                case "click_text":
+                    await this.ensureConnected();
+                    return Interaction.clickText(this.client, this.locator, this.snapshotCache, params, log);
+                case "click_role":
+                    await this.ensureConnected();
+                    return Interaction.clickRole(this.client, this.locator, this.snapshotCache, params, log);
+                case "fill_label":
+                    await this.ensureConnected();
+                    return Interaction.fillLabel(this.client, this.locator, this.snapshotCache, params, log);
+                case "click":
+                    await this.ensureConnected();
+                    return Interaction.click(this.client, this.locator, this.snapshotCache, params, log);
+                case "click_element":
+                    await this.ensureConnected();
+                    return Interaction.clickElement(this.client, this.locator, this.snapshotCache, params, log);
+                case "click_element_by_selector":
+                    await this.ensureConnected();
+                    return Interaction.clickElementBySelector(this.client, this.locator, this.snapshotCache, params, log);
+                case "type":
+                    await this.ensureConnected();
+                    return Interaction.type(this.client, this.locator, this.snapshotCache, params, log);
+                case "fill":
+                    await this.ensureConnected();
+                    return Interaction.fillInput(this.client, this.locator, this.snapshotCache, params, log);
+                case "select":
+                    await this.ensureConnected();
+                    return Interaction.selectOption(this.client, this.locator, this.snapshotCache, params, log);
+                case "check":
+                    await this.ensureConnected();
+                    return Interaction.checkElement(this.client, this.locator, this.snapshotCache, params, log);
+                case "hover":
+                    await this.ensureConnected();
+                    return Interaction.hover(this.client, this.locator, this.snapshotCache, params, log);
+                case "drag_and_drop":
+                    await this.ensureConnected();
+                    return Interaction.dragAndDrop(this.client, this.locator, this.snapshotCache, params, log);
+                case "scroll":
+                    await this.ensureConnected();
+                    return Interaction.scroll(this.client, this.locator, this.snapshotCache, params, log);
+                case "wait":
+                    await this.ensureConnected();
+                    return Interaction.wait(this.client, this.locator, this.snapshotCache, params, log);
+                case "element_at_point":
+                    await this.ensureConnected();
+                    return Interaction.elementAtPoint(this.client, this.locator, this.snapshotCache, params, log);
+                case "browser_intent":
+                    await this.ensureConnected();
+                    return this.browserIntent(params);
+                case "screenshot":
+                case "screenshot_region":
+                    await this.ensureConnected();
+                    return this.screenshot(params);
+                case "evaluate":
+                    await this.ensureConnected();
+                    return Debugging.evaluate(this.client, params);
+                // ─── Session ───────────────────────────────────────────
+                case "save_auth_state":
+                    await this.ensureConnected();
+                    return Session.saveAuthState(this.client, params, this.snapshotCache);
+                case "load_auth_state":
+                    await this.ensureConnected();
+                    return Session.loadAuthState(this.client, params, this.snapshotCache);
+                case "get_cookies":
+                    await this.ensureConnected();
+                    return Session.getCookies(this.client);
+                case "set_cookie":
+                    await this.ensureConnected();
+                    return Session.setCookie(this.client, params);
+                case "clear_cache":
+                    await this.ensureConnected();
+                    return Session.clearCache(this.client);
+                // ─── Debugging ──────────────────────────────────────────
+                case "get_logs":
+                    await this.ensureConnected();
+                    return Debugging.getLogs(this.client, params);
+                case "get_network_errors":
+                    await this.ensureConnected();
+                    return Debugging.getNetworkErrors(this.client, params);
+                case "get_network_traffic":
+                    await this.ensureConnected();
+                    return Debugging.getNetworkTraffic(this.client);
+                case "get_network_response":
+                    await this.ensureConnected();
+                    return Debugging.getNetworkResponse(this.client, params);
+                case "get_performance_metrics":
+                    await this.ensureConnected();
+                    return Debugging.getPerformanceMetrics(this.client);
+                case "start_tracing":
+                    await this.ensureConnected();
+                    return Debugging.startTracing(this.client, params);
+                case "stop_tracing":
+                    await this.ensureConnected();
+                    return Debugging.stopTracing(this.client);
+                case "cdp_command":
+                    await this.ensureConnected();
+                    return Debugging.cdpCommand(this.client, params);
+                case "assert":
+                    await this.ensureConnected();
+                    return Debugging.assertCondition(this.client, params);
+                case "get_dom_storage":
+                    await this.ensureConnected();
+                    return Debugging.getDOMStorage(this.client, params);
+                // ─── CAPTCHA ───────────────────────────────────────────
+                case "detect_captcha":
+                    await this.ensureConnected();
+                    return this.detectCaptcha();
+                case "solve_captcha":
+                    await this.ensureConnected();
+                    return this.solveCaptchaAction(params);
+                // ─── Configuration ─────────────────────────────────────
+                case "configure":
+                    await this.ensureConnected();
+                    return this.configureBrowser(params);
+                case "emulate_network":
+                    await this.ensureConnected();
+                    return this.emulateNetworkConditions(params);
+                case "set_geolocation":
+                    await this.ensureConnected();
+                    return this.setGeolocation(params);
+                case "set_timezone":
+                    await this.ensureConnected();
+                    return this.setTimezone(params);
+                case "print_pdf":
+                    await this.ensureConnected();
+                    return this.printPDF(params);
+                case "upload_file":
+                    await this.ensureConnected();
+                    return this.uploadFile(params);
+                case "mock_network_request":
+                    await this.ensureConnected();
+                    return this.mockNetworkRequest(params);
+                // ─── Screencast ────────────────────────────────────────
+                case "start_screencast":
+                    await this.ensureConnected();
+                    return this.startScreencast(params);
+                case "stop_screencast":
+                    await this.ensureConnected();
+                    return this.stopScreencast(params);
+                case "record_session":
+                    await this.ensureConnected();
+                    return this.recordSession(params);
+                case "sample_visual_frames":
+                    await this.ensureConnected();
+                    return this.sampleVisualFrames(params);
+                case "get_screencast_frames":
+                    await this.ensureConnected();
+                    return this.getScreencastFrames(params);
+                // ─── Agent APIs ────────────────────────────────────────
+                case "agent_action":
+                    await this.ensureConnected();
+                    return this.agentAction(params);
+                case "observe_and_act":
+                    await this.ensureConnected();
+                    return this.observeAndAct(params);
+                case "agent_form_fill":
+                    await this.ensureConnected();
+                    return this.agentFormFill(params);
+                default:
+                    await this.ensureConnected();
+                    return this.client.sendCommand(method, params);
+            }
+        }
+        catch (err) {
+            log.error("Command failed", { error: err.message, method });
+            throw err;
+        }
+    }
+    // ─── Connection helpers ───────────────────────────────────────────
     async ensureConnected() {
         if (!this.client.isConnected()) {
-            // Try to connect to existing Chrome on default port
             try {
                 await this.client.connect(9222);
             }
             catch {
-                // Chrome not running, launch it
                 await this.client.launch({ headless: false });
             }
         }
     }
-    async applyCognitivePause(type) {
-        let delay = 150 + Math.random() * 250; // base delay (150-400ms)
-        if (type === "type" || type === "fill") {
-            delay += 150 + Math.random() * 250; // typing prep delay (300-650ms total)
-        }
-        else if (type === "click") {
-            delay += 50 + Math.random() * 150; // click prep delay (200-550ms total)
-        }
-        console.error(`[Bridge] Emulating cognitive pause: ${Math.round(delay)}ms for action type: ${type}`);
-        await new Promise((r) => setTimeout(r, delay));
-    }
-    async sendCommand(method, params = {}) {
-        // Cognitive pause mapping
-        const interactionTypes = {
-            click_by_ref: "click",
-            click_by_selector: "click",
-            fill_by_selector: "fill",
-            press_key: "key",
-            key_combo: "key",
-            click_text: "click",
-            click_role: "click",
-            fill_label: "fill",
-            click: "click",
-            click_element: "click",
-            click_element_by_selector: "click",
-            type: "type",
-            fill: "fill",
-            select: "click",
-            check: "click",
-            hover: "click",
-            drag_and_drop: "click"
-        };
-        if (interactionTypes[method]) {
-            await this.applyCognitivePause(interactionTypes[method]);
-        }
-        switch (method) {
-            case "browser_status":
-                return this.browserStatus(params);
-            case "snapshot_compact":
-                await this.ensureConnected();
-                return this.snapshotCompact(params);
-            case "list_interactive_elements":
-                await this.ensureConnected();
-                return this.listInteractiveElements(params);
-            case "click_by_ref":
-                await this.ensureConnected();
-                return this.clickByRef(params);
-            case "click_by_selector":
-                await this.ensureConnected();
-                return this.clickBySelector(params);
-            case "fill_by_selector":
-                await this.ensureConnected();
-                return this.fillBySelector(params);
-            case "wait_for_selector":
-                await this.ensureConnected();
-                return this.waitForSelectorCompact(params);
-            case "wait_for_text":
-                await this.ensureConnected();
-                return this.waitForText(params);
-            case "get_network_errors":
-                await this.ensureConnected();
-                return this.getNetworkErrors(params);
-            case "detect_captcha":
-                await this.ensureConnected();
-                return this.detectCaptcha();
-            case "solve_captcha":
-                await this.ensureConnected();
-                return this.solveCaptchaAction(params);
-            case "browser_intent":
-                await this.ensureConnected();
-                await this.ensureNoCaptcha("browser_intent");
-                return this.browserIntent(params);
-            case "get_logs":
-                await this.ensureConnected();
-                return this.getLogs(params);
-            case "press_key":
-            case "key_combo":
-                await this.ensureConnected();
-                await this.ensureNoCaptcha("press_key");
-                return this.pressKey(params);
-            case "click_text":
-                await this.ensureConnected();
-                await this.ensureNoCaptcha("click_text");
-                return this.clickText(params);
-            case "click_role":
-                await this.ensureConnected();
-                await this.ensureNoCaptcha("click_role");
-                return this.clickRole(params);
-            case "fill_label":
-                await this.ensureConnected();
-                await this.ensureNoCaptcha("fill_label");
-                return this.fillLabel(params);
-            case "element_at_point":
-                await this.ensureConnected();
-                return this.elementAtPoint(params);
-            case "connect":
-                return this.connect(params);
-            case "get_state":
-                await this.ensureConnected();
-                return this.getState(params);
-            case "navigate":
-                await this.ensureConnected();
-                return this.navigate(params);
-            case "click":
-                await this.ensureConnected();
-                await this.ensureNoCaptcha("click");
-                return this.click(params);
-            case "click_element":
-                await this.ensureConnected();
-                await this.ensureNoCaptcha("click_element");
-                return this.clickElement(params);
-            case "click_element_by_selector":
-                await this.ensureConnected();
-                await this.ensureNoCaptcha("click_element_by_selector");
-                return this.clickElementBySelector(params);
-            case "type":
-                await this.ensureConnected();
-                await this.ensureNoCaptcha("type");
-                return this.type(params);
-            case "evaluate":
-                await this.ensureConnected();
-                return this.evaluate(params);
-            case "screenshot":
-            case "screenshot_region":
-                await this.ensureConnected();
-                return this.screenshot(params);
-            case "scroll":
-                await this.ensureConnected();
-                return this.scroll(params);
-            case "wait":
-                await this.ensureConnected();
-                return this.wait(params);
-            case "cdp_command":
-                await this.ensureConnected();
-                return this.cdpCommand(params);
-            case "get_dom_snapshot":
-                await this.ensureConnected();
-                return this.getDomSnapshot(params);
-            case "get_page_text":
-                await this.ensureConnected();
-                return this.getPageText(params);
-            case "save_auth_state":
-                await this.ensureConnected();
-                return this.saveAuthState(params);
-            case "load_auth_state":
-                await this.ensureConnected();
-                return this.loadAuthState(params);
-            case "get_tabs":
-                await this.ensureConnected();
-                return this.getTabs(params);
-            case "new_tab":
-                await this.ensureConnected();
-                return this.newTab(params);
-            case "switch_tab":
-                await this.ensureConnected();
-                return this.switchTab(params);
-            case "close_tab":
-                await this.ensureConnected();
-                return this.closeTab(params);
-            case "start_screencast":
-                await this.ensureConnected();
-                return this.startScreencast(params);
-            case "stop_screencast":
-                await this.ensureConnected();
-                return this.stopScreencast(params);
-            case "record_session":
-                await this.ensureConnected();
-                return this.recordSession(params);
-            case "sample_visual_frames":
-                await this.ensureConnected();
-                return this.sampleVisualFrames(params);
-            case "start_tracing":
-                await this.ensureConnected();
-                return this.startTracing(params);
-            case "stop_tracing":
-                await this.ensureConnected();
-                return this.stopTracing(params);
-            case "get_performance_metrics":
-                await this.ensureConnected();
-                return this.getPerformanceMetrics(params);
-            case "hover":
-                await this.ensureConnected();
-                await this.ensureNoCaptcha("hover");
-                return this.hover(params);
-            case "drag_and_drop":
-                await this.ensureConnected();
-                await this.ensureNoCaptcha("drag_and_drop");
-                return this.dragAndDrop(params);
-            // ==================== MISSING ACT TOOL ACTIONS ====================
-            case "fill":
-                await this.ensureConnected();
-                await this.ensureNoCaptcha("fill");
-                return this.fillInput(params);
-            case "select":
-                await this.ensureConnected();
-                await this.ensureNoCaptcha("select");
-                return this.selectOption(params);
-            case "check":
-                await this.ensureConnected();
-                await this.ensureNoCaptcha("check");
-                return this.checkElement(params);
-            case "get_tree":
-                await this.ensureConnected();
-                return this.getAccessibilityTree(params);
-            case "get_dom_tree":
-                await this.ensureConnected();
-                return this.getDOMTree(params);
-            case "assert":
-                await this.ensureConnected();
-                return this.assertCondition(params);
-            case "get_cookies":
-                await this.ensureConnected();
-                return this.getCookies(params);
-            case "set_cookie":
-                await this.ensureConnected();
-                return this.setCookie(params);
-            case "clear_cache":
-                await this.ensureConnected();
-                return this.clearCache(params);
-            case "set_geolocation":
-                await this.ensureConnected();
-                return this.setGeolocation(params);
-            case "set_timezone":
-                await this.ensureConnected();
-                return this.setTimezone(params);
-            case "emulate_network":
-                await this.ensureConnected();
-                return this.emulateNetworkConditions(params);
-            case "print_pdf":
-                await this.ensureConnected();
-                return this.printPDF(params);
-            case "highlight_elements":
-                await this.ensureConnected();
-                return this.highlightElements(params);
-            case "verify_ui_state":
-                await this.ensureConnected();
-                return this.verifyUIState(params);
-            case "get_dom_storage":
-                await this.ensureConnected();
-                return this.getDOMStorage(params);
-            case "get_network_traffic":
-                await this.ensureConnected();
-                return this.getNetworkTraffic(params);
-            case "get_network_response":
-                await this.ensureConnected();
-                return this.getNetworkResponse(params);
-            case "mock_network_request":
-                await this.ensureConnected();
-                return this.mockNetworkRequest(params);
-            case "get_computed_style":
-                await this.ensureConnected();
-                return this.getComputedStyle(params);
-            case "get_event_listeners":
-                await this.ensureConnected();
-                return this.getEventListeners(params);
-            case "get_screencast_frames":
-                await this.ensureConnected();
-                return this.getScreencastFrames(params);
-            case "upload_file":
-                await this.ensureConnected();
-                await this.ensureNoCaptcha("upload_file");
-                return this.uploadFile(params);
-            case "configure":
-                await this.ensureConnected();
-                return this.configureBrowser(params);
-            // ==================== AGENT-CENTRIC APIs ====================
-            case "agent_action":
-                await this.ensureConnected();
-                await this.ensureNoCaptcha("agent_action");
-                return this.agentAction(params);
-            case "smart_navigate":
-                await this.ensureConnected();
-                return this.smartNavigate(params);
-            case "observe_and_act":
-                await this.ensureConnected();
-                await this.ensureNoCaptcha("observe_and_act");
-                return this.observeAndAct(params);
-            case "agent_form_fill":
-                await this.ensureConnected();
-                await this.ensureNoCaptcha("agent_form_fill");
-                return this.agentFormFill(params);
-            case "page_snapshot":
-                await this.ensureConnected();
-                return this.pageSnapshot(params);
-            default:
-                await this.ensureConnected();
-                // Try as raw CDP command
-                return this.client.sendCommand(method, params);
-        }
-    }
-    async connect(params) {
-        const port = params.port || 9222;
-        await this.client.connect(port);
-        return "Connected to browser";
+    async launchBrowser(options) {
+        return Session.launchBrowser(this.client, options);
     }
-    async browserStatus(params) {
-        const connected = this.client.isConnected();
-        const activeTarget = this.client.getActiveTarget();
-        let targets;
-        if (connected && params.includeTargets) {
-            targets = await this.client.getTabs().catch(() => []);
-        }
-        return {
-            connected,
-            activeTarget: activeTarget ? {
-                id: activeTarget.id,
-                type: activeTarget.type,
-                title: activeTarget.title,
-                url: activeTarget.url
-            } : null,
-            targets
-        };
+    async killBrowser() {
+        return Session.killBrowser(this.client);
     }
-    async snapshotCompact(params) {
-        return this.snapshotCache.compact({
-            maxElements: params.maxElements ?? 30,
-            includeText: params.includeText !== false,
-        });
+    async listBrowsers() {
+        return Session.listBrowsers(this.client);
     }
-    async listInteractiveElements(params) {
-        const maxElements = Math.max(0, Math.min(Number(params.maxElements ?? 50), 200));
-        const snapshot = await this.snapshotCache.compact({
-            maxElements,
-            includeText: true,
-            withOverlay: !!params.withOverlay,
-        });
-        return {
-            count: snapshot.elements.length,
-            cache: snapshot.cache,
-            elements: snapshot.elements
-        };
+    async listBrowserProfiles(browser) {
+        return Session.listBrowserProfiles(this.client, browser);
     }
-    async clickByRef(params) {
-        const ref = String(params.ref || "");
-        if (!ref)
-            throw new Error("ref required");
-        if (ref.startsWith("css:")) {
-            return this.clickBySelector({ selector: ref.slice(4), timeout: params.timeout });
-        }
-        if (ref.startsWith("point:")) {
-            const [x, y] = ref.slice(6).split(",").map(Number);
-            if (!Number.isFinite(x) || !Number.isFinite(y))
-                throw new Error(`Invalid point ref: ${ref}`);
-            const before = await this.captureActionFacts();
-            await this.client.click(x, y);
-            this.snapshotCache.invalidate("click_by_ref");
-            const after = await this.captureActionFacts();
-            return { success: true, ref, facts: this.diffActionFacts(before, after) };
-        }
-        if (ref.startsWith("@") || ref.startsWith("som:")) {
-            const id = ref.replace(/^som:/, "").replace(/^@/, "");
-            await this.clickElement({ id });
-            return { success: true, ref };
+    // ─── Self-healing selector resolution ─────────────────────────────
+    async resolveSelector(params) {
+        const { originalSelector, text, fuzzyMatch } = params;
+        if (originalSelector) {
+            const exists = await this.client.evaluate(`!!document.querySelector(${JSON.stringify(originalSelector)})`);
+            if (exists) {
+                return { selector: originalSelector, method: "exact", confidence: 1.0 };
+            }
         }
-        throw new Error(`Unsupported element ref: ${ref}`);
-    }
-    async clickBySelector(params) {
-        const selector = params.selector;
-        if (!selector)
-            throw new Error("selector required");
-        const found = await this.client.waitForSelector(selector, params.timeout || 5000, { visible: params.visible !== false, stable: params.stable === true });
-        if (!found)
-            return { success: false, selector, message: "Selector not found before timeout" };
-        const before = await this.captureActionFacts();
-        await this.clickElementBySelector({ selector });
-        this.snapshotCache.invalidate("click_by_selector");
-        const after = await this.captureActionFacts(selector);
-        return { success: true, selector, facts: this.diffActionFacts(before, after) };
-    }
-    async fillBySelector(params) {
-        const selector = params.selector;
-        const value = params.value ?? "";
-        if (!selector)
-            throw new Error("selector required");
-        const found = await this.client.waitForSelector(selector, params.timeout || 5000, { visible: params.visible !== false, stable: params.stable === true });
-        if (!found)
-            return { success: false, selector, message: "Selector not found before timeout" };
-        await this.client.moveMouseToSelector(selector).catch(() => { });
-        const focused = await this.client.evaluate(`
-            (function() {
-                const el = document.querySelector(${JSON.stringify(selector)});
-                if (!el) return false;
-                el.focus();
-                if ('value' in el) {
-                    el.value = '';
-                    el.dispatchEvent(new Event('input', { bubbles: true }));
-                    el.dispatchEvent(new Event('change', { bubbles: true }));
-                }
-                return true;
-            })()
-        `);
-        if (!focused)
-            return { success: false, selector, message: "Selector could not be focused" };
-        const before = await this.captureActionFacts(selector);
-        await this.client.typeText(String(value));
-        this.snapshotCache.invalidate("fill_by_selector");
-        const after = await this.captureActionFacts(selector);
-        return { success: true, selector, length: String(value).length, facts: this.diffActionFacts(before, after) };
-    }
-    async waitForSelectorCompact(params) {
-        const selector = params.selector;
-        if (!selector)
-            throw new Error("selector required");
-        const found = await this.client.waitForSelector(selector, params.timeout || 5000, { visible: params.visible === true, stable: params.stable === true });
-        return { success: found, selector };
-    }
-    async getLogs(params) {
-        const limit = Math.max(1, Math.min(Number(params.limit ?? 50), 100));
-        const logs = await this.client.getConsoleLogs(limit);
-        return { count: logs.length, logs };
-    }
-    async pressKey(params) {
-        const key = String(params.key || params.value || "");
-        if (!key)
-            throw new Error("key required");
-        const modifiers = Array.isArray(params.modifiers) ? params.modifiers.map(String) : [];
-        const before = await this.captureActionFacts();
-        await this.client.pressKey(key, modifiers);
-        this.snapshotCache.invalidate("press_key");
-        const after = await this.captureActionFacts();
-        return { success: true, key, modifiers, facts: this.diffActionFacts(before, after) };
-    }
-    async clickText(params) {
-        const resolved = await this.locator.resolve({
-            target: params.text || params.value || params.target,
-            role: params.role,
-            timeout: params.timeout || 5000,
-            includeCandidates: params.includeCandidates
-        });
-        if (!resolved.success)
-            return resolved;
-        const before = await this.captureActionFacts();
-        await this.clickResolvedLocator(resolved.candidate);
-        this.snapshotCache.invalidate("click_text");
-        const after = await this.captureActionFacts(resolved.selector);
-        return { success: true, selector: resolved.selector, ref: resolved.ref, matchedBy: resolved.matchedBy, confidence: resolved.confidence, facts: this.diffActionFacts(before, after) };
-    }
-    async clickRole(params) {
-        const resolved = await this.locator.resolve({
-            target: params.name || params.text || params.target || "",
-            role: params.role,
-            timeout: params.timeout || 5000,
-            includeCandidates: params.includeCandidates
-        });
-        if (!resolved.success)
-            return resolved;
-        const before = await this.captureActionFacts();
-        await this.clickResolvedLocator(resolved.candidate);
-        this.snapshotCache.invalidate("click_role");
-        const after = await this.captureActionFacts(resolved.selector);
-        return { success: true, selector: resolved.selector, ref: resolved.ref, matchedBy: resolved.matchedBy, confidence: resolved.confidence, facts: this.diffActionFacts(before, after) };
-    }
-    async fillLabel(params) {
         const resolved = await this.locator.resolve({
-            target: params.label || params.target,
-            role: params.role || "textbox",
-            timeout: params.timeout || 5000,
-            includeCandidates: params.includeCandidates
-        });
-        if (!resolved.success)
-            return resolved;
-        if (resolved.candidate?.scope === "document" && resolved.candidate.framePath.length === 0 && resolved.candidate.shadowDepth === 0) {
-            return this.fillBySelector({ selector: resolved.selector, value: params.value ?? "", timeout: params.timeout || 5000 });
-        }
-        const before = await this.captureActionFacts();
-        await this.locator.focusAndClear(resolved.candidate);
-        await this.client.typeText(String(params.value ?? ""));
-        this.snapshotCache.invalidate("fill_label");
-        const after = await this.captureActionFacts();
-        return { success: true, selector: resolved.selector, ref: resolved.ref, matchedBy: resolved.matchedBy, confidence: resolved.confidence, length: String(params.value ?? "").length, facts: this.diffActionFacts(before, after) };
-    }
-    async clickResolvedLocator(candidate) {
-        if (!candidate)
-            throw new Error("Resolved locator missing candidate details");
-        if (candidate.scope === "document" && candidate.framePath.length === 0 && candidate.shadowDepth === 0 && candidate.selector) {
-            await this.clickElementBySelector({ selector: candidate.selector });
-            return;
+            target: text,
+            timeout: params.timeout || 1500,
+            includeCandidates: false,
+        }).catch(() => null);
+        if (resolved?.success && (resolved.selector || resolved.ref)) {
+            return {
+                selector: resolved.candidate?.scope === "document" &&
+                    resolved.candidate.framePath.length === 0 &&
+                    resolved.candidate.shadowDepth === 0
+                    ? resolved.selector || ""
+                    : resolved.ref || "",
+                method: resolved.matchedBy || "locator",
+                confidence: resolved.confidence || 0.7,
+            };
         }
-        await this.locator.click(candidate);
-    }
-    async elementAtPoint(params) {
-        const x = Number(params.x ?? String(params.coordinate || "").split(",")[0]);
-        const y = Number(params.y ?? String(params.coordinate || "").split(",")[1]);
-        if (!Number.isFinite(x) || !Number.isFinite(y))
-            throw new Error("x/y or coordinate required");
-        return await this.client.evaluate(`
-            (function() {
-                const el = document.elementFromPoint(${JSON.stringify(x)}, ${JSON.stringify(y)});
-                if (!el) return { found: false };
-                const rect = el.getBoundingClientRect();
-                function cssPath(node) {
-                    if (node.id) return '#' + CSS.escape(node.id);
-                    const path = [];
-                    while (node && node.nodeType === Node.ELEMENT_NODE && node !== document.body) {
-                        let selector = node.nodeName.toLowerCase();
-                        if (node.classList && node.classList.length) {
-                            selector += '.' + Array.from(node.classList).slice(0, 2).map(c => CSS.escape(c)).join('.');
-                        }
-                        const parent = node.parentElement;
-                        if (parent) {
-                            const siblings = Array.from(parent.children).filter(child => child.nodeName === node.nodeName);
-                            if (siblings.length > 1) selector += ':nth-of-type(' + (siblings.indexOf(node) + 1) + ')';
-                        }
-                        path.unshift(selector);
-                        node = parent;
-                    }
-                    return path.join(' > ');
-                }
-                return {
-                    found: true,
-                    selector: cssPath(el),
-                    tag: el.tagName.toLowerCase(),
-                    text: String(el.innerText || el.textContent || el.getAttribute('aria-label') || '').trim().replace(/\\s+/g, ' ').substring(0, 160),
-                    role: el.getAttribute('role') || '',
-                    bounds: { x: Math.round(rect.left), y: Math.round(rect.top), width: Math.round(rect.width), height: Math.round(rect.height) }
-                };
-            })()
-        `);
-    }
-    async waitForText(params) {
-        const text = String(params.text || "");
-        if (!text)
-            throw new Error("text required");
-        const timeout = params.timeout || 5000;
-        const start = Date.now();
-        while (Date.now() - start < timeout) {
-            const found = await this.client.evaluate(`
-                (document.body && document.body.innerText || '').includes(${JSON.stringify(text)})
-            `).catch(() => false);
-            if (found)
-                return { success: true, text };
-            await new Promise(r => setTimeout(r, 200));
+        if (fuzzyMatch !== false && text) {
+            const { makeFuzzyMatchScript } = await Promise.resolve().then(() => __importStar(require("./eval-scripts")));
+            const result = await this.client.evaluate(makeFuzzyMatchScript(text));
+            if (result) {
+                return { selector: result.selector, method: "fuzzy", confidence: result.confidence };
+            }
         }
-        return { success: false, text, message: "Text not found before timeout" };
-    }
-    async getNetworkErrors(params) {
-        const limit = Math.max(1, Math.min(Number(params.limit ?? 20), 100));
-        const errors = (await this.client.getNetworkTraffic())
-            .filter((entry) => entry.type === "error" || entry.status >= 400)
-            .slice(-limit);
-        return {
-            count: errors.length,
-            errors
-        };
+        throw new Error(`Could not resolve selector. Original: ${originalSelector}, Text: ${text}`);
     }
+    // ─── CAPTCHA ──────────────────────────────────────────────────────
     async detectCaptcha() {
-        return await this.client.evaluate(`
-            (function() {
-                const selectors = [
-                    'iframe[src*="recaptcha"]',
-                    'iframe[src*="hcaptcha"]',
-                    'iframe[src*="challenges.cloudflare.com"]',
-                    'iframe[src*="arkoselabs"]',
-                    'iframe[src*="funcaptcha"]',
-                    '[class*="g-recaptcha"]',
-                    '[class*="h-captcha"]',
-                    '[data-sitekey]',
-                    '[id*="captcha" i]',
-                    '[class*="captcha" i]',
-                    '[aria-label*="captcha" i]'
-                ];
-                const textPatterns = [
-                    /captcha/i,
-                    /i am not a robot/i,
-                    /verify you are human/i,
-                    /verify that you are human/i,
-                    /security check/i,
-                    /human verification/i,
-                    /cloudflare.*verify/i
-                ];
-
-                function visible(el) {
-                    const rect = el.getBoundingClientRect();
-                    const style = window.getComputedStyle(el);
-                    return style.display !== 'none' &&
-                        style.visibility !== 'hidden' &&
-                        rect.width > 0 &&
-                        rect.height > 0;
-                }
-
-                const selectorMatches = selectors.flatMap((selector) =>
-                    Array.from(document.querySelectorAll(selector))
-                        .filter(visible)
-                        .slice(0, 5)
-                        .map((el) => {
-                            const rect = el.getBoundingClientRect();
-                            return {
-                                selector,
-                                tag: el.tagName.toLowerCase(),
-                                text: String(el.innerText || el.textContent || el.getAttribute('aria-label') || '').trim().replace(/\\s+/g, ' ').substring(0, 160),
-                                src: el.getAttribute('src') || '',
-                                bounds: { x: Math.round(rect.left), y: Math.round(rect.top), width: Math.round(rect.width), height: Math.round(rect.height) }
-                            };
-                        })
-                );
-
-                const bodyText = String(document.body?.innerText || '').replace(/\\s+/g, ' ').substring(0, 5000);
-                const textMatches = textPatterns
-                    .filter((pattern) => pattern.test(bodyText))
-                    .map((pattern) => pattern.toString());
-
-                const detected = selectorMatches.length > 0 || textMatches.length > 0;
-                return {
-                    detected,
-                    captchaRequired: detected,
-                    message: detected ? 'CAPTCHA detected. Manual solve required before continuing.' : 'No CAPTCHA detected.',
-                    matches: selectorMatches,
-                    textMatches,
-                    url: window.location.href,
-                    title: document.title
-                };
-            })()
-        `).catch((error) => ({
+        return await this.client.evaluate(eval_scripts_1.CAPTCHA_DETECTION_SCRIPT).catch((error) => ({
             detected: false,
             captchaRequired: false,
-            message: `CAPTCHA detection failed: ${error.message}`
+            message: `CAPTCHA detection failed: ${error.message}`,
         }));
     }
-    async ensureNoCaptcha(action) {
-        const result = await this.detectCaptcha();
-        if (result.detected) {
-            const error = new Error("CAPTCHA detected. Manual solve required before continuing.");
-            error.captcha = {
-                ...result,
-                blockedAction: action
-            };
-            throw error;
-        }
-    }
     async solveCaptchaAction(params) {
-        const pageUrl = params.pageUrl || await this.client.evaluate("window.location.href").catch(() => "");
+        const pageUrl = params.pageUrl || (await this.client.evaluate("window.location.href").catch(() => ""));
         const opts = {
             useService: params.useService,
             service: params.service,
@@ -680,6 +407,54 @@ class CdpBridge {
         const mouse = this.client.getMousePosition();
         return await (0, captcha_solver_1.detectAndSolve)(evaluate, sendCommand, pageUrl, mouse, opts);
     }
+    // ─── Screenshot ───────────────────────────────────────────────────
+    async screenshot(params) {
+        const format = params.format === "png" ? "png" : "jpeg";
+        const quality = params.quality || 80;
+        if (params.x !== undefined) {
+            const result = await this.client.sendCommand("Page.captureScreenshot", {
+                format,
+                quality,
+                clip: {
+                    x: params.x,
+                    y: params.y,
+                    width: params.width || 100,
+                    height: params.height || 100,
+                    scale: 1,
+                },
+            });
+            return result.data;
+        }
+        return await this.client.screenshot(format, quality);
+    }
+    // ─── Wait helpers (compact versions kept here) ────────────────────
+    async waitForSelectorCompact(params) {
+        const selector = params.selector;
+        if (!selector)
+            throw new Error("selector required");
+        const found = await this.client.waitForSelector(selector, params.timeout || 5000, {
+            visible: params.visible === true,
+            stable: params.stable === true,
+        });
+        return { success: found, selector };
+    }
+    async waitForText(params) {
+        const text = String(params.text || "");
+        if (!text)
+            throw new Error("text required");
+        const timeout = params.timeout || 5000;
+        const start = Date.now();
+        while (Date.now() - start < timeout) {
+            const found = await this.client
+                .evaluate(`(document.body && document.body.innerText || '').includes(${JSON.stringify(text)})`)
+                .catch(() => false);
+            if (found)
+                return { success: true, text };
+            await new Promise((r) => setTimeout(r, 200 * Math.max(0.1, this.getSpeedMultiplier())));
+        }
+        return { success: false, text, message: "Text not found before timeout" };
+    }
+    // ─── Browser Intent ───────────────────────────────────────────────
     async browserIntent(params) {
         const intent = String(params.intent || "").toLowerCase();
         const timeout = params.timeout || 7000;
@@ -687,1004 +462,188 @@ class CdpBridge {
             const url = params.value || params.target;
             if (!url)
                 throw new Error("value or target required for navigate intent");
-            await this.navigate({ url: String(url), timeout });
-            return this.intentResult(true, intent, undefined, { url });
+            await Navigation.navigate(this.client, { url: String(url), timeout }, this.snapshotCache);
+            return { success: true, intent, url };
         }
         if (intent === "inspect") {
-            const snapshot = await this.snapshotCompact({ maxElements: params.maxElements ?? 30, includeText: true });
-            return this.intentResult(true, intent, undefined, snapshot);
+            const snapshot = await Inspection.snapshotCompact(this.client, this.snapshotCache, {
+                maxElements: params.maxElements ?? 30,
+                includeText: true,
+            });
+            return { success: true, intent, ...snapshot };
         }
         if (intent === "wait_for") {
             const expected = params.value || params.target;
             if (!expected)
                 throw new Error("value or target required for wait_for intent");
             const result = await this.waitForText({ text: expected, timeout });
-            return this.intentResult(result.success, intent, undefined, result);
+            return { success: result.success, intent, ...result };
         }
         const resolved = await this.locator.resolve({
             target: params.target,
             role: params.role,
             timeout,
-            includeCandidates: params.includeCandidates
+            includeCandidates: params.includeCandidates,
         });
         if (!resolved.success) {
-            return this.intentResult(false, intent, undefined, {
+            return {
+                success: false,
+                intent,
                 message: resolved.message,
-                candidates: params.includeCandidates ? resolved.candidates : undefined
-            });
+                candidates: params.includeCandidates ? resolved.candidates : undefined,
+            };
         }
         const selector = resolved.selector;
+        const candidate = resolved.candidate;
         if (intent === "click") {
-            await this.clickResolvedLocator(resolved.candidate);
+            await Interaction.clickResolvedLocator(this.client, this.locator, this.snapshotCache, candidate);
         }
         else if (intent === "fill") {
-            if (resolved.candidate?.scope === "document" && resolved.candidate.framePath.length === 0 && resolved.candidate.shadowDepth === 0) {
-                await this.fillBySelector({ selector, value: params.value ?? "", timeout });
+            if (candidate?.scope === "document" && candidate.framePath.length === 0 && candidate.shadowDepth === 0 && selector) {
+                await Interaction.fillBySelector(this.client, this.locator, this.snapshotCache, {
+                    selector: selector,
+                    value: params.value ?? "",
+                    timeout,
+                }, this.logger);
             }
             else {
-                await this.locator.focusAndClear(resolved.candidate);
+                await this.locator.focusAndClear(candidate);
                 await this.client.typeText(String(params.value ?? ""));
             }
         }
         else if (intent === "select") {
-            await this.selectOption({ selector, value: params.value ?? "" });
+            await Interaction.selectOption(this.client, this.locator, this.snapshotCache, {
+                selector: selector,
+                value: params.value ?? "",
+            }, this.logger);
         }
         else if (intent === "check") {
-            await this.checkElement({ selector });
+            await Interaction.checkElement(this.client, this.locator, this.snapshotCache, {
+                selector: selector,
+            }, this.logger);
         }
         else {
             throw new Error(`Unsupported browser intent: ${intent}`);
         }
-        this.snapshotCache.invalidate(`browser_intent:${intent}`);
         let verification = undefined;
         if (params.verify) {
             verification = await this.waitForText({ text: params.verify, timeout }).catch((error) => ({
                 success: false,
-                error: error.message
+                error: error.message,
             }));
         }
-        return this.intentResult(true, intent, resolved, {
+        return {
+            success: true,
+            intent,
+            target: resolved.target,
+            matchedBy: resolved.matchedBy,
+            confidence: resolved.confidence,
             selector,
             ref: resolved.ref || (selector ? `css:${selector}` : undefined),
             verification,
-            candidates: params.includeCandidates ? resolved.candidates : undefined
-        });
-    }
-    intentResult(success, intent, resolved, extra = {}) {
-        return {
-            success,
-            intent,
-            target: resolved?.target,
-            matchedBy: resolved?.matchedBy,
-            confidence: resolved?.confidence,
-            ...extra
-        };
-    }
-    async captureActionFacts(selector) {
-        return await this.client.evaluate(`
-            (function() {
-                const selector = ${JSON.stringify(selector || "")};
-                const active = document.activeElement;
-                const target = selector ? document.querySelector(selector) : active;
-                const visibleErrors = Array.from(document.querySelectorAll('[role="alert"], .error, .errors, [aria-invalid="true"]'))
-                    .filter((el) => {
-                        const rect = el.getBoundingClientRect();
-                        const style = window.getComputedStyle(el);
-                        return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
-                    })
-                    .map((el) => String(el.innerText || el.textContent || el.getAttribute('aria-label') || '').trim().replace(/\\s+/g, ' '))
-                    .filter(Boolean)
-                    .slice(0, 5);
-
-                function describe(el) {
-                    if (!el) return null;
-                    return {
-                        tag: el.tagName.toLowerCase(),
-                        id: el.id || '',
-                        name: el.getAttribute('name') || '',
-                        role: el.getAttribute('role') || '',
-                        type: el.getAttribute('type') || '',
-                        value: 'value' in el ? String(el.value || '') : '',
-                        checked: 'checked' in el ? !!el.checked : undefined,
-                        selectedIndex: 'selectedIndex' in el ? el.selectedIndex : undefined,
-                        text: String(el.innerText || el.textContent || '').trim().replace(/\\s+/g, ' ').substring(0, 160)
-                    };
-                }
-
-                return {
-                    url: window.location.href,
-                    title: document.title,
-                    readyState: document.readyState,
-                    focused: describe(active),
-                    target: describe(target),
-                    visibleErrors
-                };
-            })()
-        `).catch(() => ({}));
-    }
-    diffActionFacts(before, after) {
-        return {
-            urlChanged: before?.url !== after?.url,
-            titleChanged: before?.title !== after?.title,
-            focused: after?.focused,
-            target: after?.target,
-            valueChanged: before?.target?.value !== after?.target?.value,
-            checkedChanged: before?.target?.checked !== after?.target?.checked,
-            selectedIndexChanged: before?.target?.selectedIndex !== after?.target?.selectedIndex,
-            visibleErrors: after?.visibleErrors || []
-        };
-    }
-    async resolveNaturalTarget(params) {
-        const target = String(params.target || "").trim();
-        const role = params.role ? String(params.role).toLowerCase() : "";
-        const timeout = params.timeout || 7000;
-        const start = Date.now();
-        if (!target && !role) {
-            return { success: false, message: "target or role required" };
-        }
-        while (Date.now() - start < timeout) {
-            const result = await this.client.sendCommand("Runtime.evaluate", {
-                expression: `
-                    (function() {
-                        const target = ${JSON.stringify(target)};
-                        const targetLower = target.toLowerCase();
-                        const roleHint = ${JSON.stringify(role)};
-                        const selectors = [
-                            'a[href]', 'button', 'input:not([type="hidden"])', 'select', 'textarea',
-                            '[onclick]', '[role]', '[tabindex]:not([tabindex="-1"])', 'label', 'summary'
-                        ].join(', ');
-
-                        function cssPath(el) {
-                            if (el.id) return '#' + CSS.escape(el.id);
-                            const path = [];
-                            while (el && el.nodeType === Node.ELEMENT_NODE && el !== document.body) {
-                                let selector = el.nodeName.toLowerCase();
-                                if (el.classList && el.classList.length) {
-                                    selector += '.' + Array.from(el.classList).slice(0, 2).map(c => CSS.escape(c)).join('.');
-                                }
-                                const parent = el.parentElement;
-                                if (parent) {
-                                    const siblings = Array.from(parent.children).filter(child => child.nodeName === el.nodeName);
-                                    if (siblings.length > 1) selector += ':nth-of-type(' + (siblings.indexOf(el) + 1) + ')';
-                                }
-                                path.unshift(selector);
-                                el = parent;
-                            }
-                            return path.length ? path.join(' > ') : '';
-                        }
-
-                        function visible(el) {
-                            const rect = el.getBoundingClientRect();
-                            const computed = window.getComputedStyle(el);
-                            return computed.display !== 'none' &&
-                                computed.visibility !== 'hidden' &&
-                                computed.opacity !== '0' &&
-                                rect.width > 0 &&
-                                rect.height > 0;
-                        }
-
-                        function inferRole(el) {
-                            const explicit = (el.getAttribute('role') || '').toLowerCase();
-                            if (explicit) return explicit;
-                            const tag = el.tagName.toLowerCase();
-                            const type = (el.getAttribute('type') || '').toLowerCase();
-                            if (tag === 'button' || type === 'button' || type === 'submit') return 'button';
-                            if (tag === 'a') return 'link';
-                            if (tag === 'textarea') return 'textbox';
-                            if (tag === 'select') return 'combobox';
-                            if (tag === 'input' && ['checkbox', 'radio'].includes(type)) return type;
-                            if (tag === 'input') return 'textbox';
-                            return tag;
-                        }
-
-                        function labelFor(el) {
-                            if (el.id) {
-                                const label = document.querySelector('label[for="' + CSS.escape(el.id) + '"]');
-                                if (label) return label.innerText || label.textContent || '';
-                            }
-                            const wrappingLabel = el.closest('label');
-                            return wrappingLabel ? (wrappingLabel.innerText || wrappingLabel.textContent || '') : '';
-                        }
-
-                        function norm(value) {
-                            return String(value || '').trim().replace(/\\s+/g, ' ');
-                        }
-
-                        function scoreField(value, weightExact, weightIncludes) {
-                            const text = norm(value);
-                            const lower = text.toLowerCase();
-                            if (!targetLower) return { score: 0, by: '' };
-                            if (lower === targetLower) return { score: weightExact, by: 'exact' };
-                            if (lower.includes(targetLower)) return { score: weightIncludes, by: 'contains' };
-                            if (targetLower.includes(lower) && lower.length >= 3) return { score: Math.max(1, weightIncludes - 1), by: 'contained_by_target' };
-                            return { score: 0, by: '' };
-                        }
-
-                        const candidates = Array.from(document.querySelectorAll(selectors)).map((el) => {
-                            if (!visible(el)) return null;
-                            const selector = cssPath(el);
-                            if (!selector) return null;
-
-                            const inferredRole = inferRole(el);
-                            const fields = [
-                                ['selector', selector, 12, 10],
-                                ['aria-label', el.getAttribute('aria-label'), 11, 9],
-                                ['label', labelFor(el), 11, 9],
-                                ['placeholder', el.getAttribute('placeholder'), 10, 8],
-                                ['name', el.getAttribute('name'), 9, 7],
-                                ['text', el.innerText || el.textContent, 8, 6],
-                                ['value', el.getAttribute('value'), 7, 5],
-                                ['title', el.getAttribute('title'), 6, 4]
-                            ];
-
-                            let score = 0;
-                            let matchedBy = '';
-                            for (const [field, value, exact, includes] of fields) {
-                                const match = scoreField(value, exact, includes);
-                                if (match.score > score) {
-                                    score = match.score;
-                                    matchedBy = field + ':' + match.by;
-                                }
-                            }
-
-                            if (roleHint) {
-                                if (inferredRole === roleHint) score += 4;
-                                else if (roleHint === 'textbox' && ['input', 'textarea'].includes(el.tagName.toLowerCase())) score += 3;
-                                else score -= 2;
-                            }
-
-                            const rect = el.getBoundingClientRect();
-                            return {
-                                selector,
-                                role: inferredRole,
-                                tag: el.tagName.toLowerCase(),
-                                type: el.getAttribute('type') || '',
-                                text: norm(el.innerText || el.textContent || el.getAttribute('aria-label') || el.getAttribute('placeholder')).substring(0, 120),
-                                matchedBy,
-                                score,
-                                bounds: {
-                                    x: Math.round(rect.left),
-                                    y: Math.round(rect.top),
-                                    width: Math.round(rect.width),
-                                    height: Math.round(rect.height)
-                                }
-                            };
-                        }).filter(Boolean).sort((a, b) => b.score - a.score);
-
-                        return candidates;
-                    })()
-                `,
-                returnByValue: true,
-                awaitPromise: true
-            });
-            const candidates = result.result?.value || [];
-            const best = candidates[0];
-            if (best && best.score > 0) {
-                return {
-                    success: true,
-                    target,
-                    selector: best.selector,
-                    matchedBy: best.matchedBy,
-                    confidence: Math.min(1, best.score / 16),
-                    candidates: params.includeCandidates ? candidates.slice(0, 10) : undefined
-                };
-            }
-            await new Promise(r => setTimeout(r, 200));
-        }
-        return { success: false, target, message: "No matching visible element found" };
-    }
-    async getState(params) {
-        const includeScreenshot = params.screenshot === true;
-        const includeDomSnapshot = params.domSnapshot === true || params.includeDOMSnapshot === true;
-        const includeElements = params.elements !== false;
-        const includeSoM = params.som === true || params.withOverlay === true;
-        const includeTabs = params.tabs === true;
-        const compact = includeElements
-            ? await this.snapshotCache.compact({ maxElements: 200, includeText: true, withOverlay: includeSoM })
-            : await this.snapshotCache.compact({ maxElements: 0, includeText: false });
-        const [screenshot, domSnapshot, tabs] = await Promise.all([
-            includeScreenshot ? this.client.screenshot(params.format, params.quality).catch(() => null) : Promise.resolve(null),
-            includeDomSnapshot ? this.client.getDOMSnapshot().catch(() => null) : Promise.resolve(null),
-            includeTabs ? this.client.getTabs().catch(() => []) : Promise.resolve([]),
-        ]);
-        if (includeSoM) {
-            await this.client.removeSoMOverlay().catch(() => { });
-        }
-        return {
-            title: compact.title,
-            url: compact.url,
-            screenshot,
-            domSnapshot,
-            elements: includeElements ? compact.elements : [],
-            somInjected: includeSoM,
-            cache: compact.cache,
-            tabs,
+            candidates: params.includeCandidates ? resolved.candidates : undefined,
         };
     }
-    async navigate(params) {
-        await this.client.navigateAndWait(params.url, params.timeout || 10000);
-        this.snapshotCache.invalidate("navigate");
-        return "Navigated";
-    }
-    async waitForPageSettled(timeout = 10000) {
+    // ─── Agent APIs ───────────────────────────────────────────────────
+    async agentAction(params) {
+        const { action, target, verify, waitFor, timeout } = params;
+        const timeoutMs = timeout || 10000;
         try {
-            await this.client.waitForNavigation(Math.min(timeout, 10000));
-        }
-        catch {
-            await this.client.waitForNetworkIdle(300, Math.min(timeout, 2500)).catch(() => { });
-        }
-    }
-    async click(params) {
-        const x = params.x || params.coordinate?.split(',')[0] || 100;
-        const y = params.y || params.coordinate?.split(',')[1] || 100;
-        await this.client.click(x, y);
-        this.snapshotCache.invalidate("click");
-        return "Clicked";
-    }
-    async clickElement(params) {
-        // Click by element ID (from SoM) - resolves ID to coordinates
-        if (params.id !== undefined) {
-            const result = await this.client.evaluate(`
-                (function() {
-                    const targetId = Number(${JSON.stringify(String(params.id).replace(/@/g, ''))});
-                    const selectors = [
-                        'a[href]', 'button', 'input:not([type="hidden"])', 'select', 'textarea',
-                        '[onclick]', '[role="button"]', '[role="link"]', '[role="checkbox"]',
-                        '[tabindex]:not([tabindex="-1"])', 'label', 'summary'
-                    ].join(', ');
-                    const elements = Array.from(document.querySelectorAll(selectors)).filter((el) => {
-                        const rect = el.getBoundingClientRect();
-                        const computed = window.getComputedStyle(el);
-                        return computed.display !== 'none' &&
-                            computed.visibility !== 'hidden' &&
-                            rect.width > 0 &&
-                            rect.height > 0;
-                    });
-                    const el = elements[targetId - 1];
-                    if (el) {
-                        el.scrollIntoView({ block: 'center', inline: 'center', behavior: 'instant' });
-                        const rect = el.getBoundingClientRect();
-                        return { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2, w: rect.width };
+            switch (action) {
+                case "click":
+                    if (target.id) {
+                        await Interaction.clickElement(this.client, this.locator, this.snapshotCache, { id: target.id, button: target.button }, this.logger);
                     }
-                    return null;
-                })()
-            `);
-            if (result) {
-                await this.client.click(result.x, result.y, params.button, result.w);
-                this.snapshotCache.invalidate("click_element");
-                return `Clicked element @${params.id}`;
+                    else if (target.selector) {
+                        await this.client.waitForSelector(target.selector, 5000);
+                        await Interaction.clickElementBySelector(this.client, this.locator, this.snapshotCache, { selector: target.selector, button: target.button }, this.logger);
+                    }
+                    else if (target.x !== undefined) {
+                        await this.client.click(target.x, target.y, target.button);
+                    }
+                    break;
+                case "type":
+                    if (target.selector) {
+                        await this.client.waitForSelector(target.selector, 5000);
+                        await this.client.moveMouseToSelector(target.selector).catch(() => { });
+                        await this.client.evaluate(`(function(){var el=document.querySelector(${JSON.stringify(target.selector)});if(el){el.value='';el.focus();}})()`);
+                    }
+                    await this.client.typeText(target.text || target.value || "");
+                    break;
+                case "scroll":
+                    await this.client.sendCommand("Input.dispatchMouseWheel", {
+                        x: target.x || 0, y: target.y || 0,
+                        deltaX: target.deltaX || 0, deltaY: target.deltaY || target.y || 0,
+                    });
+                    break;
+                case "key_press":
+                    await this.client.sendCommand("Input.dispatchKeyEvent", { type: "keyDown", text: target.key, key: target.key });
+                    await this.client.sendCommand("Input.dispatchKeyEvent", { type: "keyUp", text: target.key, key: target.key });
+                    break;
+                case "hover":
+                    await this.client.moveMouse(target.x || 0, target.y || 0);
+                    break;
+                case "drag":
+                    const sx = target.startX || target.x || 0;
+                    const sy = target.startY || target.y || 0;
+                    const ex = target.endX || sx + 100;
+                    const ey = target.endY || sy + 100;
+                    await this.client.moveMouse(sx, sy);
+                    await this.client.sendCommand("Input.dispatchMouseEvent", { type: "mousePressed", x: sx, y: sy, button: "left", clickCount: 1 });
+                    await this.client.moveMouse(ex, ey);
+                    await this.client.sendCommand("Input.dispatchMouseEvent", { type: "mouseReleased", x: ex, y: ey, button: "left", clickCount: 1 });
+                    break;
             }
-            // Fallback: try to find element by selector or text
-            if (params.selector) {
-                return this.clickElementBySelector({ selector: params.selector });
+            if (waitFor) {
+                if (waitFor.type === "network_idle") {
+                    await this.client.waitForNetworkIdle(500, waitFor.timeout || 3000);
+                }
+                else if (waitFor.type === "element" && waitFor.selector) {
+                    await this.client.waitForSelector(waitFor.selector, waitFor.timeout || 5000);
+                }
+                else if (waitFor.type === "navigation") {
+                    await this.client.waitForNavigation(waitFor.timeout || 10000).catch(() => { });
+                }
             }
-            if (params.text) {
-                return this.clickElementByText({ text: params.text });
+            else {
+                await new Promise((r) => setTimeout(r, 500));
             }
+            let verification = null;
+            if (verify) {
+                if (verify.type === "element_exists") {
+                    verification = await this.client.evaluate(`(function(){var el=document.querySelector(${JSON.stringify(verify.selector)});return {success:!!el,exists:!!el,message:el?"Element exists":"Element not found"};})()`);
+                }
+                else if (verify.type === "element_contains_text") {
+                    verification = await this.client.evaluate(`(function(){var el=document.querySelector(${JSON.stringify(verify.selector)});if(!el)return {success:false,message:"Element not found"};var t=(el.innerText||el.textContent||"").trim();var m=t.indexOf(${JSON.stringify(verify.expectedText || verify.text || "")})>=0;return {success:m,text:t,message:m?"Verified":"Text mismatch"};})()`);
+                }
+                else if (verify.selector) {
+                    const res = await this.client.evaluate(`!!document.querySelector(${JSON.stringify(verify.selector)})`);
+                    verification = { success: !!res, selector: verify.selector };
+                }
+            }
+            const screenshot = params.screenshot === true ? await this.client.screenshot("jpeg", 70).catch(() => null) : null;
+            const url = await this.client.evaluate("window.location.href").catch(() => "Unknown");
+            const title = await this.client.evaluate("document.title").catch(() => "Unknown");
+            return { success: true, action: `${action} completed`, verification, screenshot, url, title };
         }
-        // Fallback to coordinate click
-        if (params.x !== undefined && params.y !== undefined) {
-            await this.client.click(params.x, params.y);
-            this.snapshotCache.invalidate("click_element");
-            return "Clicked at coordinates";
-        }
-        throw new Error("Element not found: no valid id, selector, text, or coordinates provided");
-    }
-    async clickElementByText(params) {
-        const result = await this.locator.resolve({ target: params.text, timeout: params.timeout || 5000 });
-        if (result.success && result.candidate) {
-            await this.clickResolvedLocator(result.candidate);
-            this.snapshotCache.invalidate("click_element_by_text");
-            return `Clicked element with text: ${params.text}`;
-        }
-        throw new Error(`Element with text not found: ${params.text}`);
-    }
-    async clickElementBySelector(params) {
-        const selector = params.selector;
-        if (!selector)
-            throw new Error("Selector required");
-        if (String(selector).startsWith("point:")) {
-            const [x, y] = String(selector).slice(6).split(",").map(Number);
-            if (!Number.isFinite(x) || !Number.isFinite(y))
-                throw new Error(`Invalid point selector: ${selector}`);
-            await this.client.click(x, y);
-            this.snapshotCache.invalidate("click_element_by_selector");
-            return "Clicked element by point";
-        }
-        // Run the full actionability gate (visible, enabled, in-viewport, stable
-        // bounds, not obscured) before committing the click.
-        const point = await this.resolveActionablePoint(selector, params.timeout ?? 4000);
-        if (!point.ok) {
-            const detail = point.reason === "obscured" && point.obscuredBy
-                ? `${point.reason} by <${point.obscuredBy}>`
-                : point.reason;
-            throw new Error(`Element not actionable (${detail}): ${selector}`);
-        }
-        await this.client.click(point.x, point.y, params.button, point.w);
-        this.snapshotCache.invalidate("click_element_by_selector");
-        return "Clicked element by selector";
-    }
-    /**
-     * Centralized actionability gate. Polls until the selector resolves to an
-     * element that is visible, enabled, scrolled into the viewport, has stable
-     * bounds across frames, and is the topmost element at its own click point
-     * (i.e. not covered by an overlay/cookie banner). Returns the verified click
-     * point, or the blocking reason so the caller can surface it.
-     */
-    async resolveActionablePoint(selector, timeout = 4000) {
-        const start = Date.now();
-        let lastBoxKey = "";
-        let stableHits = 0;
-        let last = { ok: false, reason: "not_found" };
-        while (Date.now() - start < timeout) {
-            const result = await this.client.sendCommand("Runtime.evaluate", {
-                expression: `
-                    (function() {
-                        const el = document.querySelector(${JSON.stringify(selector)});
-                        if (!el) return { ok: false, reason: 'not_found' };
-                        el.scrollIntoView({ block: 'center', inline: 'center', behavior: 'instant' });
-                        const rect = el.getBoundingClientRect();
-                        const style = window.getComputedStyle(el);
-                        if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0' || rect.width === 0 || rect.height === 0) {
-                            return { ok: false, reason: 'not_visible' };
-                        }
-                        if (el.disabled === true || el.getAttribute('aria-disabled') === 'true' || style.pointerEvents === 'none') {
-                            return { ok: false, reason: 'disabled' };
-                        }
-                        const cx = rect.left + rect.width / 2;
-                        const cy = rect.top + rect.height / 2;
-                        const vw = window.innerWidth || document.documentElement.clientWidth;
-                        const vh = window.innerHeight || document.documentElement.clientHeight;
-                        if (cx < 0 || cy < 0 || cx > vw || cy > vh) {
-                            return { ok: false, reason: 'offscreen' };
-                        }
-                        const top = document.elementFromPoint(cx, cy);
-                        const reachable = top === el || el.contains(top) || (top && top.contains(el));
-                        let obscuredBy = '';
-                        if (!reachable && top) {
-                            obscuredBy = top.tagName.toLowerCase() + (top.id ? '#' + top.id : '');
-                        }
-                        return {
-                            ok: !!reachable,
-                            reason: reachable ? 'ok' : 'obscured',
-                            obscuredBy: obscuredBy,
-                            x: cx,
-                            y: cy,
-                            w: rect.width,
-                            boxKey: Math.round(rect.left) + ',' + Math.round(rect.top) + ',' + Math.round(rect.width) + ',' + Math.round(rect.height)
-                        };
-                    })()
-                `,
-                returnByValue: true,
-            });
-            const state = result.result?.value;
-            if (state) {
-                last = state;
-                if (state.ok) {
-                    if (state.boxKey === lastBoxKey) {
-                        stableHits++;
-                        if (stableHits >= 1) {
-                            return { ok: true, reason: "ok", x: state.x, y: state.y, w: state.w };
-                        }
-                    }
-                    else {
-                        lastBoxKey = state.boxKey;
-                        stableHits = 0;
-                    }
-                }
-            }
-            await new Promise(r => setTimeout(r, 90));
-        }
-        return { ok: false, reason: last?.reason || "timeout", obscuredBy: last?.obscuredBy };
-    }
-    async type(params) {
-        const text = params.text || params.value || "";
-        await this.client.typeText(text);
-        return "Typed text";
-    }
-    async evaluate(params) {
-        return await this.client.evaluate(params.script);
-    }
-    async screenshot(params) {
-        const format = params.format === "png" ? "png" : "jpeg";
-        const quality = params.quality || 80;
-        if (params.x !== undefined) {
-            // Region screenshot - use CDP clipping
-            const result = await this.client.sendCommand("Page.captureScreenshot", {
-                format,
-                quality,
-                clip: {
-                    x: params.x,
-                    y: params.y,
-                    width: params.width || 100,
-                    height: params.height || 100,
-                    scale: 1,
-                },
-            });
-            return result.data;
-        }
-        return await this.client.screenshot(format, quality);
-    }
-    async scroll(params) {
-        const x = params.x || 0;
-        const y = params.y || 0;
-        const originX = params.originX ?? params.mouseX ?? params.options?.originX;
-        const originY = params.originY ?? params.mouseY ?? params.options?.originY;
-        await this.client.wheel(x, y, originX, originY);
-        return "Scrolled";
-    }
-    async wait(params) {
-        const ms = params.ms || params.timeout || 1000;
-        await new Promise((r) => setTimeout(r, ms));
-        return "Waited";
-    }
-    async cdpCommand(params) {
-        return await this.client.sendCommand(params.command, params.args || {});
-    }
-    async getDomSnapshot(params) {
-        return await this.client.getDOMSnapshot();
-    }
-    /**
-     * Extract clean, readable page content as Markdown (or plain text) — a
-     * token-cheap alternative to screenshots or full DOM dumps for reading a page.
-     * Scopes to `selector` when provided, otherwise picks the main content region.
-     */
-    async getPageText(params) {
-        const format = params.format === "text" ? "text" : "markdown";
-        const selector = params.selector ? String(params.selector) : "";
-        const maxLength = Math.max(500, Math.min(Number(params.maxLength ?? 20000), 200000));
-        const includeLinks = params.includeLinks !== false;
-        const extracted = await this.client.evaluate(`
-            (function() {
-                const FORMAT = ${JSON.stringify(format)};
-                const SELECTOR = ${JSON.stringify(selector)};
-                const INCLUDE_LINKS = ${JSON.stringify(includeLinks)};
-                const SKIP = new Set(['SCRIPT','STYLE','NOSCRIPT','SVG','CANVAS','TEMPLATE','IFRAME','OBJECT','EMBED','NAV','FOOTER','HEADER','ASIDE']);
-
-                function pickRoot() {
-                    if (SELECTOR) {
-                        const el = document.querySelector(SELECTOR);
-                        if (el) return el;
-                    }
-                    return document.querySelector('main, article, [role="main"]') || document.body || document.documentElement;
-                }
-
-                function isHidden(el) {
-                    if (el.getAttribute && el.getAttribute('aria-hidden') === 'true') return true;
-                    const style = window.getComputedStyle(el);
-                    if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return true;
-                    const rect = el.getBoundingClientRect();
-                    return rect.width === 0 && rect.height === 0 && el.tagName !== 'BR' && el.tagName !== 'HR';
-                }
-
-                function inline(node) {
-                    let out = '';
-                    node.childNodes.forEach(function(child) {
-                        if (child.nodeType === Node.TEXT_NODE) {
-                            out += child.textContent.replace(/\\s+/g, ' ');
-                        } else if (child.nodeType === Node.ELEMENT_NODE) {
-                            if (SKIP.has(child.tagName) || isHidden(child)) return;
-                            const tag = child.tagName.toLowerCase();
-                            const inner = inline(child);
-                            if (FORMAT === 'markdown') {
-                                if (tag === 'a' && INCLUDE_LINKS && child.getAttribute('href')) {
-                                    const href = child.getAttribute('href');
-                                    out += inner.trim() ? '[' + inner.trim() + '](' + href + ')' : '';
-                                } else if (tag === 'strong' || tag === 'b') {
-                                    out += inner.trim() ? '**' + inner.trim() + '**' : '';
-                                } else if (tag === 'em' || tag === 'i') {
-                                    out += inner.trim() ? '*' + inner.trim() + '*' : '';
-                                } else if (tag === 'code') {
-                                    out += inner.trim() ? '\`' + inner.trim() + '\`' : '';
-                                } else if (tag === 'br') {
-                                    out += '\\n';
-                                } else {
-                                    out += inner;
-                                }
-                            } else {
-                                out += (tag === 'br') ? '\\n' : inner;
-                            }
-                        }
-                    });
-                    return out;
-                }
-
-                const BLOCK = new Set(['P','DIV','SECTION','ARTICLE','UL','OL','LI','TABLE','TR','BLOCKQUOTE','PRE','H1','H2','H3','H4','H5','H6','HR','FIGURE','FIGCAPTION']);
-                const lines = [];
-
-                function walk(node, depth) {
-                    if (node.nodeType !== Node.ELEMENT_NODE) return;
-                    if (SKIP.has(node.tagName) || isHidden(node)) return;
-                    const tag = node.tagName.toLowerCase();
-
-                    if (/^h[1-6]$/.test(tag)) {
-                        const t = inline(node).trim();
-                        if (t) lines.push(FORMAT === 'markdown' ? '#'.repeat(Number(tag[1])) + ' ' + t : t);
-                        return;
-                    }
-                    if (tag === 'hr') { lines.push(FORMAT === 'markdown' ? '---' : ''); return; }
-                    if (tag === 'pre') {
-                        const t = (node.innerText || node.textContent || '').replace(/\\s+$/,'');
-                        if (t) lines.push(FORMAT === 'markdown' ? '\\n\`\`\`\\n' + t + '\\n\`\`\`\\n' : t);
-                        return;
-                    }
-                    if (tag === 'li') {
-                        const t = inline(node).trim();
-                        if (t) {
-                            const indent = '  '.repeat(Math.max(0, depth));
-                            lines.push(FORMAT === 'markdown' ? indent + '- ' + t : indent + '• ' + t);
-                        }
-                        return;
-                    }
-                    if (tag === 'blockquote') {
-                        const t = inline(node).trim();
-                        if (t) lines.push(FORMAT === 'markdown' ? '> ' + t : t);
-                        return;
-                    }
-                    if (tag === 'tr') {
-                        const cells = Array.from(node.children).map(function(c){ return inline(c).trim(); });
-                        if (cells.some(Boolean)) lines.push(FORMAT === 'markdown' ? '| ' + cells.join(' | ') + ' |' : cells.join('\\t'));
-                        return;
-                    }
-
-                    // Leaf-ish block (no block descendants): emit its inline text once.
-                    const hasBlockChild = Array.from(node.children).some(function(c){ return BLOCK.has(c.tagName); });
-                    if (!hasBlockChild && (tag === 'p' || tag === 'div' || tag === 'section' || tag === 'figcaption' || tag === 'td' || tag === 'th')) {
-                        const t = inline(node).trim();
-                        if (t) lines.push(t);
-                        return;
-                    }
-
-                    const nextDepth = (tag === 'ul' || tag === 'ol') ? depth + 1 : depth;
-                    node.childNodes.forEach(function(child){ walk(child, nextDepth); });
-                }
-
-                const root = pickRoot();
-                walk(root, 0);
-
-                let text = lines.join('\\n\\n').replace(/\\n{3,}/g, '\\n\\n').replace(/[ \\t]+\\n/g, '\\n').trim();
-                return { title: document.title || '', url: location.href, text: text };
-            })()
-        `).catch((e) => ({ title: "", url: "", text: "", error: e?.message }));
-        const text = String(extracted?.text ?? "");
-        const truncated = text.length > maxLength;
-        return {
-            title: extracted?.title ?? "",
-            url: extracted?.url ?? "",
-            format,
-            length: text.length,
-            truncated,
-            text: truncated ? text.slice(0, maxLength) + "\n\n…[truncated]" : text,
-        };
-    }
-    defaultAuthStatePath(custom) {
-        if (custom)
-            return path_1.default.resolve(String(custom));
-        return path_1.default.resolve(process.cwd(), ".aether", "auth-state.json");
-    }
-    // CDP Network.getAllCookies returns Cookie objects with read-only fields
-    // (size, session, …) that Network.setCookies rejects. Keep only CookieParam fields.
-    toCookieParam(c) {
-        const param = {
-            name: c.name,
-            value: c.value,
-            domain: c.domain,
-            path: c.path,
-            secure: c.secure,
-            httpOnly: c.httpOnly,
-        };
-        if (typeof c.expires === "number" && c.expires > 0)
-            param.expires = c.expires;
-        if (c.sameSite)
-            param.sameSite = c.sameSite;
-        if (c.priority)
-            param.priority = c.priority;
-        if (c.sourceScheme)
-            param.sourceScheme = c.sourceScheme;
-        if (typeof c.sourcePort === "number")
-            param.sourcePort = c.sourcePort;
-        if (c.partitionKey)
-            param.partitionKey = c.partitionKey;
-        return param;
-    }
-    /**
-     * Export the current session (cookies + localStorage + sessionStorage of the
-     * active origin) to a JSON file so a logged-in state can be reused later.
-     */
-    async saveAuthState(params) {
-        const filePath = this.defaultAuthStatePath(params.path);
-        const cookiesRes = await this.client.sendCommand("Network.getAllCookies", {})
-            .catch(() => this.client.sendCommand("Storage.getCookies", {}).catch(() => ({ cookies: [] })));
-        const cookies = (cookiesRes?.cookies || []).map((c) => this.toCookieParam(c));
-        const storage = await this.client.evaluate(`
-            (function() {
-                const ls = {}, ss = {};
-                try { for (let i = 0; i < localStorage.length; i++) { const k = localStorage.key(i); ls[k] = localStorage.getItem(k); } } catch (e) {}
-                try { for (let i = 0; i < sessionStorage.length; i++) { const k = sessionStorage.key(i); ss[k] = sessionStorage.getItem(k); } } catch (e) {}
-                return { origin: location.origin, localStorage: ls, sessionStorage: ss };
-            })()
-        `).catch(() => null);
-        const state = {
-            version: 1,
-            savedAt: new Date().toISOString(),
-            cookies,
-            origins: storage ? [storage] : [],
-        };
-        await fs_1.promises.mkdir(path_1.default.dirname(filePath), { recursive: true });
-        await fs_1.promises.writeFile(filePath, JSON.stringify(state, null, 2), "utf8");
-        return {
-            success: true,
-            path: filePath,
-            cookies: cookies.length,
-            origins: state.origins.length,
-            storageKeys: storage ? Object.keys(storage.localStorage).length + Object.keys(storage.sessionStorage).length : 0,
-        };
-    }
-    /**
-     * Restore a session saved by saveAuthState. Cookies are set globally; storage
-     * is restored for the active origin (navigate to the site first), then the tab
-     * is reloaded so the session takes effect.
-     */
-    async loadAuthState(params) {
-        const filePath = this.defaultAuthStatePath(params.path);
-        let raw;
-        try {
-            raw = await fs_1.promises.readFile(filePath, "utf8");
-        }
-        catch (e) {
-            return { success: false, path: filePath, message: `Could not read auth state: ${e?.message}` };
-        }
-        let state;
-        try {
-            state = JSON.parse(raw);
-        }
-        catch (e) {
-            return { success: false, path: filePath, message: `Invalid auth state JSON: ${e?.message}` };
-        }
-        let cookiesSet = 0;
-        if (Array.isArray(state.cookies) && state.cookies.length) {
-            const params2 = state.cookies.map((c) => this.toCookieParam(c));
-            await this.client.setCookies(params2).catch((err) => {
-                console.error("[Aether] setCookies failed during loadAuthState:", err?.message);
-            });
-            cookiesSet = params2.length;
-        }
-        let storageRestored = 0;
-        let storageSkipped = 0;
-        const currentOrigin = await this.client.evaluate("location.origin").catch(() => "");
-        for (const entry of (state.origins || [])) {
-            if (entry.origin && currentOrigin && entry.origin !== currentOrigin) {
-                storageSkipped++;
-                continue;
-            }
-            const data = JSON.stringify({ localStorage: entry.localStorage || {}, sessionStorage: entry.sessionStorage || {} });
-            const ok = await this.client.evaluate(`
-                (function() {
-                    try {
-                        const data = ${data};
-                        for (const k in data.localStorage) localStorage.setItem(k, data.localStorage[k]);
-                        for (const k in data.sessionStorage) sessionStorage.setItem(k, data.sessionStorage[k]);
-                        return true;
-                    } catch (e) { return false; }
-                })()
-            `).catch(() => false);
-            if (ok)
-                storageRestored++;
-        }
-        if (params.reload !== false) {
-            await this.client.reload(false).catch(() => { });
-        }
-        this.snapshotCache.invalidate("load_auth_state");
-        return {
-            success: true,
-            path: filePath,
-            cookiesSet,
-            storageRestored,
-            storageSkipped,
-            note: storageSkipped > 0 ? "Some storage origins were skipped; navigate to that origin before loading to restore them." : undefined,
-        };
-    }
-    // ==================== AGENT-CENTRIC APIs ====================
-    async agentAction(params) {
-        const { action, target, verify, waitFor, timeout } = params;
-        const timeoutMs = timeout || 10000;
-        try {
-            // Execute action with proper element resolution
-            switch (action) {
-                case "click":
-                    if (target.id) {
-                        await this.clickElement({ id: target.id, button: target.button });
-                    }
-                    else if (target.selector) {
-                        // Wait for selector if needed
-                        await this.client.waitForSelector(target.selector, 5000);
-                        await this.clickElementBySelector({ selector: target.selector, button: target.button });
-                    }
-                    else if (target.x !== undefined) {
-                        await this.client.click(target.x, target.y, target.button);
-                    }
-                    break;
-                case "type":
-                    if (target.selector) {
-                        await this.client.waitForSelector(target.selector, 5000);
-                        await this.client.moveMouseToSelector(target.selector).catch(() => { });
-                        await this.client.evaluate(`
-                            (function() {
-                                const el = document.querySelector(${JSON.stringify(target.selector)});
-                                if (el) { el.value = ''; el.focus(); }
-                            })()
-                        `);
-                    }
-                    await this.client.typeText(target.text || target.value || "");
-                    break;
-                case "scroll":
-                    await this.client.sendCommand("Input.dispatchMouseWheel", {
-                        x: target.x || 0, y: target.y || 0,
-                        deltaX: target.deltaX || 0, deltaY: target.deltaY || target.y || 0
-                    });
-                    break;
-                case "key_press":
-                    await this.client.sendCommand("Input.dispatchKeyEvent", {
-                        type: "keyDown", text: target.key, key: target.key
-                    });
-                    await this.client.sendCommand("Input.dispatchKeyEvent", {
-                        type: "keyUp", text: target.key, key: target.key
-                    });
-                    break;
-                case "hover":
-                    await this.client.moveMouse(target.x || 0, target.y || 0);
-                    break;
-                case "drag":
-                    const sx = target.startX || target.x || 0;
-                    const sy = target.startY || target.y || 0;
-                    const ex = target.endX || sx + 100;
-                    const ey = target.endY || sy + 100;
-                    await this.client.moveMouse(sx, sy);
-                    await this.client.sendCommand("Input.dispatchMouseEvent", { type: "mousePressed", x: sx, y: sy, button: "left", clickCount: 1 });
-                    await this.client.moveMouse(ex, ey);
-                    await this.client.sendCommand("Input.dispatchMouseEvent", { type: "mouseReleased", x: ex, y: ey, button: "left", clickCount: 1 });
-                    break;
-            }
-            // Wait for condition with proper waiting mechanisms
-            if (waitFor) {
-                if (waitFor.type === "network_idle") {
-                    await this.client.waitForNetworkIdle(500, waitFor.timeout || 3000);
-                }
-                else if (waitFor.type === "element") {
-                    if (waitFor.selector) {
-                        await this.client.waitForSelector(waitFor.selector, waitFor.timeout || 5000);
-                    }
-                    else {
-                        await new Promise(r => setTimeout(r, waitFor.timeout || 3000));
-                    }
-                }
-                else if (waitFor.type === "navigation") {
-                    try {
-                        await this.client.waitForNavigation(waitFor.timeout || 10000);
-                    }
-                    catch {
-                        // Navigation might have already completed
-                    }
-                }
-            }
-            else {
-                // Default wait for stability
-                await new Promise(r => setTimeout(r, 500));
-            }
-            // Verify if requested
-            let verification = null;
-            if (verify) {
-                if (verify.type === "element_exists") {
-                    const res = await this.client.evaluate(`
-                        (function() {
-                            const el = document.querySelector(${JSON.stringify(verify.selector)});
-                            return { success: !!el, exists: !!el, message: el ? "Element exists" : "Element not found" };
-                        })()
-                    `);
-                    verification = res;
-                }
-                else if (verify.type === "element_contains_text") {
-                    const res = await this.client.evaluate(`
-                        (function() {
-                            const el = document.querySelector(${JSON.stringify(verify.selector)});
-                            if (!el) return { success: false, message: "Element not found" };
-                            const text = (el.innerText || el.textContent || "").trim();
-                            const matches = text.includes(${JSON.stringify(verify.expectedText || verify.text || "")});
-                            return { success: matches, text, message: matches ? "Verified" : "Text mismatch" };
-                        })()
-                    `);
-                    verification = res;
-                }
-                else if (verify.selector) {
-                    // Simple existence check
-                    const res = await this.client.evaluate(`
-                        (function() {
-                            return !!document.querySelector(${JSON.stringify(verify.selector)});
-                        })()
-                    `);
-                    verification = { success: !!res, selector: verify.selector };
-                }
-            }
-            // Get screenshot
-            const screenshot = params.screenshot === true ? await this.client.screenshot("jpeg", 70).catch(() => null) : null;
-            const url = await this.client.evaluate("window.location.href").catch(() => "Unknown");
-            const title = await this.client.evaluate("document.title").catch(() => "Unknown");
-            return {
-                success: true,
-                action: `${action} completed`,
-                verification,
-                screenshot,
-                url,
-                title
-            };
-        }
-        catch (e) {
-            return { success: false, error: e.message };
-        }
-    }
-    async smartNavigate(params) {
-        const { url, waitFor, dismissPopups, screenshot, timeout } = params;
-        const timeoutMs = timeout || 30000;
-        try {
-            await this.client.navigateAndWait(url, timeoutMs);
-            // Dismiss popups if requested
-            if (dismissPopups !== false) {
-                await this.client.evaluate(`
-                    (function() {
-                        // Try to find and click common close buttons
-                        const selectors = [
-                            '[aria-label*="close" i]', '[aria-label*="dismiss" i]',
-                            '.close', '.dismiss', '.modal-close',
-                            'button[class*="close"]', '[data-dismiss="modal"]'
-                        ];
-                        for (const sel of selectors) {
-                            const el = document.querySelector(sel);
-                            if (el && el.offsetParent !== null) {
-                                el.click();
-                                return true;
-                            }
-                        }
-                        return false;
-                    })()
-                `).catch(() => { });
-            }
-            // Wait for specific condition
-            if (waitFor) {
-                if (waitFor.type === "network_idle") {
-                    await this.client.waitForNetworkIdle(500, waitFor.timeout || 3000);
-                }
-                else if (waitFor.type === "element" && waitFor.selector) {
-                    await this.client.waitForSelector(waitFor.selector, waitFor.timeout || 5000);
-                }
-            }
-            const currentUrl = await this.client.evaluate("window.location.href").catch(() => url);
-            const title = await this.client.evaluate("document.title").catch(() => "Unknown");
-            const screenshotData = screenshot === true ? await this.client.screenshot("jpeg", 70).catch(() => null) : null;
-            return {
-                success: true,
-                url: currentUrl,
-                title,
-                screenshot: screenshotData
-            };
-        }
-        catch (e) {
-            return { success: false, error: e.message };
+        catch (e) {
+            return { success: false, error: e.message };
         }
     }
     async observeAndAct(params) {
         const { action, observe, returnScreenshot } = params;
         try {
             const [beforeFacts, beforeScreenshot] = await Promise.all([
-                this.captureActionFacts(action.selector),
+                Interaction.captureActionFacts(this.client, action?.selector),
                 returnScreenshot === true ? this.client.screenshot("jpeg", 70).catch(() => null) : Promise.resolve(null),
             ]);
             if (action.type === "click" && action.selector) {
                 await this.client.waitForSelector(action.selector, 5000, { visible: true, stable: true });
-                await this.clickElementBySelector({ selector: action.selector });
+                await Interaction.clickElementBySelector(this.client, this.locator, this.snapshotCache, { selector: action.selector }, this.logger);
             }
             else if (action.type === "type" && action.text) {
                 if (action.selector) {
-                    await this.fillBySelector({ selector: action.selector, value: action.text, timeout: 5000 });
+                    await Interaction.fillBySelector(this.client, this.locator, this.snapshotCache, { selector: action.selector, value: action.text, timeout: 5000 }, this.logger);
                 }
                 else {
                     await this.client.typeText(action.text);
@@ -1697,20 +656,19 @@ class CdpBridge {
                 await this.client.waitForNetworkIdle(500, 5000).catch(() => { });
             }
             else {
-                await new Promise(r => setTimeout(r, 300));
+                await new Promise((r) => setTimeout(r, 300));
             }
             const [afterFacts, afterScreenshot] = await Promise.all([
-                this.captureActionFacts(action.selector),
+                Interaction.captureActionFacts(this.client, action?.selector),
                 returnScreenshot === true ? this.client.screenshot("jpeg", 70).catch(() => null) : Promise.resolve(null),
             ]);
-            const facts = this.diffActionFacts(beforeFacts, afterFacts);
+            const facts = Interaction.diffActionFacts(beforeFacts, afterFacts);
             const changesDetected = facts.urlChanged || facts.titleChanged || facts.valueChanged || facts.checkedChanged || facts.selectedIndexChanged;
             return {
                 success: true,
                 before: { facts: beforeFacts, screenshot: beforeScreenshot },
                 after: { facts: afterFacts, screenshot: afterScreenshot },
-                changesDetected,
-                facts,
+                changesDetected, facts,
                 navigationOccurred: facts.urlChanged,
             };
         }
@@ -1718,18 +676,6 @@ class CdpBridge {
             return { success: false, error: e.message };
         }
     }
-    simpleDiff(before, after) {
-        // Simple Levenshtein distance for change detection
-        if (before === after)
-            return 0;
-        const len = Math.max(before.length, after.length);
-        let diff = 0;
-        for (let i = 0; i < len; i++) {
-            if (before[i] !== after[i])
-                diff++;
-        }
-        return diff;
-    }
     async agentFormFill(params) {
         const { fields, submitAfterFill, submitSelector } = params;
         const results = [];
@@ -1741,29 +687,29 @@ class CdpBridge {
                     continue;
                 }
                 if (["text", "email", "password", "textarea"].includes(field.type) || !field.type) {
-                    await this.fillBySelector({ selector, value: field.value ?? "", timeout: field.timeout || 5000 });
+                    await Interaction.fillBySelector(this.client, this.locator, this.snapshotCache, { selector, value: field.value ?? "", timeout: field.timeout || 5000 }, this.logger);
                 }
                 else if (field.type === "select") {
-                    await this.selectOption({ selector, value: field.value ?? "" });
+                    await Interaction.selectOption(this.client, this.locator, this.snapshotCache, { selector, value: field.value ?? "" }, this.logger);
                 }
                 else if (field.type === "checkbox" || field.type === "radio") {
                     if (field.checked === false) {
-                        await this.setChecked({ selector, checked: false });
+                        await Interaction.setChecked(this.client, this.locator, this.snapshotCache, { selector, checked: false }, this.logger);
                     }
                     else {
-                        await this.checkElement({ selector });
+                        await Interaction.checkElement(this.client, this.locator, this.snapshotCache, { selector }, this.logger);
                     }
                 }
                 else if (field.type === "file") {
                     await this.uploadFile({ selector, files: field.files || [] });
                 }
                 else {
-                    await this.fillBySelector({ selector, value: field.value ?? "", timeout: field.timeout || 5000 });
+                    await Interaction.fillBySelector(this.client, this.locator, this.snapshotCache, { selector, value: field.value ?? "", timeout: field.timeout || 5000 }, this.logger);
                 }
                 results.push({ field: field.id || field.selector, selector, success: true });
             }
             if (submitAfterFill && submitSelector) {
-                await this.clickElementBySelector({ selector: submitSelector });
+                await Interaction.clickElementBySelector(this.client, this.locator, this.snapshotCache, { selector: submitSelector }, this.logger);
             }
             return { success: true, fieldsFilled: results.length, results };
         }
@@ -1771,200 +717,129 @@ class CdpBridge {
             return { success: false, error: e.message, results };
         }
     }
-    async pageSnapshot(params) {
-        try {
-            const includeScreenshot = params.screenshot === true;
-            const includeCookies = params.cookies === true;
-            const includeAccessibilityTree = params.accessibilityTree === true;
-            const [title, url, screenshot, domSnapshot, elements, forms, cookies, axTree] = await Promise.all([
-                this.client.evaluate("document.title").catch(() => "Unknown"),
-                this.client.evaluate("window.location.href").catch(() => "Unknown"),
-                includeScreenshot ? this.client.screenshot(params.fullPage ? "jpeg" : "jpeg", 70).catch(() => null) : Promise.resolve(null),
-                params.includeDOMSnapshot ? this.client.getDOMSnapshot().catch(() => null) : Promise.resolve(undefined),
-                this.client.getInteractiveElements(false).catch(() => ({ elements: [] })),
-                this.client.evaluate(`
-                    (function() {
-                        const forms = Array.from(document.querySelectorAll('form'));
-                        return forms.map((form, idx) => {
-                            const inputs = Array.from(form.querySelectorAll('input, select, textarea'));
-                            return {
-                                id: 'form-' + idx,
-                                action: form.action,
-                                method: form.method,
-                                inputs: inputs.map(input => ({
-                                    type: input.type || 'text',
-                                    name: input.name || '',
-                                    id: input.id || '',
-                                    required: input.required,
-                                    placeholder: input.placeholder || ''
-                                }))
-                            };
-                        });
-                    })()
-                `).catch(() => ({ value: [] })),
-                includeCookies ? this.client.sendCommand("Network.getCookies", {}).catch(() => ({ cookies: [] })) : Promise.resolve({ cookies: [] }),
-                includeAccessibilityTree ? this.client.getSimplifiedAccessibilityTree().catch(() => []) : Promise.resolve([]),
-            ]);
-            return {
-                title,
-                url,
-                screenshot,
-                elements: elements.elements,
-                accessibilityTree: axTree,
-                forms: forms || [],
-                cookies: cookies.cookies || [],
-                domSnapshot: params.includeDOMSnapshot ? domSnapshot : undefined,
-                metadata: {
-                    timestamp: Date.now(),
-                    elementCount: elements.elements.length,
-                }
-            };
-        }
-        catch (e) {
-            return { success: false, error: e.message };
-        }
-    }
-    // ==================== SELF-HEALING SELECTOR RESOLUTION ====================
-    async resolveSelector(params) {
-        const { originalSelector, text, fuzzyMatch } = params;
-        // Try original selector first
-        if (originalSelector) {
-            const exists = await this.client.evaluate(`
-                !!document.querySelector(${JSON.stringify(originalSelector)})
-            `);
-            if (exists) {
-                return { selector: originalSelector, method: "exact", confidence: 1.0 };
+    // ─── Configuration ────────────────────────────────────────────────
+    async configureBrowser(params) {
+        const { network, emulation, script } = params;
+        const results = [];
+        if (network) {
+            if (network.blockImages) {
+                await this.client.sendCommand("Network.setBlockedURLs", {
+                    urls: ["*.jpg", "*.jpeg", "*.png", "*.gif", "*.webp", "*.svg"],
+                });
+                results.push("Blocked images");
+            }
+            if (network.blockCSS) {
+                await this.client.sendCommand("Network.setBlockedURLs", { urls: ["*.css"] });
+                results.push("Blocked CSS");
+            }
+            if (network.blockAds) {
+                await this.client.sendCommand("Network.setBlockedURLs", {
+                    urls: ["*doubleclick.net*", "*googlesyndication.com*", "*adservice.*"],
+                });
+                results.push("Blocked ads");
             }
         }
-        const resolved = await this.locator.resolve({
-            target: text,
-            timeout: params.timeout || 1500,
-            includeCandidates: false,
-        }).catch(() => null);
-        if (resolved?.success && (resolved.selector || resolved.ref)) {
-            return {
-                selector: resolved.candidate?.scope === "document" && resolved.candidate.framePath.length === 0 && resolved.candidate.shadowDepth === 0
-                    ? resolved.selector || ""
-                    : resolved.ref || "",
-                method: resolved.matchedBy || "locator",
-                confidence: resolved.confidence || 0.7,
-            };
-        }
-        // Try fuzzy text matching if enabled
-        if (fuzzyMatch !== false && text) {
-            const result = await this.client.evaluate(`
-                (function() {
-                    const searchText = ${JSON.stringify(text)};
-                    const searchLower = String(searchText || '').trim().toLowerCase();
-                    const elements = Array.from(document.querySelectorAll('a[href], button, input:not([type="hidden"]), select, textarea, [role="button"], [role="link"], [onclick]')).filter((el) => {
-                        const rect = el.getBoundingClientRect();
-                        const computed = window.getComputedStyle(el);
-                        return computed.display !== 'none' && computed.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
-                    });
-
-                    function cssPath(el) {
-                        if (el.id) return '#' + CSS.escape(el.id);
-                        const path = [];
-                        while (el && el.nodeType === Node.ELEMENT_NODE && el !== document.body) {
-                            let selector = el.nodeName.toLowerCase();
-                            if (el.classList && el.classList.length) {
-                                selector += '.' + Array.from(el.classList).slice(0, 2).map(c => CSS.escape(c)).join('.');
-                            }
-                            const parent = el.parentElement;
-                            if (parent) {
-                                const siblings = Array.from(parent.children).filter(child => child.nodeName === el.nodeName);
-                                if (siblings.length > 1) selector += ':nth-of-type(' + (siblings.indexOf(el) + 1) + ')';
-                            }
-                            path.unshift(selector);
-                            el = parent;
-                        }
-                        return path.length ? path.join(' > ') : '';
-                    }
-
-                    function textFor(el) {
-                        return String(
-                            el.innerText ||
-                            el.textContent ||
-                            el.getAttribute('aria-label') ||
-                            el.getAttribute('placeholder') ||
-                            el.getAttribute('name') ||
-                            ''
-                        ).trim();
-                    }
-                    
-                    // Exact match first
-                    let best = elements.find(el => textFor(el).toLowerCase() === searchLower);
-                    if (best) return { selector: cssPath(best), confidence: 1.0 };
-                    
-                    // Partial match
-                    best = elements.find(el => {
-                        const value = textFor(el).toLowerCase();
-                        return searchLower.length >= 3 && value.includes(searchLower);
-                    });
-                    if (best) return { selector: cssPath(best), confidence: 0.8 };
-                    
-                    // Fuzzy match (Levenshtein distance)
-                    let minDist = Infinity;
-                    let bestEl = null;
-                    elements.forEach(el => {
-                        const elText = textFor(el);
-                        if (!elText || Math.abs(elText.length - searchText.length) > 8) return;
-                        const dist = levenshteinDistance(searchText, elText);
-                        if (dist < minDist && dist <= 3) {
-                            minDist = dist;
-                            bestEl = el;
-                        }
-                    });
-                    
-                    if (bestEl) return { selector: cssPath(bestEl), confidence: 0.6 };
-                    
-                    return null;
-                    
-                    function levenshteinDistance(a, b) {
-                        if (a.length === 0) return b.length;
-                        if (b.length === 0) return a.length;
-                        const matrix = [];
-                        for (let i = 0; i <= b.length; i++) matrix[i] = [i];
-                        for (let j = 0; j <= a.length; j++) matrix[0][j] = j;
-                        for (let i = 1; i <= b.length; i++) {
-                            for (let j = 1; j <= a.length; j++) {
-                                matrix[i][j] = b.charAt(i-1) === a.charAt(j-1) ? matrix[i-1][j-1] : 
-                                    Math.min(matrix[i-1][j-1] + 1, matrix[i][j-1] + 1, matrix[i-1][j] + 1);
-                            }
-                        }
-                        return matrix[b.length][a.length];
-                    }
-                })()
-            `);
-            if (result) {
-                return { selector: result.selector, method: "fuzzy", confidence: result.confidence };
+        if (emulation) {
+            if (emulation.width && emulation.height) {
+                await this.client.sendCommand("Emulation.setDeviceMetricsOverride", {
+                    width: emulation.width, height: emulation.height,
+                    deviceScaleFactor: emulation.scale || 1, mobile: emulation.mobile || false,
+                });
+                results.push(`Emulated device: ${emulation.width}x${emulation.height}`);
+            }
+            if (emulation.userAgent) {
+                await this.client.sendCommand("Emulation.setUserAgentOverride", { userAgent: emulation.userAgent });
+                results.push("Set custom user agent");
             }
         }
-        throw new Error(`Could not resolve selector. Original: ${originalSelector}, Text: ${text}`);
+        if (script?.onLoad) {
+            await this.client.sendCommand("Page.addScriptToEvaluateOnNewDocument", { source: script.onLoad });
+            results.push("Added script to run on new documents");
+        }
+        return { success: true, configured: results, message: results.join(", ") || "No configuration applied" };
     }
-    async getTabs(params) {
-        const result = await this.client.sendCommand("Target.getTargets", {});
-        return result.targetInfos || [];
+    async emulateNetworkConditions(params) {
+        await this.client.sendCommand("Network.emulateNetworkConditions", {
+            offline: params.offline || false,
+            latency: params.latency || 0,
+            downloadThroughput: params.downloadThroughput || 0,
+            uploadThroughput: params.uploadThroughput || 0,
+        });
+        return "Network conditions emulated";
     }
-    async newTab(params) {
-        const result = await this.client.sendCommand("Target.createTarget", {
-            url: params.url || "about:blank",
+    async setGeolocation(params) {
+        await this.client.sendCommand("Emulation.setGeolocationOverride", {
+            latitude: params.latitude, longitude: params.longitude, accuracy: params.accuracy || 100,
         });
-        return result.targetId ? `Created new tab: ${result.targetId}` : "Created new tab";
+        return `Geolocation set to ${params.latitude}, ${params.longitude}`;
     }
-    async switchTab(params) {
-        if (!params.targetId)
-            throw new Error("targetId required to switch tabs");
-        await this.client.sendCommand("Target.activateTarget", { targetId: params.targetId });
-        await this.client.switchToTarget(params.targetId, params.port || 9222);
-        return `Switched to tab ${params.targetId}`;
+    async setTimezone(params) {
+        await this.client.sendCommand("Emulation.setTimezoneOverride", { timezoneId: params.timezoneId });
+        return `Timezone set to ${params.timezoneId}`;
     }
-    async closeTab(params) {
-        await this.client.sendCommand("Target.closeTarget", {
-            targetId: params.targetId,
+    async printPDF(params) {
+        const result = await this.client.sendCommand("Page.printToPDF", {
+            landscape: params.landscape || false,
+            printBackground: params.printBackground || false,
+            ...params.options,
+        });
+        return result.data;
+    }
+    async uploadFile(params) {
+        const selector = params.selector;
+        const files = params.files || [];
+        if (!selector)
+            throw new Error("Selector required for upload_file");
+        if (!files.length)
+            throw new Error("No files specified");
+        const result = await this.client.evaluate(`(function(){var el=document.querySelector(${JSON.stringify(selector)});if(!el)return {success:false,error:"Element not found"};if(el.type!=='file')return {success:false,error:"Element is not a file input"};el.style.display='block';el.click();return {success:true};})()`);
+        if (!result?.success)
+            throw new Error(result?.error || "Failed to activate file input");
+        const docResult = await this.client.sendCommand("DOM.getDocument", {});
+        const queryResult = await this.client.sendCommand("DOM.querySelector", {
+            nodeId: docResult.root.nodeId, selector,
+        });
+        if (!queryResult.nodeId)
+            throw new Error(`File input not found: ${selector}`);
+        await this.client.sendCommand("DOM.setFileInputFiles", { files, nodeId: queryResult.nodeId });
+        return "File upload completed";
+    }
+    // ─── Network Mocking ──────────────────────────────────────────────
+    async mockNetworkRequest(params) {
+        const urlPattern = params.urlPattern;
+        const mockResponse = params.mockResponse;
+        if (!urlPattern)
+            throw new Error("urlPattern required");
+        this.mockRoutes.push({ pattern: urlPattern, response: mockResponse || "{}" });
+        await this.client.sendCommand("Fetch.enable", {
+            patterns: this.mockRoutes.map((route) => ({ urlPattern: route.pattern })),
         });
-        return "Closed tab";
+        if (!this.mockRouteListener) {
+            this.mockRouteListener = async (event) => {
+                const route = this.mockRoutes.find((item) => this.matchesUrlPattern(event.request.url, item.pattern));
+                if (!route) {
+                    await this.client.sendCommand("Fetch.continueRequest", { requestId: event.requestId }).catch(() => { });
+                    return;
+                }
+                await this.client.sendCommand("Fetch.fulfillRequest", {
+                    requestId: event.requestId,
+                    responseCode: 200,
+                    responseHeaders: [
+                        { name: "Content-Type", value: "application/json" },
+                        { name: "Access-Control-Allow-Origin", value: "*" },
+                    ],
+                    body: Buffer.from(route.response).toString("base64"),
+                }).catch(() => { });
+            };
+            this.client.on("Fetch.requestPaused", this.mockRouteListener);
+        }
+        return `Mocking enabled for pattern: ${urlPattern}`;
     }
+    matchesUrlPattern(url, pattern) {
+        const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+        return new RegExp(`^${escaped}$`).test(url);
+    }
+    // ─── Screencast ───────────────────────────────────────────────────
     async startScreencast(params) {
         this.screencastFrames = [];
         if (!this.screencastFrameListener) {
@@ -1984,7 +859,7 @@ class CdpBridge {
         await this.client.sendCommand("Page.startScreencast", {
             format: params.format || "jpeg",
             quality: params.quality || 80,
-            everyNthFrame: params.everyNthFrame || 1
+            everyNthFrame: params.everyNthFrame || 1,
         });
         return "Started screencast";
     }
@@ -2008,14 +883,10 @@ class CdpBridge {
         };
         this.client.on("Page.screencastFrame", onFrame);
         await this.startScreencast(params);
-        await new Promise(r => setTimeout(r, duration));
+        await new Promise((r) => setTimeout(r, duration));
         await this.stopScreencast(params);
         this.client.removeEventListener("Page.screencastFrame", onFrame);
-        return {
-            frames,
-            frameCount: frames.length,
-            duration
-        };
+        return { frames, frameCount: frames.length, duration };
     }
     async sampleVisualFrames(params) {
         const duration = Math.max(250, Math.min(Number(params.duration ?? 1500), 10000));
@@ -2035,550 +906,25 @@ class CdpBridge {
             quality: Math.max(20, Math.min(Number(params.quality ?? 45), 80)),
             maxWidth: Math.max(320, Math.min(Number(params.maxWidth ?? 800), 1280)),
             maxHeight: Math.max(240, Math.min(Number(params.maxHeight ?? 600), 900)),
-            everyNthFrame: Math.max(1, Math.min(Number(params.everyNthFrame ?? 3), 10))
+            everyNthFrame: Math.max(1, Math.min(Number(params.everyNthFrame ?? 3), 10)),
         });
         try {
-            await new Promise(r => setTimeout(r, duration));
+            await new Promise((r) => setTimeout(r, duration));
         }
         finally {
             await this.client.sendCommand("Page.stopScreencast", {}).catch(() => { });
             this.client.removeEventListener("Page.screencastFrame", onFrame);
         }
-        return {
-            success: true,
-            frameCount: frames.length,
-            duration,
-            format: params.format || "jpeg",
-            timestamps,
-            frames
-        };
-    }
-    async startTracing(params) {
-        await this.client.sendCommand("Tracing.start", { categories: params.categories || "devtools.timeline" });
-        return "Started tracing";
-    }
-    async stopTracing(params) {
-        await this.client.sendCommand("Tracing.end", {});
-        return "Stopped tracing";
-    }
-    async getPerformanceMetrics(params) {
-        await this.client.sendCommand("Performance.enable", {});
-        const result = await this.client.sendCommand("Performance.getMetrics", {});
-        return result.metrics;
-    }
-    async hover(params) {
-        const x = params.x || (params.coordinate ? Number(params.coordinate.split(',')[0]) : 100);
-        const y = params.y || (params.coordinate ? Number(params.coordinate.split(',')[1]) : 100);
-        await this.client.moveMouse(x, y);
-        return "Hovered";
-    }
-    async dragAndDrop(params) {
-        const startX = params.startX || 0;
-        const startY = params.startY || 0;
-        const endX = params.endX || 0;
-        const endY = params.endY || 0;
-        await this.client.moveMouse(startX, startY);
-        await this.client.sendCommand("Input.dispatchMouseEvent", { type: "mousePressed", x: startX, y: startY, button: "left", clickCount: 1 });
-        await this.client.moveMouse(endX, endY);
-        await this.client.sendCommand("Input.dispatchMouseEvent", { type: "mouseReleased", x: endX, y: endY, button: "left", clickCount: 1 });
-        return "Dragged and dropped";
-    }
-    // ==================== MISSING ACT TOOL ACTION IMPLEMENTATIONS ====================
-    async fillInput(params) {
-        const selector = params.selector;
-        const text = params.value || params.text || "";
-        if (selector) {
-            // Wait for element and clear it first
-            await this.client.waitForSelector(selector);
-            await this.client.moveMouseToSelector(selector).catch(() => { });
-            await this.client.evaluate(`
-                (function() {
-                    const el = document.querySelector(${JSON.stringify(selector)});
-                    if (el) {
-                        el.value = '';
-                        el.focus();
-                        return true;
-                    }
-                    return false;
-                })()
-            `);
-        }
-        await this.client.typeText(text);
-        return `Filled with: ${text}`;
-    }
-    async selectOption(params) {
-        const selector = params.selector;
-        const value = params.value || "";
-        if (!selector)
-            throw new Error("Selector required for select action");
-        await this.client.waitForSelector(selector);
-        const selectInfo = await this.client.evaluate(`
-            (function() {
-                const select = document.querySelector(${JSON.stringify(selector)});
-                if (!select) return { success: false, error: "Element not found" };
-                if (select.tagName.toLowerCase() !== 'select') return { success: false, error: "Element is not a select" };
-                if (select.disabled) return { success: false, error: "Element is disabled" };
-                const wanted = ${JSON.stringify(value)};
-                const options = Array.from(select.options || []);
-                const index = options.findIndex((option) =>
-                    option.value === wanted ||
-                    option.text === wanted ||
-                    option.label === wanted
-                );
-                return {
-                    success: true,
-                    selectedValue: select.value,
-                    index,
-                    optionCount: options.length,
-                    wantedValue: index >= 0 ? options[index].value : wanted,
-                };
-            })()
-        `);
-        if (!selectInfo?.success)
-            throw new Error(selectInfo?.error || "Failed to inspect select");
-        if (selectInfo.selectedValue === selectInfo.wantedValue) {
-            return `Selected option: ${value}`;
-        }
-        if (selectInfo.index >= 0 && selectInfo.index <= 40) {
-            try {
-                await this.clickElementBySelector({ selector });
-                await this.client.pressKey("Home");
-                for (let i = 0; i < selectInfo.index; i++) {
-                    await this.client.pressKey("ArrowDown");
-                }
-                await this.client.pressKey("Enter");
-                const verified = await this.client.evaluate(`
-                    (function() {
-                        const select = document.querySelector(${JSON.stringify(selector)});
-                        return select ? select.value : null;
-                    })()
-                `);
-                if (verified === selectInfo.wantedValue) {
-                    return `Selected option: ${value}`;
-                }
-            }
-            catch {
-                // Fall back to direct value setting below for reliability.
-            }
-        }
-        const result = await this.client.evaluate(`
-            (function() {
-                const select = document.querySelector(${JSON.stringify(selector)});
-                if (!select) return { success: false, error: "Element not found" };
-                select.value = ${JSON.stringify(selectInfo.wantedValue)};
-                select.dispatchEvent(new Event('input', { bubbles: true }));
-                select.dispatchEvent(new Event('change', { bubbles: true }));
-                return { success: true, selectedValue: select.value };
-            })()
-        `);
-        if (result?.success)
-            return `Selected option: ${value}`;
-        throw new Error(result?.error || "Failed to select option");
-    }
-    async checkElement(params) {
-        const selector = params.selector;
-        if (!selector)
-            throw new Error("Selector required for check action");
-        return this.setChecked({ selector, checked: true });
-    }
-    async setChecked(params) {
-        const selector = params.selector;
-        if (!selector)
-            throw new Error("Selector required for checked state");
-        await this.client.waitForSelector(selector);
-        const before = await this.client.evaluate(`
-            (function() {
-                const el = document.querySelector(${JSON.stringify(selector)});
-                if (!el) return { success: false, error: "Element not found" };
-                if (el.type !== 'checkbox' && el.type !== 'radio') return { success: false, error: "Element is not a checkbox or radio" };
-                if (el.disabled) return { success: false, error: "Element is disabled" };
-                return { success: true, checked: !!el.checked, type: el.type };
-            })()
-        `);
-        if (!before?.success)
-            throw new Error(before?.error || "Failed to inspect checked state");
-        const wanted = !!params.checked;
-        if (before.checked === wanted)
-            return `Checked state set to ${wanted}`;
-        if (!(before.type === "radio" && !wanted)) {
-            try {
-                await this.clickElementBySelector({ selector });
-                const afterClick = await this.client.evaluate(`
-                    (function() {
-                        const el = document.querySelector(${JSON.stringify(selector)});
-                        return el ? !!el.checked : null;
-                    })()
-                `);
-                if (afterClick === wanted)
-                    return `Checked state set to ${wanted}`;
-            }
-            catch {
-                // Fall back to direct state setting below for reliability.
-            }
-        }
-        const result = await this.client.evaluate(`
-            (function() {
-                const el = document.querySelector(${JSON.stringify(selector)});
-                if (!el) return { success: false, error: "Element not found" };
-                if (el.type !== 'checkbox' && el.type !== 'radio') return { success: false, error: "Element is not a checkbox or radio" };
-                el.checked = ${JSON.stringify(!!params.checked)};
-                el.dispatchEvent(new Event('input', { bubbles: true }));
-                el.dispatchEvent(new Event('change', { bubbles: true }));
-                return { success: true, checked: el.checked };
-            })()
-        `);
-        if (result?.success)
-            return `Checked state set to ${!!params.checked}`;
-        throw new Error(result?.error || "Failed to set checked state");
+        return { success: true, frameCount: frames.length, duration, format: params.format || "jpeg", timestamps, frames };
     }
-    async getAccessibilityTree(params) {
-        return await this.client.getSimplifiedAccessibilityTree();
-    }
-    async getDOMTree(params) {
-        const result = await this.client.getDOMSnapshot();
-        return result;
-    }
-    async assertCondition(params) {
-        const assertionType = params.assertionType || "element_exists";
-        const selector = params.selector;
-        const expectedText = params.expectedText || params.value || "";
-        const result = await this.client.evaluate(`
-            (function() {
-                const selector = ${JSON.stringify(selector)};
-                const type = ${JSON.stringify(assertionType)};
-                const expectedText = ${JSON.stringify(expectedText)};
-                
-                const el = selector ? document.querySelector(selector) : null;
-                
-                switch(type) {
-                    case 'element_exists':
-                        return { success: !!el, message: el ? 'Element exists' : 'Element not found' };
-                    case 'element_not_exists':
-                        return { success: !el, message: !el ? 'Element does not exist' : 'Element found' };
-                    case 'element_contains_text':
-                        if (!el) return { success: false, message: 'Element not found' };
-                        const text = (el.innerText || el.textContent || '').trim();
-                        const matches = text.includes(expectedText);
-                        return { success: matches, message: matches ? 'Text matches' : 'Text does not match', actualText: text };
-                    case 'url_contains':
-                        const urlMatches = window.location.href.includes(expectedText);
-                        return { success: urlMatches, message: urlMatches ? 'URL contains text' : 'URL does not contain text' };
-                    default:
-                        return { success: false, message: 'Unknown assertion type' };
-                }
-            })()
-        `);
-        return result || { success: false, message: "Assertion failed" };
-    }
-    async getCookies(params) {
-        const result = await this.client.sendCommand("Network.getCookies", {
-            urls: [await this.client.evaluate("window.location.href").catch(() => "*") || "*"],
-        });
-        return result.cookies || [];
-    }
-    async setCookie(params) {
-        const cookies = [{
-                name: params.cookieName || params.name,
-                value: params.cookieValue || params.value,
-                url: params.url || await this.client.evaluate("window.location.href").catch(() => undefined),
-                domain: params.domain,
-                path: params.path || "/",
-                secure: params.secure || false,
-                httpOnly: params.httpOnly || false,
-            }];
-        await this.client.sendCommand("Network.setCookies", { cookies });
-        return "Cookie set";
-    }
-    async clearCache(params) {
-        await this.client.sendCommand("Network.clearBrowserCache", {});
-        await this.client.sendCommand("Network.clearBrowserCookies", {});
-        return "Cache cleared";
-    }
-    async setGeolocation(params) {
-        await this.client.sendCommand("Emulation.setGeolocationOverride", {
-            latitude: params.latitude,
-            longitude: params.longitude,
-            accuracy: params.accuracy || 100,
-        });
-        return `Geolocation set to ${params.latitude}, ${params.longitude}`;
-    }
-    async setTimezone(params) {
-        await this.client.sendCommand("Emulation.setTimezoneOverride", {
-            timezoneId: params.timezoneId,
-        });
-        return `Timezone set to ${params.timezoneId}`;
-    }
-    async emulateNetworkConditions(params) {
-        await this.client.sendCommand("Network.emulateNetworkConditions", {
-            offline: params.offline || false,
-            latency: params.latency || 0,
-            downloadThroughput: params.downloadThroughput || 0,
-            uploadThroughput: params.uploadThroughput || 0,
-        });
-        return "Network conditions emulated";
-    }
-    async printPDF(params) {
-        const result = await this.client.sendCommand("Page.printToPDF", {
-            landscape: params.landscape || false,
-            printBackground: params.printBackground || false,
-            ...params.options,
-        });
-        return result.data; // base64 PDF
-    }
-    async highlightElements(params) {
-        const result = await this.client.getInteractiveElements(true);
-        return {
-            success: true,
-            elements: result.elements,
-            message: `Highlighted ${result.elements.length} elements`,
-        };
-    }
-    async verifyUIState(params) {
-        const selector = params.selector;
-        const expectedText = params.expectedText || params.value || "";
-        const result = await this.client.evaluate(`
-            (function() {
-                const el = document.querySelector(${JSON.stringify(selector)});
-                if (!el) return { exists: false, visible: false };
-                
-                const rect = el.getBoundingClientRect();
-                const computed = window.getComputedStyle(el);
-                const visible = rect.width > 0 && rect.height > 0 && 
-                              computed.display !== 'none' && 
-                              computed.visibility !== 'hidden' &&
-                              computed.opacity !== '0';
-                
-                return {
-                    exists: true,
-                    visible,
-                    text: (el.innerText || el.textContent || '').trim().substring(0, 200),
-                    bounds: { x: rect.left, y: rect.top, width: rect.width, height: rect.height }
-                };
-            })()
-        `);
-        return result || { exists: false, visible: false };
-    }
-    async getDOMStorage(params) {
-        await this.client.sendCommand("DOMStorage.enable", {});
-        const origin = params.origin || await this.client.evaluate("window.location.origin").catch(() => "");
-        const result = await this.client.sendCommand("DOMStorage.getDOMStorageItems", {
-            storageId: { securityOrigin: origin, isLocalStorage: params.type !== 'session' },
-        });
-        return result.entries || [];
-    }
-    async getNetworkTraffic(params) {
-        return await this.client.getNetworkTraffic();
-    }
-    async getNetworkResponse(params) {
-        const requestId = params.requestId;
-        if (!requestId)
-            throw new Error("requestId required");
-        const result = await this.client.sendCommand("Network.getResponseBody", { requestId });
-        return result;
-    }
-    async mockNetworkRequest(params) {
-        const urlPattern = params.urlPattern;
-        const mockResponse = params.mockResponse;
-        if (!urlPattern)
-            throw new Error("urlPattern required");
-        this.mockRoutes.push({
-            pattern: urlPattern,
-            response: mockResponse || "{}"
-        });
-        await this.client.sendCommand("Fetch.enable", {
-            patterns: this.mockRoutes.map(route => ({ urlPattern: route.pattern }))
-        });
-        if (!this.mockRouteListener) {
-            this.mockRouteListener = async (event) => {
-                const route = this.mockRoutes.find(item => this.matchesUrlPattern(event.request.url, item.pattern));
-                if (!route) {
-                    await this.client.sendCommand("Fetch.continueRequest", { requestId: event.requestId }).catch(() => { });
-                    return;
-                }
-                await this.client.sendCommand("Fetch.fulfillRequest", {
-                    requestId: event.requestId,
-                    responseCode: 200,
-                    responseHeaders: [
-                        { name: "Content-Type", value: "application/json" },
-                        { name: "Access-Control-Allow-Origin", value: "*" }
-                    ],
-                    body: Buffer.from(route.response).toString("base64")
-                }).catch(() => { });
-            };
-            this.client.on("Fetch.requestPaused", this.mockRouteListener);
-        }
-        return `Mocking enabled for pattern: ${urlPattern}`;
-    }
-    matchesUrlPattern(url, pattern) {
-        const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-        return new RegExp(`^${escaped}$`).test(url);
-    }
-    async getComputedStyle(params) {
-        const selector = params.selector;
-        const property = params.property;
-        if (!selector)
-            throw new Error("Selector required");
-        const result = await this.client.evaluate(`
-            (function() {
-                const el = document.querySelector(${JSON.stringify(selector)});
-                if (!el) return null;
-                const style = window.getComputedStyle(el);
-                ${property ? `return style.getPropertyValue(${JSON.stringify(property)});` : `return JSON.parse(JSON.stringify(style));`}
-            })()
-        `);
-        return result;
-    }
-    async getEventListeners(params) {
-        const selector = params.selector;
-        if (!selector)
-            throw new Error("Selector required");
-        const result = await this.client.evaluate(`
-            (function() {
-                const el = document.querySelector(${JSON.stringify(selector)});
-                if (!el) return null;
-                // getEventListeners is Chrome DevTools specific, not available in page context
-                return { message: "getEventListeners requires DevTools protocol, not available in page context" };
-            })()
-        `);
-        return result;
-    }
-    screencastFrames = [];
-    screencastFrameListener = null;
-    mockRoutes = [];
-    mockRouteListener = null;
     async getScreencastFrames(params) {
         const maxFrames = params.maxFrames || this.screencastFrames.length;
         const frames = this.screencastFrames.slice(-maxFrames);
-        return {
-            frameCount: frames.length,
-            frames,
-            message: `Retrieved ${frames.length} frames`
-        };
-    }
-    async uploadFile(params) {
-        const selector = params.selector;
-        const files = params.files || [];
-        if (!selector)
-            throw new Error("Selector required for upload_file action");
-        if (!files.length)
-            throw new Error("No files specified");
-        // Click the file input to activate it
-        const result = await this.client.evaluate(`
-            (function() {
-                const el = document.querySelector(${JSON.stringify(selector)});
-                if (!el) return { success: false, error: "Element not found" };
-                if (el.type !== 'file') return { success: false, error: "Element is not a file input" };
-                el.style.display = 'block'; // Make sure it's visible
-                el.click();
-                return { success: true };
-            })()
-        `);
-        if (!result?.success) {
-            throw new Error(result?.error || "Failed to activate file input");
-        }
-        const documentResult = await this.client.sendCommand("DOM.getDocument", {});
-        const queryResult = await this.client.sendCommand("DOM.querySelector", {
-            nodeId: documentResult.root.nodeId,
-            selector
-        });
-        if (!queryResult.nodeId) {
-            throw new Error(`File input not found: ${selector}`);
-        }
-        await this.client.sendCommand("DOM.setFileInputFiles", {
-            files,
-            nodeId: queryResult.nodeId
-        });
-        return "File upload completed";
-    }
-    async configureBrowser(params) {
-        const { network, emulation, script } = params;
-        const results = [];
-        // Configure network settings
-        if (network) {
-            if (network.blockImages) {
-                await this.client.sendCommand("Network.setBlockedURLs", {
-                    urls: ["*.jpg", "*.jpeg", "*.png", "*.gif", "*.webp", "*.svg"]
-                });
-                results.push("Blocked images");
-            }
-            if (network.blockCSS) {
-                await this.client.sendCommand("Network.setBlockedURLs", {
-                    urls: ["*.css"]
-                });
-                results.push("Blocked CSS");
-            }
-            if (network.blockAds) {
-                await this.client.sendCommand("Network.setBlockedURLs", {
-                    urls: ["*doubleclick.net*", "*googlesyndication.com*", "*adservice.*"]
-                });
-                results.push("Blocked ads");
-            }
-        }
-        // Configure emulation settings
-        if (emulation) {
-            if (emulation.width && emulation.height) {
-                await this.client.sendCommand("Emulation.setDeviceMetricsOverride", {
-                    width: emulation.width,
-                    height: emulation.height,
-                    deviceScaleFactor: emulation.scale || 1,
-                    mobile: emulation.mobile || false,
-                });
-                results.push(`Emulated device: ${emulation.width}x${emulation.height}`);
-            }
-            if (emulation.userAgent) {
-                await this.client.sendCommand("Emulation.setUserAgentOverride", {
-                    userAgent: emulation.userAgent,
-                });
-                results.push("Set custom user agent");
-            }
-        }
-        // Configure scripts
-        if (script?.onLoad) {
-            await this.client.sendCommand("Page.addScriptToEvaluateOnNewDocument", {
-                source: script.onLoad,
-            });
-            results.push("Added script to run on new documents");
-        }
-        return {
-            success: true,
-            configured: results,
-            message: results.join(", ") || "No configuration applied"
-        };
-    }
-    async launchBrowser(options) {
-        const client = (0, cdp_client_1.getCdpClient)();
-        await client.launchAuto({
-            browser: options?.browser,
-            headless: options?.headless,
-            port: options?.port,
-            profile: options?.profile,
-            profileDirectory: options?.profileDirectory,
-            userDataDir: options?.userDataDir,
-        });
-        const profileLabel = options?.profile || options?.profileDirectory;
-        return profileLabel
-            ? `Browser launched successfully with profile "${profileLabel}"`
-            : "Browser launched successfully";
-    }
-    async killBrowser() {
-        const client = (0, cdp_client_1.getCdpClient)();
-        await client.killBrowser();
-        return "Browser killed";
-    }
-    async listBrowsers() {
-        const client = (0, cdp_client_1.getCdpClient)();
-        return await client.listAvailableBrowsers();
-    }
-    async listBrowserProfiles(browser) {
-        const client = (0, cdp_client_1.getCdpClient)();
-        return await client.listBrowserProfiles(browser || "brave");
-    }
-    async getTargetsViaHttp() {
-        // This is a simplified version - in reality we'd need to know the port
-        return [];
+        return { frameCount: frames.length, frames, message: `Retrieved ${frames.length} frames` };
     }
 }
 exports.CdpBridge = CdpBridge;
+// Singleton
 let bridgeInstance = null;
 function getCdpBridge() {
     if (!bridgeInstance) {