spider-browser 0.1.0

package/dist/index.js

@@ -0,0 +1,3609 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// utils/errors.ts
+var SpiderError, ConnectionError, AuthError, RateLimitError, BlockedError, BackendUnavailableError, TimeoutError, ProtocolError, NavigationError, LLMError;
+var init_errors = __esm({
+  "utils/errors.ts"() {
+    "use strict";
+    SpiderError = class extends Error {
+      constructor(message, code, retryable = false) {
+        super(message);
+        this.code = code;
+        this.retryable = retryable;
+        this.name = "SpiderError";
+      }
+    };
+    ConnectionError = class extends SpiderError {
+      constructor(message, wsCode) {
+        super(message, "CONNECTION_ERROR", true);
+        this.wsCode = wsCode;
+        this.name = "ConnectionError";
+      }
+    };
+    AuthError = class extends SpiderError {
+      constructor(message) {
+        super(message, "AUTH_ERROR", false);
+        this.name = "AuthError";
+      }
+    };
+    RateLimitError = class extends SpiderError {
+      constructor(message, retryAfterMs) {
+        super(message, "RATE_LIMIT", true);
+        this.retryAfterMs = retryAfterMs;
+        this.name = "RateLimitError";
+      }
+    };
+    BlockedError = class extends SpiderError {
+      constructor(message) {
+        super(message, "BLOCKED", true);
+        this.name = "BlockedError";
+      }
+    };
+    BackendUnavailableError = class extends SpiderError {
+      constructor(message) {
+        super(message, "BACKEND_UNAVAILABLE", true);
+        this.name = "BackendUnavailableError";
+      }
+    };
+    TimeoutError = class extends SpiderError {
+      constructor(message) {
+        super(message, "TIMEOUT", true);
+        this.name = "TimeoutError";
+      }
+    };
+    ProtocolError = class extends SpiderError {
+      constructor(message) {
+        super(message, "PROTOCOL_ERROR", false);
+        this.name = "ProtocolError";
+      }
+    };
+    NavigationError = class extends SpiderError {
+      constructor(message) {
+        super(message, "NAVIGATION_ERROR", true);
+        this.name = "NavigationError";
+      }
+    };
+    LLMError = class extends SpiderError {
+      constructor(message) {
+        super(message, "LLM_ERROR", true);
+        this.name = "LLMError";
+      }
+    };
+  }
+});
+
+// ai/providers/openai.ts
+var openai_exports = {};
+__export(openai_exports, {
+  OpenAICompatibleProvider: () => OpenAICompatibleProvider
+});
+var DEFAULT_URLS, OpenAICompatibleProvider;
+var init_openai = __esm({
+  "ai/providers/openai.ts"() {
+    "use strict";
+    init_errors();
+    DEFAULT_URLS = {
+      openai: "https://api.openai.com/v1/chat/completions",
+      openrouter: "https://openrouter.ai/api/v1/chat/completions"
+    };
+    OpenAICompatibleProvider = class {
+      url;
+      apiKey;
+      model;
+      maxTokens;
+      temperature;
+      constructor(config) {
+        this.url = config.baseUrl ?? DEFAULT_URLS[config.provider] ?? DEFAULT_URLS.openai;
+        this.apiKey = config.apiKey;
+        this.model = config.model;
+        this.maxTokens = config.maxTokens ?? 4096;
+        this.temperature = config.temperature ?? 0.1;
+      }
+      async chat(messages, options) {
+        const body = {
+          model: this.model,
+          messages,
+          max_tokens: this.maxTokens,
+          temperature: this.temperature
+        };
+        if (options?.jsonMode) {
+          body.response_format = { type: "json_object" };
+        }
+        const resp = await fetch(this.url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`
+          },
+          body: JSON.stringify(body)
+        });
+        if (!resp.ok) {
+          const text = await resp.text().catch(() => "");
+          throw new LLMError(`OpenAI API error ${resp.status}: ${text}`);
+        }
+        const json = await resp.json();
+        const content = json?.choices?.[0]?.message?.content;
+        if (typeof content !== "string") {
+          throw new LLMError("OpenAI response missing choices[0].message.content");
+        }
+        return content;
+      }
+      async chatJSON(messages) {
+        const text = await this.chat(messages, { jsonMode: true });
+        try {
+          return JSON.parse(text);
+        } catch {
+          const match = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+          if (match) {
+            return JSON.parse(match[1]);
+          }
+          throw new LLMError(`LLM response is not valid JSON: ${text.slice(0, 200)}`);
+        }
+      }
+    };
+  }
+});
+
+// ai/providers/anthropic.ts
+var anthropic_exports = {};
+__export(anthropic_exports, {
+  AnthropicProvider: () => AnthropicProvider
+});
+var AnthropicProvider;
+var init_anthropic = __esm({
+  "ai/providers/anthropic.ts"() {
+    "use strict";
+    init_errors();
+    AnthropicProvider = class {
+      url;
+      apiKey;
+      model;
+      maxTokens;
+      temperature;
+      constructor(config) {
+        this.url = config.baseUrl ?? "https://api.anthropic.com/v1/messages";
+        this.apiKey = config.apiKey;
+        this.model = config.model;
+        this.maxTokens = config.maxTokens ?? 4096;
+        this.temperature = config.temperature ?? 0.1;
+      }
+      async chat(messages, _options) {
+        const systemMsg = messages.find((m) => m.role === "system");
+        const userMessages = messages.filter((m) => m.role !== "system");
+        const anthropicMessages = userMessages.map((m) => {
+          if (typeof m.content === "string") {
+            return { role: m.role, content: m.content };
+          }
+          const parts = m.content.map((part) => {
+            if (part.type === "text") {
+              return { type: "text", text: part.text };
+            }
+            const dataUrl = part.image_url.url;
+            const match = dataUrl.match(/^data:(image\/\w+);base64,(.+)$/);
+            if (match) {
+              return {
+                type: "image",
+                source: {
+                  type: "base64",
+                  media_type: match[1],
+                  data: match[2]
+                }
+              };
+            }
+            return {
+              type: "image",
+              source: { type: "url", url: dataUrl }
+            };
+          });
+          return { role: m.role, content: parts };
+        });
+        const body = {
+          model: this.model,
+          max_tokens: this.maxTokens,
+          temperature: this.temperature,
+          messages: anthropicMessages
+        };
+        if (systemMsg) {
+          body.system = typeof systemMsg.content === "string" ? systemMsg.content : systemMsg.content.map((p) => p.text).join("\n");
+        }
+        const resp = await fetch(this.url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-api-key": this.apiKey,
+            "anthropic-version": "2023-06-01"
+          },
+          body: JSON.stringify(body)
+        });
+        if (!resp.ok) {
+          const text = await resp.text().catch(() => "");
+          throw new LLMError(`Anthropic API error ${resp.status}: ${text}`);
+        }
+        const json = await resp.json();
+        const content = json?.content?.[0]?.text;
+        if (typeof content !== "string") {
+          throw new LLMError("Anthropic response missing content[0].text");
+        }
+        return content;
+      }
+      async chatJSON(messages) {
+        const text = await this.chat(messages);
+        try {
+          return JSON.parse(text);
+        } catch {
+          const match = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+          if (match) {
+            return JSON.parse(match[1]);
+          }
+          throw new LLMError(`LLM response is not valid JSON: ${text.slice(0, 200)}`);
+        }
+      }
+    };
+  }
+});
+
+// protocol/transport.ts
+init_errors();
+import WebSocket from "ws";
+
+// utils/logger.ts
+var LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 4
+};
+var Logger = class {
+  level;
+  constructor(level = "info") {
+    this.level = LEVELS[level];
+  }
+  setLevel(level) {
+    this.level = LEVELS[level];
+  }
+  debug(msg, data) {
+    if (this.level <= LEVELS.debug) this.log("DEBUG", msg, data);
+  }
+  info(msg, data) {
+    if (this.level <= LEVELS.info) this.log("INFO", msg, data);
+  }
+  warn(msg, data) {
+    if (this.level <= LEVELS.warn) this.log("WARN", msg, data);
+  }
+  error(msg, data) {
+    if (this.level <= LEVELS.error) this.log("ERROR", msg, data);
+  }
+  log(level, msg, data) {
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const extra = data ? " " + JSON.stringify(data) : "";
+    const line = `[${ts}] ${level} spider-browser: ${msg}${extra}`;
+    if (level === "ERROR") {
+      console.error(line);
+    } else if (level === "WARN") {
+      console.warn(line);
+    } else {
+      console.log(line);
+    }
+  }
+};
+var logger = new Logger("info");
+
+// protocol/transport.ts
+var Transport = class {
+  ws = null;
+  messageHandler = null;
+  currentBrowser;
+  opts;
+  emitter;
+  _stealthLevel;
+  /** Generation counter — incremented on each connect. Prevents stale WS messages from being processed. */
+  generation = 0;
+  /** Credits remaining from last upgrade response (x-sc header). */
+  _upgradeCredits;
+  /** Stealth tier from last upgrade response (x-sr header). */
+  _upgradeStealthTier;
+  /** Credits consumed during this session (from Spider.metering event). */
+  _sessionCreditsUsed;
+  constructor(opts, emitter) {
+    this.opts = opts;
+    this.currentBrowser = opts.browser === "auto" ? "chrome" : opts.browser;
+    this.emitter = emitter;
+    this._stealthLevel = opts.stealthLevel ?? 0;
+  }
+  get browser() {
+    return this.currentBrowser;
+  }
+  get connected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  get stealthLevel() {
+    return this._stealthLevel;
+  }
+  set stealthLevel(level) {
+    this._stealthLevel = Math.max(0, Math.min(3, level));
+  }
+  /** Credits remaining from the WebSocket upgrade response. */
+  get upgradeCredits() {
+    return this._upgradeCredits;
+  }
+  /** Active stealth tier from the WebSocket upgrade response. */
+  get upgradeStealthTier() {
+    return this._upgradeStealthTier;
+  }
+  /** Credits consumed during this session (from server Spider.metering event). */
+  get sessionCreditsUsed() {
+    return this._sessionCreditsUsed;
+  }
+  /**
+   * Request the current session cost from the server via Spider.getMetering.
+   * This is a synchronous CDP-style request/response — no event-loop timing issues.
+   * Returns the credits used so far, or the last known value if the request fails.
+   */
+  async requestMetering(timeoutMs = 3e3) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return this._sessionCreditsUsed ?? 0;
+    }
+    const meteringId = 2147483640;
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        resolve(this._sessionCreditsUsed ?? 0);
+      }, timeoutMs);
+      const origHandler = this.messageHandler;
+      this.messageHandler = (data) => {
+        if (data.includes(`"id":${meteringId}`)) {
+          try {
+            const msg = JSON.parse(data);
+            if (msg.id === meteringId && msg.result?.credits_used !== void 0) {
+              clearTimeout(timer);
+              this._sessionCreditsUsed = msg.result.credits_used;
+              this.messageHandler = origHandler;
+              resolve(msg.result.credits_used);
+              return;
+            }
+          } catch {
+          }
+        }
+        if (origHandler) origHandler(data);
+      };
+      try {
+        this.send(JSON.stringify({ id: meteringId, method: "Spider.getMetering" }));
+      } catch {
+        clearTimeout(timer);
+        this.messageHandler = origHandler;
+        resolve(this._sessionCreditsUsed ?? 0);
+      }
+    });
+  }
+  /** Set the handler that receives raw JSON messages from the WebSocket. */
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  /** Connect to the browser_server WebSocket with retry. */
+  async connect(maxAttempts = 3) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      return;
+    }
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        return await this.connectInternal();
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (lastError instanceof AuthError) throw lastError;
+        if (attempt < maxAttempts) {
+          const backoff = 500 * attempt;
+          logger.warn(`connect attempt ${attempt}/${maxAttempts} failed, retrying in ${backoff}ms`, {
+            error: lastError.message
+          });
+          await new Promise((r) => setTimeout(r, backoff));
+        }
+      }
+    }
+    throw lastError;
+  }
+  /** Reconnect with a different browser type (used by retry engine). */
+  async reconnect(browser) {
+    const prev = this.currentBrowser;
+    this.currentBrowser = browser;
+    this.close();
+    logger.info(`switching browser: ${prev} -> ${browser}`);
+    return this.connectInternal();
+  }
+  /** Send a raw JSON string through the WebSocket. */
+  send(data) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new ConnectionError("WebSocket is not connected");
+    }
+    this.ws.send(data);
+  }
+  /** Close the WebSocket connection, removing event listeners to prevent data mixing. */
+  close() {
+    if (this.ws) {
+      const ws = this.ws;
+      this.ws = null;
+      ws.removeAllListeners("message");
+      ws.removeAllListeners("open");
+      ws.removeAllListeners("close");
+      ws.removeAllListeners("upgrade");
+      ws.removeAllListeners("error");
+      ws.on("error", () => {
+      });
+      try {
+        ws.terminate();
+      } catch {
+      }
+    }
+  }
+  buildUrl() {
+    const base = this.opts.serverUrl.replace(/\/$/, "");
+    const params = new URLSearchParams();
+    params.set("token", this.opts.apiKey);
+    if (this.currentBrowser !== "auto") {
+      params.set("browser", this.currentBrowser);
+    }
+    if (this.opts.url) {
+      params.set("url", this.opts.url);
+    }
+    if (this.opts.captcha && this.opts.captcha !== "off") {
+      params.set("ai_captcha", this.opts.captcha);
+    }
+    if (this._stealthLevel > 0) {
+      params.set("s", String(this._stealthLevel));
+    }
+    return `${base}/v1/browser?${params.toString()}`;
+  }
+  connectInternal() {
+    const gen = ++this.generation;
+    return new Promise((resolve, reject) => {
+      const url = this.buildUrl();
+      logger.debug(`connecting to ${url.replace(/token=[^&]+/, "token=***")}`);
+      const ws = new WebSocket(url);
+      let resolved = false;
+      const connectMs = this.opts.connectTimeoutMs ?? 3e4;
+      const timeout = setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          ws.removeAllListeners();
+          ws.on("error", () => {
+          });
+          ws.terminate();
+          reject(new TimeoutError(`WebSocket connection timeout (${connectMs}ms)`));
+        }
+      }, connectMs);
+      ws.on("upgrade", (response) => {
+        const sc = response.headers["x-sc"];
+        const sr = response.headers["x-sr"];
+        if (sc) {
+          this._upgradeCredits = parseFloat(String(sc));
+        }
+        if (sr) {
+          this._upgradeStealthTier = parseInt(String(sr), 10);
+        }
+        if (this._upgradeCredits !== void 0) {
+          this.emitter.emit("metering", {
+            credits: this._upgradeCredits,
+            rate: this._upgradeStealthTier ?? 0
+          });
+        }
+      });
+      ws.on("open", () => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeout);
+          this.ws = ws;
+          this.emitter.emit("ws.open", {});
+          logger.info(`connected (browser=${this.currentBrowser}, stealth=${this._stealthLevel})`);
+          resolve();
+        }
+      });
+      ws.on("message", (raw) => {
+        if (gen !== this.generation) return;
+        const str = raw.toString();
+        if (str.includes('"Spider.metering"')) {
+          try {
+            const msg = JSON.parse(str);
+            if (msg.method === "Spider.metering" && msg.params?.credits_used !== void 0) {
+              this._sessionCreditsUsed = msg.params.credits_used;
+              this.emitter.emit("metering", {
+                credits: this._upgradeCredits ?? 0,
+                rate: this._upgradeStealthTier ?? 0,
+                session_credits_used: msg.params.credits_used
+              });
+              return;
+            }
+          } catch {
+          }
+        }
+        if (this.messageHandler) {
+          this.messageHandler(str);
+        }
+      });
+      ws.on("close", (code, reason) => {
+        const reasonStr = reason.toString();
+        if (gen === this.generation) {
+          this.emitter.emit("ws.close", { code, reason: reasonStr });
+        }
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeout);
+          if (code === 4001 || code === 4002) {
+            reject(new AuthError(`Authentication failed (code ${code}): ${reasonStr}`));
+          } else if (code === 4003) {
+            reject(new BackendUnavailableError(`Backend unavailable: ${reasonStr}`));
+          } else {
+            reject(new ConnectionError(`WebSocket closed during connect: ${code} ${reasonStr}`, code));
+          }
+        }
+      });
+      ws.on("error", (err) => {
+        if (gen === this.generation) {
+          this.emitter.emit("ws.error", { error: err });
+        }
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeout);
+          reject(new ConnectionError(`WebSocket error: ${err.message}`));
+        }
+      });
+    });
+  }
+};
+
+// protocol/cdp-session.ts
+init_errors();
+var CDPSession = class {
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  eventHandlers = /* @__PURE__ */ new Map();
+  transport;
+  /** CDP session ID from Target.attachToTarget (required for page-level commands). */
+  targetSessionId;
+  commandTimeoutMs;
+  constructor(transport, opts) {
+    this.transport = transport;
+    this.commandTimeoutMs = opts?.commandTimeoutMs ?? 3e4;
+  }
+  /** Get the attached target session ID. */
+  get sessionId() {
+    return this.targetSessionId;
+  }
+  /** Process a raw message from the transport. Returns true if handled. */
+  handleMessage(data) {
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      return false;
+    }
+    if (typeof msg.id === "number") {
+      const pending = this.pending.get(msg.id);
+      if (pending) {
+        this.pending.delete(msg.id);
+        clearTimeout(pending.timer);
+        pending.resolve(msg);
+        return true;
+      }
+      return false;
+    }
+    if (typeof msg.method === "string") {
+      const handlers = this.eventHandlers.get(msg.method);
+      if (handlers) {
+        const params = msg.params ?? {};
+        for (const h of handlers) {
+          try {
+            h(params);
+          } catch {
+          }
+        }
+      }
+      const wildcardHandlers = this.eventHandlers.get("*");
+      if (wildcardHandlers) {
+        for (const h of wildcardHandlers) {
+          try {
+            h({ method: msg.method, ...msg.params ?? {} });
+          } catch {
+          }
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+  /** Send a CDP command and wait for the response. */
+  async send(method, params) {
+    const id = this.nextId++;
+    const cmd = { id, method, params: params ?? {} };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new TimeoutError(`CDP command timeout: ${method} (${this.commandTimeoutMs}ms)`));
+      }, this.commandTimeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      try {
+        this.transport.send(JSON.stringify(cmd));
+      } catch (err) {
+        this.pending.delete(id);
+        clearTimeout(timer);
+        reject(err);
+      }
+    });
+  }
+  /**
+   * Send a CDP command scoped to the attached page session.
+   * This is what you use for Page.*, Runtime.*, Input.* commands.
+   */
+  async sendToTarget(method, params) {
+    if (!this.targetSessionId) {
+      throw new ProtocolError("No target session \u2014 call attachToPage() first");
+    }
+    const id = this.nextId++;
+    const cmd = {
+      id,
+      method,
+      params: params ?? {},
+      sessionId: this.targetSessionId
+    };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new TimeoutError(`CDP command timeout: ${method} (${this.commandTimeoutMs}ms)`));
+      }, this.commandTimeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      try {
+        this.transport.send(JSON.stringify(cmd));
+      } catch (err) {
+        this.pending.delete(id);
+        clearTimeout(timer);
+        reject(err);
+      }
+    });
+  }
+  /** Subscribe to a CDP event. */
+  on(method, handler) {
+    let set = this.eventHandlers.get(method);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.eventHandlers.set(method, set);
+    }
+    set.add(handler);
+  }
+  /** Unsubscribe from a CDP event. */
+  off(method, handler) {
+    this.eventHandlers.get(method)?.delete(handler);
+  }
+  // -------------------------------------------------------------------
+  // Browser-level target management
+  // -------------------------------------------------------------------
+  /**
+   * Discover page targets, find or create one, attach to it, and enable
+   * the required CDP domains (Page, Runtime).
+   *
+   * This is the key initialization step — without this, Page.navigate and
+   * Runtime.evaluate won't work because we're connected at browser level.
+   */
+  async attachToPage() {
+    await this.send("Target.setDiscoverTargets", { discover: true });
+    let pageTargetId;
+    logger.debug("creating fresh page target for session isolation");
+    const createResp = await this.send("Target.createTarget", { url: "about:blank" });
+    pageTargetId = createResp.result?.targetId;
+    if (!pageTargetId) {
+      throw new ProtocolError("Failed to create page target");
+    }
+    logger.debug(`created page target: ${pageTargetId}`);
+    const attachResp = await this.send("Target.attachToTarget", {
+      targetId: pageTargetId,
+      flatten: true
+    });
+    let sessionId = attachResp.result?.sessionId;
+    if (!sessionId) {
+      sessionId = await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          this.off("Target.attachedToTarget", handler);
+          reject(new TimeoutError("Timeout waiting for Target.attachedToTarget event"));
+        }, 5e3);
+        const handler = (params) => {
+          const sid = params.sessionId;
+          if (sid) {
+            clearTimeout(timeout);
+            this.off("Target.attachedToTarget", handler);
+            resolve(sid);
+          }
+        };
+        this.on("Target.attachedToTarget", handler);
+      });
+    }
+    this.targetSessionId = sessionId;
+    logger.info(`attached to page target`, { targetId: pageTargetId, sessionId });
+    await this.sendToTarget("Page.enable");
+    await this.sendToTarget("Runtime.enable");
+    return sessionId;
+  }
+  // -------------------------------------------------------------------
+  // High-level CDP commands (all use sendToTarget for page-scoped ops)
+  // -------------------------------------------------------------------
+  /** Capture a screenshot as base64 PNG (10s timeout to avoid blocking on heavy pages). */
+  async captureScreenshot() {
+    const screenshotTimeout = Math.min(this.commandTimeoutMs, 1e4);
+    const id = this.nextId++;
+    const cmd = {
+      id,
+      method: "Page.captureScreenshot",
+      params: { format: "png" },
+      sessionId: this.targetSessionId
+    };
+    const resp = await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new TimeoutError(`CDP command timeout: Page.captureScreenshot (${screenshotTimeout}ms)`));
+      }, screenshotTimeout);
+      this.pending.set(id, { resolve, reject, timer });
+      try {
+        this.transport.send(JSON.stringify(cmd));
+      } catch (err) {
+        this.pending.delete(id);
+        clearTimeout(timer);
+        reject(err);
+      }
+    });
+    const data = resp.result?.["data"];
+    if (typeof data !== "string") {
+      throw new ProtocolError("captureScreenshot: missing result.data");
+    }
+    return data;
+  }
+  /** Get full page HTML. */
+  async getHTML() {
+    const resp = await this.sendToTarget("Runtime.evaluate", {
+      expression: "document.documentElement.outerHTML",
+      returnByValue: true
+    });
+    return this.extractEvalValue(resp);
+  }
+  /** Evaluate a JavaScript expression and return the value. */
+  async evaluate(expression) {
+    const resp = await this.sendToTarget("Runtime.evaluate", {
+      expression,
+      returnByValue: true
+    });
+    return this.extractEvalValue(resp);
+  }
+  /** Wait for a CDP event to fire, with timeout. Returns true if event fired, false on timeout. */
+  waitForEvent(method, timeoutMs) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.off(method, handler);
+        resolve(false);
+      }, timeoutMs);
+      const handler = () => {
+        clearTimeout(timer);
+        this.off(method, handler);
+        resolve(true);
+      };
+      this.on(method, handler);
+    });
+  }
+  /** Navigate to a URL and wait for the page to load. */
+  async navigate(url) {
+    const loadPromise = this.waitForEvent("Page.loadEventFired", 3e4);
+    const stopPromise = this.waitForEvent("Page.frameStoppedLoading", 35e3);
+    const resp = await this.sendToTarget("Page.navigate", { url });
+    const errorText = resp.result?.errorText;
+    if (errorText) {
+      loadPromise.catch(() => {
+      });
+      stopPromise.catch(() => {
+      });
+      if (isRetryableNavError(errorText)) {
+        throw new NavigationError(`Navigation failed: ${errorText}`);
+      }
+      throw new ProtocolError(`Navigation failed: ${errorText}`);
+    }
+    const loaded = await loadPromise;
+    if (!loaded) {
+      await stopPromise;
+    }
+  }
+  /** Dispatch a mouse event. */
+  async dispatchMouseEvent(type, x, y, button = "none", clickCount = 0) {
+    await this.sendToTarget("Input.dispatchMouseEvent", { type, x, y, button, clickCount });
+  }
+  /** Click at coordinates (mouseMoved -> mousePressed -> mouseReleased). */
+  async clickPoint(x, y) {
+    await this.dispatchMouseEvent("mouseMoved", x, y, "none", 0);
+    await this.dispatchMouseEvent("mousePressed", x, y, "left", 1);
+    await this.dispatchMouseEvent("mouseReleased", x, y, "left", 1);
+  }
+  /** Right-click at coordinates. */
+  async rightClickPoint(x, y) {
+    await this.dispatchMouseEvent("mouseMoved", x, y, "none", 0);
+    await this.dispatchMouseEvent("mousePressed", x, y, "right", 1);
+    await this.dispatchMouseEvent("mouseReleased", x, y, "right", 1);
+  }
+  /** Double-click at coordinates. */
+  async doubleClickPoint(x, y) {
+    await this.dispatchMouseEvent("mouseMoved", x, y, "none", 0);
+    await this.dispatchMouseEvent("mousePressed", x, y, "left", 1);
+    await this.dispatchMouseEvent("mouseReleased", x, y, "left", 1);
+    await this.dispatchMouseEvent("mousePressed", x, y, "left", 2);
+    await this.dispatchMouseEvent("mouseReleased", x, y, "left", 2);
+  }
+  /** Click and hold at coordinates for a duration. */
+  async clickHoldPoint(x, y, holdMs) {
+    await this.dispatchMouseEvent("mouseMoved", x, y, "none", 0);
+    await this.dispatchMouseEvent("mousePressed", x, y, "left", 1);
+    await sleep(holdMs);
+    await this.dispatchMouseEvent("mouseReleased", x, y, "left", 1);
+  }
+  /** Hover (mouseMoved only). */
+  async hoverPoint(x, y) {
+    await this.dispatchMouseEvent("mouseMoved", x, y, "none", 0);
+  }
+  /** Smooth drag from point to point (10-step interpolation). */
+  async dragPoint(fromX, fromY, toX, toY) {
+    const steps = 10;
+    await this.dispatchMouseEvent("mouseMoved", fromX, fromY, "none", 0);
+    await this.dispatchMouseEvent("mousePressed", fromX, fromY, "left", 1);
+    for (let i = 1; i <= steps; i++) {
+      const t = i / steps;
+      const x = fromX + (toX - fromX) * t;
+      const y = fromY + (toY - fromY) * t;
+      await this.dispatchMouseEvent("mouseMoved", x, y, "left", 0);
+      await sleep(16);
+    }
+    await this.dispatchMouseEvent("mouseReleased", toX, toY, "left", 1);
+  }
+  /** Insert text via Input.insertText. */
+  async insertText(text) {
+    await this.sendToTarget("Input.insertText", { text });
+  }
+  /** Press a key (keyDown + keyUp). */
+  async pressKey(key, code, keyCode) {
+    await this.sendToTarget("Input.dispatchKeyEvent", {
+      type: "keyDown",
+      key,
+      code,
+      windowsVirtualKeyCode: keyCode,
+      text: key
+    });
+    await this.sendToTarget("Input.dispatchKeyEvent", {
+      type: "keyUp",
+      key,
+      code,
+      windowsVirtualKeyCode: keyCode
+    });
+  }
+  /** Send keyDown event. */
+  async keyDown(key, code, keyCode) {
+    await this.sendToTarget("Input.dispatchKeyEvent", {
+      type: "keyDown",
+      key,
+      code,
+      windowsVirtualKeyCode: keyCode,
+      text: key
+    });
+  }
+  /** Send keyUp event. */
+  async keyUp(key, code, keyCode) {
+    await this.sendToTarget("Input.dispatchKeyEvent", {
+      type: "keyUp",
+      key,
+      code,
+      windowsVirtualKeyCode: keyCode
+    });
+  }
+  /** Set viewport via Emulation.setDeviceMetricsOverride. */
+  async setViewport(width, height, deviceScaleFactor = 2, mobile = false) {
+    await this.sendToTarget("Emulation.setDeviceMetricsOverride", {
+      width,
+      height,
+      deviceScaleFactor,
+      mobile
+    });
+  }
+  /** Clean up all pending commands and event handlers. Rejects in-flight commands. */
+  destroy() {
+    const pendingSnapshot = [...this.pending.values()];
+    this.pending.clear();
+    this.eventHandlers.clear();
+    this.targetSessionId = void 0;
+    for (const pending of pendingSnapshot) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("session destroyed"));
+    }
+  }
+  extractEvalValue(resp) {
+    if (resp.error) {
+      throw new ProtocolError(`CDP error: ${resp.error.message}`);
+    }
+    const result = resp.result;
+    return result?.result?.value;
+  }
+};
+var RETRYABLE_NAV_ERRORS = [
+  "net::ERR_ABORTED",
+  "net::ERR_CONNECTION_RESET",
+  "net::ERR_CONNECTION_CLOSED",
+  "net::ERR_CONNECTION_REFUSED",
+  "net::ERR_CONNECTION_TIMED_OUT",
+  "net::ERR_TIMED_OUT",
+  "net::ERR_EMPTY_RESPONSE",
+  "net::ERR_SOCKET_NOT_CONNECTED",
+  "net::ERR_NETWORK_CHANGED"
+];
+function isRetryableNavError(errorText) {
+  return RETRYABLE_NAV_ERRORS.some((e) => errorText.includes(e));
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// protocol/bidi-session.ts
+init_errors();
+var BiDiSession = class {
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  eventHandlers = /* @__PURE__ */ new Map();
+  transport;
+  browsingContext;
+  commandTimeoutMs;
+  constructor(transport, opts) {
+    this.transport = transport;
+    this.commandTimeoutMs = opts?.commandTimeoutMs ?? 3e4;
+  }
+  get context() {
+    return this.browsingContext;
+  }
+  /** Process a raw message from the transport. Returns true if handled. */
+  handleMessage(data) {
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      return false;
+    }
+    if (typeof msg.id === "number" && typeof msg.type === "string") {
+      const pending = this.pending.get(msg.id);
+      if (pending) {
+        this.pending.delete(msg.id);
+        clearTimeout(pending.timer);
+        pending.resolve(msg);
+        return true;
+      }
+      return false;
+    }
+    if (msg.type === "event" && typeof msg.method === "string") {
+      const handlers = this.eventHandlers.get(msg.method);
+      if (handlers) {
+        const params = msg.params ?? {};
+        for (const h of handlers) {
+          try {
+            h(params);
+          } catch {
+          }
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+  /** Send a BiDi command and wait for the response. */
+  async send(method, params) {
+    const id = this.nextId++;
+    const cmd = { id, method, params };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new TimeoutError(`BiDi command timeout: ${method} (${this.commandTimeoutMs}ms)`));
+      }, this.commandTimeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      try {
+        this.transport.send(JSON.stringify(cmd));
+      } catch (err) {
+        this.pending.delete(id);
+        clearTimeout(timer);
+        reject(err);
+      }
+    });
+  }
+  /** Subscribe to a BiDi event. */
+  on(method, handler) {
+    let set = this.eventHandlers.get(method);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.eventHandlers.set(method, set);
+    }
+    set.add(handler);
+  }
+  /** Unsubscribe from a BiDi event. */
+  off(method, handler) {
+    this.eventHandlers.get(method)?.delete(handler);
+  }
+  // -------------------------------------------------------------------
+  // High-level BiDi commands
+  // -------------------------------------------------------------------
+  /**
+   * Get or create a browsing context.
+   *
+   * The browser_server's Firefox relay proxies to geckodriver which already has
+   * a session with a browsing context. We try multiple strategies:
+   * 1. browsingContext.getTree (standard BiDi)
+   * 2. session.status (to get session info, then extract context)
+   * 3. browsingContext.create as last resort
+   *
+   * If all discovery fails, we set a placeholder context that gets replaced
+   * on the first successful navigate response.
+   */
+  async getOrCreateContext() {
+    if (this.browsingContext) return this.browsingContext;
+    try {
+      const savedTimeout = this.commandTimeoutMs;
+      try {
+        this.commandTimeoutMs = 5e3;
+        const resp = await this.send("browsingContext.getTree", {});
+        const contexts = resp.result?.contexts;
+        if (Array.isArray(contexts) && contexts.length > 0) {
+          this.browsingContext = contexts[0].context;
+          return this.browsingContext;
+        }
+      } finally {
+        this.commandTimeoutMs = savedTimeout;
+      }
+    } catch {
+    }
+    try {
+      const savedTimeout = this.commandTimeoutMs;
+      try {
+        this.commandTimeoutMs = 5e3;
+        const createResp = await this.send("browsingContext.create", { type: "tab" });
+        const ctx = createResp.result?.context;
+        if (ctx) {
+          this.browsingContext = ctx;
+          return this.browsingContext;
+        }
+      } finally {
+        this.commandTimeoutMs = savedTimeout;
+      }
+    } catch {
+    }
+    this.browsingContext = "__default__";
+    return this.browsingContext;
+  }
+  /** Set the browsing context (called when we discover it from a response). */
+  setContext(contextId) {
+    this.browsingContext = contextId;
+  }
+  /** Navigate to a URL. */
+  async navigate(url) {
+    const ctx = await this.getOrCreateContext();
+    const resp = await this.send("browsingContext.navigate", {
+      context: ctx,
+      url,
+      wait: "complete"
+    });
+    if (this.browsingContext === "__default__") {
+      const realCtx = resp.result?.navigation ? resp?.params?.context : void 0;
+      if (realCtx) {
+        this.browsingContext = realCtx;
+      }
+    }
+  }
+  /** Capture a screenshot as base64 PNG. */
+  async captureScreenshot() {
+    const ctx = await this.getOrCreateContext();
+    const resp = await this.send("browsingContext.captureScreenshot", { context: ctx });
+    const data = resp.result?.data;
+    if (typeof data !== "string") {
+      throw new ProtocolError("captureScreenshot: missing result.data");
+    }
+    return data;
+  }
+  /**
+   * Evaluate JavaScript and return the value.
+   *
+   * BiDi script.evaluate returns results in this format:
+   *   { result: { type: "string", value: "..." } }
+   *   { result: { type: "number", value: 42 } }
+   *   { result: { type: "boolean", value: true } }
+   *   { result: { type: "object", value: [...entries...] } }
+   *   { result: { type: "null" } }
+   *   { result: { type: "undefined" } }
+   *   { result: { type: "array", value: [...] } }
+   */
+  async evaluate(expression) {
+    const ctx = await this.getOrCreateContext();
+    const resp = await this.send("script.evaluate", {
+      expression,
+      target: { context: ctx },
+      awaitPromise: false,
+      resultOwnership: "none"
+    });
+    if (resp.type === "error") {
+      throw new ProtocolError(`BiDi script error: ${resp.message ?? resp.error}`);
+    }
+    const resultObj = resp.result?.result ?? resp.result;
+    return this.extractBiDiValue(resultObj);
+  }
+  /** Extract a JS value from a BiDi remote value object. */
+  extractBiDiValue(remoteValue) {
+    if (!remoteValue) return void 0;
+    const type = remoteValue.type;
+    switch (type) {
+      case "undefined":
+        return void 0;
+      case "null":
+        return null;
+      case "string":
+      case "number":
+      case "boolean":
+      case "bigint":
+        return remoteValue.value;
+      case "array":
+        if (Array.isArray(remoteValue.value)) {
+          return remoteValue.value.map((v) => this.extractBiDiValue(v));
+        }
+        return remoteValue.value;
+      case "object":
+        if (Array.isArray(remoteValue.value)) {
+          const obj = {};
+          for (const entry of remoteValue.value) {
+            if (Array.isArray(entry) && entry.length === 2) {
+              const key = typeof entry[0] === "string" ? entry[0] : entry[0]?.value ?? String(entry[0]);
+              obj[key] = this.extractBiDiValue(entry[1]);
+            }
+          }
+          return obj;
+        }
+        return remoteValue.value;
+      default:
+        return remoteValue.value ?? remoteValue;
+    }
+  }
+  /** Get full page HTML. */
+  async getHTML() {
+    return await this.evaluate("document.documentElement.outerHTML");
+  }
+  /**
+   * Perform actions (BiDi input.performActions).
+   * This is the BiDi way to do mouse/keyboard events.
+   */
+  async performActions(actions) {
+    const ctx = await this.getOrCreateContext();
+    await this.send("input.performActions", {
+      context: ctx,
+      actions
+    });
+  }
+  /** Click at coordinates via BiDi input actions. */
+  async clickPoint(x, y) {
+    await this.performActions([
+      {
+        type: "pointer",
+        id: "mouse",
+        actions: [
+          { type: "pointerMove", x: Math.round(x), y: Math.round(y) },
+          { type: "pointerDown", button: 0 },
+          { type: "pointerUp", button: 0 }
+        ]
+      }
+    ]);
+  }
+  /** Insert text via BiDi input actions. */
+  async insertText(text) {
+    const actions = text.split("").map((ch) => [
+      { type: "keyDown", value: ch },
+      { type: "keyUp", value: ch }
+    ]).flat();
+    await this.performActions([{ type: "key", id: "keyboard", actions }]);
+  }
+  /** Clean up all pending commands and event handlers. Rejects in-flight commands. */
+  destroy() {
+    const pendingSnapshot = [...this.pending.values()];
+    this.pending.clear();
+    this.eventHandlers.clear();
+    this.browsingContext = void 0;
+    for (const pending of pendingSnapshot) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("session destroyed"));
+    }
+  }
+};
+
+// protocol/types.ts
+var KEY_MAP = {
+  Enter: { key: "Enter", code: "Enter", keyCode: 13 },
+  Tab: { key: "Tab", code: "Tab", keyCode: 9 },
+  Escape: { key: "Escape", code: "Escape", keyCode: 27 },
+  Backspace: { key: "Backspace", code: "Backspace", keyCode: 8 },
+  Delete: { key: "Delete", code: "Delete", keyCode: 46 },
+  Space: { key: " ", code: "Space", keyCode: 32 },
+  " ": { key: " ", code: "Space", keyCode: 32 },
+  ArrowLeft: { key: "ArrowLeft", code: "ArrowLeft", keyCode: 37 },
+  ArrowUp: { key: "ArrowUp", code: "ArrowUp", keyCode: 38 },
+  ArrowRight: { key: "ArrowRight", code: "ArrowRight", keyCode: 39 },
+  ArrowDown: { key: "ArrowDown", code: "ArrowDown", keyCode: 40 },
+  Home: { key: "Home", code: "Home", keyCode: 36 },
+  End: { key: "End", code: "End", keyCode: 35 },
+  PageUp: { key: "PageUp", code: "PageUp", keyCode: 33 },
+  PageDown: { key: "PageDown", code: "PageDown", keyCode: 34 }
+};
+function getKeyParams(keyName) {
+  return KEY_MAP[keyName] ?? { key: keyName, code: keyName, keyCode: 0 };
+}
+
+// protocol/protocol-adapter.ts
+var ProtocolAdapter = class {
+  cdp = null;
+  bidi = null;
+  transport;
+  emitter;
+  protocol;
+  adapterOpts;
+  constructor(transport, emitter, browser, opts) {
+    this.transport = transport;
+    this.emitter = emitter;
+    this.adapterOpts = opts ?? {};
+    const sessionOpts = opts?.commandTimeoutMs ? { commandTimeoutMs: opts.commandTimeoutMs } : void 0;
+    if (browser === "auto") {
+      this.protocol = "auto";
+    } else if (browser === "firefox") {
+      this.protocol = "bidi";
+      this.bidi = new BiDiSession(transport, sessionOpts);
+    } else {
+      this.protocol = "cdp";
+      this.cdp = new CDPSession(transport, sessionOpts);
+    }
+    transport.onMessage((data) => this.routeMessage(data));
+  }
+  /** Whether this adapter uses CDP or BiDi (or 'auto' before init). */
+  get protocolType() {
+    return this.protocol;
+  }
+  /** Route incoming WebSocket messages to the right session + spider events. */
+  routeMessage(data) {
+    try {
+      const msg = JSON.parse(data);
+      if (typeof msg.method === "string" && msg.method.startsWith("Spider.")) {
+        this.handleSpiderEvent(msg.method, msg.params ?? {});
+        return;
+      }
+    } catch {
+    }
+    if (this.cdp) {
+      this.cdp.handleMessage(data);
+    } else if (this.bidi) {
+      this.bidi.handleMessage(data);
+    }
+  }
+  /** Handle Spider.* custom events from the browser_server. */
+  handleSpiderEvent(method, params) {
+    switch (method) {
+      case "Spider.captchaDetected":
+        this.emitter.emit("captcha.detected", {
+          types: params.types ?? [],
+          url: params.url ?? ""
+        });
+        break;
+      case "Spider.captchaSolving":
+        this.emitter.emit("captcha.solving", {
+          types: params.types ?? [],
+          url: params.url ?? "",
+          round: params.round ?? 0
+        });
+        break;
+      case "Spider.captchaSolved":
+        this.emitter.emit("captcha.solved", { url: params.url ?? "" });
+        break;
+      case "Spider.captchaFailed":
+        this.emitter.emit("captcha.failed", {
+          url: params.url ?? "",
+          reason: params.reason ?? ""
+        });
+        break;
+      default:
+        logger.debug(`unhandled Spider event: ${method}`, params);
+    }
+  }
+  // -------------------------------------------------------------------
+  // Unified interface — all methods work for both CDP and BiDi
+  // -------------------------------------------------------------------
+  /**
+   * Initialize the protocol session.
+   *
+   * For CDP (Chrome/Servo/LightPanda): discovers page targets, attaches to one
+   * with flatten:true to get a sessionId, then enables Page + Runtime domains
+   * on that target. This is required because browser_server proxies to Chrome's
+   * browser-level CDP endpoint.
+   *
+   * For BiDi (Firefox): gets or creates a browsing context.
+   *
+   * For "auto" mode: tries CDP first (Target.setDiscoverTargets). If it fails
+   * (e.g. we actually got a BiDi session), falls back to BiDi.
+   */
+  async init() {
+    if (this.protocol === "auto") {
+      await this.autoDetectAndInit();
+      return;
+    }
+    if (this.cdp) {
+      await this.cdp.attachToPage();
+    } else if (this.bidi) {
+      await this.bidi.getOrCreateContext();
+    }
+  }
+  /**
+   * Auto-detect protocol by trying CDP first, falling back to BiDi.
+   * Used when browser type is "auto" and we don't know what the server gave us.
+   */
+  async autoDetectAndInit() {
+    const sessionOpts = this.adapterOpts.commandTimeoutMs ? { commandTimeoutMs: this.adapterOpts.commandTimeoutMs } : void 0;
+    try {
+      this.cdp = new CDPSession(this.transport, sessionOpts);
+      this.transport.onMessage((data) => this.routeMessage(data));
+      await this.cdp.attachToPage();
+      this.protocol = "cdp";
+      logger.info("auto-detected CDP protocol");
+      return;
+    } catch {
+      this.cdp?.destroy();
+      this.cdp = null;
+    }
+    this.bidi = new BiDiSession(this.transport, sessionOpts);
+    this.transport.onMessage((data) => this.routeMessage(data));
+    await this.bidi.getOrCreateContext();
+    this.protocol = "bidi";
+    logger.info("auto-detected BiDi protocol");
+  }
+  /** Navigate to URL. */
+  async navigate(url) {
+    if (this.cdp) {
+      await this.cdp.navigate(url);
+    } else {
+      await this.bidi.navigate(url);
+    }
+  }
+  /** Get page HTML. */
+  async getHTML() {
+    if (this.cdp) {
+      return this.cdp.getHTML();
+    }
+    return this.bidi.getHTML();
+  }
+  /** Evaluate JavaScript expression. */
+  async evaluate(expression) {
+    if (this.cdp) {
+      return this.cdp.evaluate(expression);
+    }
+    return this.bidi.evaluate(expression);
+  }
+  /** Capture screenshot as base64 PNG. */
+  async captureScreenshot() {
+    if (this.cdp) {
+      return this.cdp.captureScreenshot();
+    }
+    return this.bidi.captureScreenshot();
+  }
+  /** Click at viewport coordinates. */
+  async clickPoint(x, y) {
+    if (this.cdp) {
+      await this.cdp.clickPoint(x, y);
+    } else {
+      await this.bidi.clickPoint(x, y);
+    }
+  }
+  /** Right-click at coordinates. */
+  async rightClickPoint(x, y) {
+    if (this.cdp) {
+      await this.cdp.rightClickPoint(x, y);
+    } else {
+      await this.bidi.performActions([
+        {
+          type: "pointer",
+          id: "mouse",
+          actions: [
+            { type: "pointerMove", x: Math.round(x), y: Math.round(y) },
+            { type: "pointerDown", button: 2 },
+            { type: "pointerUp", button: 2 }
+          ]
+        }
+      ]);
+    }
+  }
+  /** Double-click at coordinates. */
+  async doubleClickPoint(x, y) {
+    if (this.cdp) {
+      await this.cdp.doubleClickPoint(x, y);
+    } else {
+      await this.bidi.performActions([
+        {
+          type: "pointer",
+          id: "mouse",
+          actions: [
+            { type: "pointerMove", x: Math.round(x), y: Math.round(y) },
+            { type: "pointerDown", button: 0 },
+            { type: "pointerUp", button: 0 },
+            { type: "pointerDown", button: 0 },
+            { type: "pointerUp", button: 0 }
+          ]
+        }
+      ]);
+    }
+  }
+  /** Click and hold at coordinates. */
+  async clickHoldPoint(x, y, holdMs) {
+    if (this.cdp) {
+      await this.cdp.clickHoldPoint(x, y, holdMs);
+    } else {
+      await this.bidi.performActions([
+        {
+          type: "pointer",
+          id: "mouse",
+          actions: [
+            { type: "pointerMove", x: Math.round(x), y: Math.round(y) },
+            { type: "pointerDown", button: 0 },
+            { type: "pause", duration: holdMs },
+            { type: "pointerUp", button: 0 }
+          ]
+        }
+      ]);
+    }
+  }
+  /** Hover at coordinates. */
+  async hoverPoint(x, y) {
+    if (this.cdp) {
+      await this.cdp.hoverPoint(x, y);
+    } else {
+      await this.bidi.performActions([
+        {
+          type: "pointer",
+          id: "mouse",
+          actions: [{ type: "pointerMove", x: Math.round(x), y: Math.round(y) }]
+        }
+      ]);
+    }
+  }
+  /** Smooth drag from point to point. */
+  async dragPoint(fromX, fromY, toX, toY) {
+    if (this.cdp) {
+      await this.cdp.dragPoint(fromX, fromY, toX, toY);
+    } else {
+      const steps = 10;
+      const actions = [
+        { type: "pointerMove", x: Math.round(fromX), y: Math.round(fromY) },
+        { type: "pointerDown", button: 0 }
+      ];
+      for (let i = 1; i <= steps; i++) {
+        const t = i / steps;
+        actions.push({
+          type: "pointerMove",
+          x: Math.round(fromX + (toX - fromX) * t),
+          y: Math.round(fromY + (toY - fromY) * t),
+          duration: 16
+        });
+      }
+      actions.push({ type: "pointerUp", button: 0 });
+      await this.bidi.performActions([{ type: "pointer", id: "mouse", actions }]);
+    }
+  }
+  /** Insert text. */
+  async insertText(text) {
+    if (this.cdp) {
+      await this.cdp.insertText(text);
+    } else {
+      await this.bidi.insertText(text);
+    }
+  }
+  /** Press a named key (e.g. "Enter", "Tab"). */
+  async pressKey(keyName) {
+    const { key, code, keyCode } = getKeyParams(keyName);
+    if (this.cdp) {
+      await this.cdp.pressKey(key, code, keyCode);
+    } else {
+      await this.bidi.performActions([
+        {
+          type: "key",
+          id: "keyboard",
+          actions: [
+            { type: "keyDown", value: key },
+            { type: "keyUp", value: key }
+          ]
+        }
+      ]);
+    }
+  }
+  /** Send keyDown. */
+  async keyDown(keyName) {
+    const { key, code, keyCode } = getKeyParams(keyName);
+    if (this.cdp) {
+      await this.cdp.keyDown(key, code, keyCode);
+    } else {
+      await this.bidi.performActions([
+        { type: "key", id: "keyboard", actions: [{ type: "keyDown", value: key }] }
+      ]);
+    }
+  }
+  /** Send keyUp. */
+  async keyUp(keyName) {
+    const { key, code, keyCode } = getKeyParams(keyName);
+    if (this.cdp) {
+      await this.cdp.keyUp(key, code, keyCode);
+    } else {
+      await this.bidi.performActions([
+        { type: "key", id: "keyboard", actions: [{ type: "keyUp", value: key }] }
+      ]);
+    }
+  }
+  /** Set viewport dimensions. */
+  async setViewport(width, height, deviceScaleFactor = 2, mobile = false) {
+    if (this.cdp) {
+      await this.cdp.setViewport(width, height, deviceScaleFactor, mobile);
+    } else {
+      await this.bidi.evaluate(
+        `window.resizeTo(${width}, ${height})`
+      );
+    }
+  }
+  /** Subscribe to a CDP domain event (only relevant for CDP). */
+  onProtocolEvent(method, handler) {
+    if (this.cdp) {
+      this.cdp.on(method, handler);
+    } else if (this.bidi) {
+      this.bidi.on(method, handler);
+    }
+  }
+  /** Clean up resources. Nulls references first to prevent stale message routing. */
+  destroy() {
+    const cdp = this.cdp;
+    const bidi = this.bidi;
+    this.cdp = null;
+    this.bidi = null;
+    cdp?.destroy();
+    bidi?.destroy();
+  }
+};
+
+// events/emitter.ts
+var SpiderEventEmitter = class {
+  handlers = /* @__PURE__ */ new Map();
+  on(event, handler) {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+    return this;
+  }
+  off(event, handler) {
+    this.handlers.get(event)?.delete(handler);
+    return this;
+  }
+  once(event, handler) {
+    const wrapped = (data) => {
+      this.off(event, wrapped);
+      handler(data);
+    };
+    return this.on(event, wrapped);
+  }
+  emit(event, data) {
+    const set = this.handlers.get(event);
+    if (set) {
+      for (const handler of set) {
+        try {
+          handler(data);
+        } catch {
+        }
+      }
+    }
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.handlers.delete(event);
+    } else {
+      this.handlers.clear();
+    }
+  }
+};
+
+// page.ts
+init_errors();
+var SpiderPage = class {
+  /** @internal */
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  // -------------------------------------------------------------------
+  // Navigation
+  // -------------------------------------------------------------------
+  /** Navigate to a URL and wait for load. */
+  async goto(url) {
+    await this.adapter.navigate(url);
+  }
+  /** Go back in browser history. */
+  async goBack() {
+    await this.adapter.evaluate("window.history.back()");
+  }
+  /** Go forward in browser history. */
+  async goForward() {
+    await this.adapter.evaluate("window.history.forward()");
+  }
+  /** Reload the page. */
+  async reload() {
+    await this.adapter.evaluate("window.location.reload()");
+  }
+  // -------------------------------------------------------------------
+  // Content
+  // -------------------------------------------------------------------
+  /**
+   * Get the full page HTML, ensuring the page is ready first.
+   *
+   * Waits for network idle + DOM stability, then checks content quality.
+   * If the content seems incomplete (too short or looks like a loading state),
+   * does incremental waits with exponential backoff before returning.
+   *
+   * @param waitMs Max time to wait for readiness (default: 8000ms).
+   *               Pass 0 to skip readiness checks and return immediately.
+   * @param minLength Minimum content length to consider "good" (default: 1000).
+   */
+  async content(waitMs = 8e3, minLength = 1e3) {
+    if (waitMs > 0) {
+      await this.waitForNetworkIdle(waitMs);
+    }
+    let html = await this.adapter.getHTML() ?? "";
+    if (waitMs > 0 && this.isInterstitialContent(html)) {
+      const interstitialWaits = [4e3, 4e3, 4e3];
+      for (const wait of interstitialWaits) {
+        await sleep2(wait);
+        html = await this.adapter.getHTML() ?? "";
+        if (!this.isInterstitialContent(html)) break;
+      }
+      if (this.isInterstitialContent(html)) {
+        throw new BlockedError("Page stuck on interstitial challenge");
+      }
+    }
+    if (waitMs > 0 && this.isRateLimitContent(html)) {
+      throw new BlockedError("Rate limit exceeded (site-level)");
+    }
+    if (waitMs > 0 && html.length < minLength) {
+      const increments = [300, 500, 800, 1200];
+      for (const extra of increments) {
+        await sleep2(extra);
+        const updated = await this.adapter.getHTML();
+        if (updated.length > html.length) {
+          html = updated;
+        }
+        if (html.length >= minLength) break;
+      }
+    }
+    return html;
+  }
+  /**
+   * Get the raw page HTML without any readiness waiting.
+   * Use this when you need immediate access or have already waited.
+   */
+  async rawContent() {
+    return this.adapter.getHTML();
+  }
+  /** Get the page title. */
+  async title() {
+    return await this.adapter.evaluate("document.title");
+  }
+  /** Get the current page URL. */
+  async url() {
+    return await this.adapter.evaluate("window.location.href");
+  }
+  /** Capture a screenshot as base64 PNG. */
+  async screenshot() {
+    return this.adapter.captureScreenshot();
+  }
+  /** Evaluate arbitrary JavaScript and return the result. */
+  async evaluate(expression) {
+    return this.adapter.evaluate(expression);
+  }
+  // -------------------------------------------------------------------
+  // Click Actions
+  // -------------------------------------------------------------------
+  /** Click an element by CSS selector. */
+  async click(selector) {
+    const { x, y } = await this.getElementCenter(selector);
+    await this.adapter.clickPoint(x, y);
+  }
+  /** Click at specific viewport coordinates. */
+  async clickAt(x, y) {
+    await this.adapter.clickPoint(x, y);
+  }
+  /** Double-click an element by CSS selector. */
+  async dblclick(selector) {
+    const { x, y } = await this.getElementCenter(selector);
+    await this.adapter.doubleClickPoint(x, y);
+  }
+  /** Right-click an element by CSS selector. */
+  async rightClick(selector) {
+    const { x, y } = await this.getElementCenter(selector);
+    await this.adapter.rightClickPoint(x, y);
+  }
+  /** Click all elements matching a selector. */
+  async clickAll(selector) {
+    const points = await this.adapter.evaluate(`
+      (function() {
+        const els = document.querySelectorAll(${JSON.stringify(selector)});
+        return Array.from(els).map(el => {
+          const r = el.getBoundingClientRect();
+          return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
+        });
+      })()
+    `);
+    if (Array.isArray(points)) {
+      for (const pt of points) {
+        await this.adapter.clickPoint(pt.x, pt.y);
+        await sleep2(100);
+      }
+    }
+  }
+  // -------------------------------------------------------------------
+  // Input Actions
+  // -------------------------------------------------------------------
+  /** Fill a form field — focus, clear existing value, type new value. */
+  async fill(selector, value) {
+    await this.adapter.evaluate(`
+      (function() {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (el) { el.focus(); el.value = ''; }
+      })()
+    `);
+    try {
+      const { x, y } = await this.getElementCenter(selector);
+      await this.adapter.clickPoint(x, y);
+    } catch {
+    }
+    await this.adapter.insertText(value);
+    await this.adapter.evaluate(`
+      (function() {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (el) {
+          el.dispatchEvent(new Event('input', { bubbles: true }));
+          el.dispatchEvent(new Event('change', { bubbles: true }));
+        }
+      })()
+    `);
+  }
+  /** Type text into the currently focused element. */
+  async type(value) {
+    await this.adapter.insertText(value);
+  }
+  /** Press a named key (e.g. "Enter", "Tab", "Escape"). */
+  async press(key) {
+    await this.adapter.pressKey(key);
+  }
+  /** Clear an input field. */
+  async clear(selector) {
+    await this.adapter.evaluate(
+      `document.querySelector(${JSON.stringify(selector)}).value = ''`
+    );
+  }
+  /** Select an option in a <select> element. */
+  async select(selector, value) {
+    await this.adapter.evaluate(`
+      (function() {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (el) {
+          el.value = ${JSON.stringify(value)};
+          el.dispatchEvent(new Event('change', { bubbles: true }));
+        }
+      })()
+    `);
+  }
+  // -------------------------------------------------------------------
+  // Focus & Hover
+  // -------------------------------------------------------------------
+  /** Focus an element. */
+  async focus(selector) {
+    await this.adapter.evaluate(
+      `document.querySelector(${JSON.stringify(selector)})?.focus()`
+    );
+  }
+  /** Blur (unfocus) an element. */
+  async blur(selector) {
+    await this.adapter.evaluate(
+      `document.querySelector(${JSON.stringify(selector)})?.blur()`
+    );
+  }
+  /** Hover over an element. */
+  async hover(selector) {
+    const { x, y } = await this.getElementCenter(selector);
+    await this.adapter.hoverPoint(x, y);
+  }
+  // -------------------------------------------------------------------
+  // Drag
+  // -------------------------------------------------------------------
+  /** Drag from one element to another. */
+  async drag(fromSelector, toSelector) {
+    const from = await this.getElementCenter(fromSelector);
+    const to = await this.getElementCenter(toSelector);
+    await this.adapter.dragPoint(from.x, from.y, to.x, to.y);
+  }
+  // -------------------------------------------------------------------
+  // Scroll
+  // -------------------------------------------------------------------
+  /** Scroll vertically by pixels (positive = down). */
+  async scrollY(pixels) {
+    await this.adapter.evaluate(`window.scrollBy(0, ${pixels})`);
+  }
+  /** Scroll horizontally by pixels (positive = right). */
+  async scrollX(pixels) {
+    await this.adapter.evaluate(`window.scrollBy(${pixels}, 0)`);
+  }
+  /** Scroll an element into view. */
+  async scrollTo(selector) {
+    await this.adapter.evaluate(
+      `document.querySelector(${JSON.stringify(selector)})?.scrollIntoView({ behavior: 'smooth', block: 'center' })`
+    );
+  }
+  /** Scroll to absolute page coordinates. */
+  async scrollToPoint(x, y) {
+    await this.adapter.evaluate(`window.scrollTo(${x}, ${y})`);
+  }
+  // -------------------------------------------------------------------
+  // Wait
+  // -------------------------------------------------------------------
+  /** Wait for a CSS selector to appear in the DOM. */
+  async waitForSelector(selector, timeoutMs = 5e3) {
+    const interval = 100;
+    const maxIter = Math.ceil(timeoutMs / interval);
+    const checkJs = `!!document.querySelector(${JSON.stringify(selector)})`;
+    for (let i = 0; i < maxIter; i++) {
+      const found = await this.adapter.evaluate(checkJs);
+      if (found) return;
+      await sleep2(interval);
+    }
+    throw new TimeoutError(`Timeout waiting for selector: ${selector}`);
+  }
+  /** Wait for navigation/page load (simple delay). */
+  async waitForNavigation(timeoutMs = 5e3) {
+    await sleep2(Math.min(timeoutMs, 1e3));
+  }
+  /**
+   * Wait until the page is fully loaded and DOM is stable.
+   *
+   * Checks:
+   * 1. document.readyState === 'complete'
+   * 2. DOM content length stabilizes (no changes for 500ms)
+   *
+   * Use after goto() for SPAs and dynamic pages to ensure all
+   * content is rendered before extracting HTML.
+   */
+  async waitForReady(timeoutMs = 1e4) {
+    const start = Date.now();
+    const pollInterval = 200;
+    const stableThreshold = 500;
+    while (Date.now() - start < timeoutMs) {
+      const state = await this.adapter.evaluate("document.readyState");
+      if (state === "complete") break;
+      await sleep2(pollInterval);
+    }
+    let lastLength = 0;
+    let stableSince = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      const length = await this.adapter.evaluate(
+        "document.documentElement.innerHTML.length"
+      );
+      if (length !== lastLength) {
+        lastLength = length;
+        stableSince = Date.now();
+      } else if (Date.now() - stableSince >= stableThreshold) {
+        return;
+      }
+      await sleep2(pollInterval);
+    }
+  }
+  /**
+   * Wait until page content exceeds a minimum length.
+   * Useful for SPAs where content loads asynchronously.
+   */
+  async waitForContent(minLength = 500, timeoutMs = 8e3) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      const length = await this.adapter.evaluate(
+        "document.documentElement.innerHTML.length"
+      );
+      if (length >= minLength) return;
+      await sleep2(200);
+    }
+  }
+  /**
+   * Wait for network idle + DOM stability (cross-platform).
+   *
+   * Uses the Performance/Resource Timing API and MutationObserver
+   * (works in both Chrome/CDP and Firefox/BiDi) to detect when:
+   * 1. document.readyState === 'complete'
+   * 2. No new network resources loading (PerformanceObserver)
+   * 3. DOM mutations have settled
+   *
+   * This is more comprehensive than waitForReady() — it also
+   * catches lazy-loaded images, XHR/fetch requests, and script-injected content.
+   */
+  async waitForNetworkIdle(timeoutMs = 8e3) {
+    const start = Date.now();
+    const pollInterval = 250;
+    while (Date.now() - start < timeoutMs) {
+      const state = await this.adapter.evaluate("document.readyState");
+      if (state === "complete") break;
+      await sleep2(pollInterval);
+    }
+    const idleMs = 400;
+    const remaining = Math.max(1e3, timeoutMs - (Date.now() - start));
+    try {
+      await this.adapter.evaluate(`
+        new Promise((resolve) => {
+          let lastActivity = Date.now();
+          const idleThreshold = ${idleMs};
+          const deadline = Date.now() + ${remaining};
+
+          // Track resource loads
+          const perfObs = new PerformanceObserver(() => { lastActivity = Date.now(); });
+          try { perfObs.observe({ entryTypes: ['resource'] }); } catch(e) {}
+
+          // Track DOM mutations
+          const mutObs = new MutationObserver(() => { lastActivity = Date.now(); });
+          mutObs.observe(document.documentElement, {
+            childList: true, subtree: true, attributes: true
+          });
+
+          const check = () => {
+            const now = Date.now();
+            if (now >= deadline || (now - lastActivity >= idleThreshold)) {
+              perfObs.disconnect();
+              mutObs.disconnect();
+              resolve(true);
+              return;
+            }
+            setTimeout(check, 100);
+          };
+          setTimeout(check, idleThreshold);
+        })
+      `);
+    } catch {
+      await sleep2(500);
+    }
+  }
+  // -------------------------------------------------------------------
+  // Viewport
+  // -------------------------------------------------------------------
+  /** Set the viewport dimensions. */
+  async setViewport(width, height, deviceScaleFactor = 2, mobile = false) {
+    await this.adapter.setViewport(width, height, deviceScaleFactor, mobile);
+  }
+  // -------------------------------------------------------------------
+  // DOM Queries
+  // -------------------------------------------------------------------
+  /** Query a single element and return its outer HTML. */
+  async querySelector(selector) {
+    return await this.adapter.evaluate(
+      `document.querySelector(${JSON.stringify(selector)})?.outerHTML ?? null`
+    );
+  }
+  /** Query all matching elements and return their outer HTML. */
+  async querySelectorAll(selector) {
+    return await this.adapter.evaluate(`
+      Array.from(document.querySelectorAll(${JSON.stringify(selector)})).map(el => el.outerHTML)
+    `);
+  }
+  /** Get text content of an element. */
+  async textContent(selector) {
+    return await this.adapter.evaluate(
+      `document.querySelector(${JSON.stringify(selector)})?.textContent ?? null`
+    );
+  }
+  // -------------------------------------------------------------------
+  // Internals
+  // -------------------------------------------------------------------
+  /** Get the center coordinates of a DOM element (scrolls into view first). */
+  async getElementCenter(selector) {
+    const result = await this.adapter.evaluate(`
+      (function() {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!el) return null;
+        el.scrollIntoView({ block: 'center', behavior: 'instant' });
+        const r = el.getBoundingClientRect();
+        return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
+      })()
+    `);
+    if (!result) {
+      throw new Error(`Element not found: ${selector}`);
+    }
+    return result;
+  }
+  /** @internal Replace the adapter (used during browser switching). */
+  _setAdapter(adapter) {
+    this.adapter = adapter;
+  }
+  /**
+   * Detect challenge interstitials that may auto-resolve (e.g. Cloudflare "Just a moment...").
+   * These pages show briefly before redirecting to the real content.
+   */
+  isInterstitialContent(html) {
+    if (html.length > 15e3) return false;
+    const lower = html.toLowerCase();
+    return lower.includes("just a moment") || lower.includes("checking your browser") || lower.includes("please wait while we verify") || lower.includes("ddos-guard") || lower.includes("challenge-platform");
+  }
+  /**
+   * Detect site-level rate limiting in page content.
+   * Browser rotation gives a new profile which bypasses per-session rate limits.
+   */
+  isRateLimitContent(html) {
+    if (html.length > 2e4) return false;
+    const lower = html.toLowerCase();
+    return lower.includes("rate limit exceeded") || lower.includes("too many requests") || lower.includes("rate limit") && lower.includes("please try again");
+  }
+};
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// retry/failure-tracker.ts
+var FAILURE_TTL_MS = 10 * 60 * 1e3;
+var ROTATE_AFTER_FAILURES = 2;
+var FailureTracker = class {
+  failures = /* @__PURE__ */ new Map();
+  key(domain, browser) {
+    return `${domain}::${browser}`;
+  }
+  /** Record a failure for a domain + browser. */
+  recordFailure(domain, browser) {
+    const k = this.key(domain, browser);
+    const existing = this.failures.get(k);
+    if (existing) {
+      existing.count++;
+      existing.lastFailure = Date.now();
+    } else {
+      this.failures.set(k, { count: 1, lastFailure: Date.now() });
+    }
+  }
+  /** Record a success — clears the failure counter. */
+  recordSuccess(domain, browser) {
+    this.failures.delete(this.key(domain, browser));
+  }
+  /** Get failure count (0 if expired or not found). */
+  failureCount(domain, browser) {
+    const record = this.failures.get(this.key(domain, browser));
+    if (!record) return 0;
+    if (Date.now() - record.lastFailure > FAILURE_TTL_MS) {
+      this.failures.delete(this.key(domain, browser));
+      return 0;
+    }
+    return record.count;
+  }
+  /** Get total failures across all browsers for a domain. */
+  totalFailureCount(domain) {
+    let total = 0;
+    for (const [key, record] of this.failures) {
+      if (key.startsWith(`${domain}::`)) {
+        if (Date.now() - record.lastFailure < FAILURE_TTL_MS) {
+          total += record.count;
+        }
+      }
+    }
+    return total;
+  }
+  /** Clear all failure records for a domain (used on stealth escalation). */
+  clear(domain) {
+    for (const key of this.failures.keys()) {
+      if (key.startsWith(`${domain}::`)) {
+        this.failures.delete(key);
+      }
+    }
+  }
+  /** Clean expired entries. */
+  cleanup() {
+    const now = Date.now();
+    for (const [key, record] of this.failures) {
+      if (now - record.lastFailure > FAILURE_TTL_MS) {
+        this.failures.delete(key);
+      }
+    }
+  }
+};
+
+// retry/browser-selector.ts
+var PRIMARY_ROTATION = [
+  "chrome",
+  "chrome-new"
+];
+var EXTENDED_ROTATION = [];
+var BROWSER_ROTATION = [
+  ...PRIMARY_ROTATION,
+  ...EXTENDED_ROTATION
+];
+var BrowserSelector = class {
+  tracker;
+  rotationIndex = 0;
+  constructor(tracker) {
+    this.tracker = tracker;
+  }
+  /** Get the current failure tracker. */
+  get failureTracker() {
+    return this.tracker;
+  }
+  /**
+   * Check if the current browser should be rotated for a domain.
+   */
+  shouldRotate(domain, currentBrowser) {
+    return this.tracker.failureCount(domain, currentBrowser) >= ROTATE_AFTER_FAILURES;
+  }
+  /**
+   * Pick the next browser to try, given the current one has failed.
+   * Returns the next browser in rotation that hasn't exceeded the failure threshold.
+   * Returns null if all browsers have been exhausted.
+   */
+  nextBrowser(domain, currentBrowser) {
+    const currentIdx = BROWSER_ROTATION.indexOf(currentBrowser);
+    for (let offset = 1; offset < BROWSER_ROTATION.length; offset++) {
+      const idx = (currentIdx + offset) % BROWSER_ROTATION.length;
+      const candidate = BROWSER_ROTATION[idx];
+      if (this.tracker.failureCount(domain, candidate) < ROTATE_AFTER_FAILURES) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+  /**
+   * Choose the best browser for a domain (mirrors hints.rs choose_browser_for_domain).
+   * Uses failure history to skip browsers that have been failing.
+   */
+  chooseBrowser(domain, fallback) {
+    for (const browser of BROWSER_ROTATION) {
+      if (this.tracker.failureCount(domain, browser) < ROTATE_AFTER_FAILURES) {
+        return browser;
+      }
+    }
+    return fallback;
+  }
+};
+
+// retry/retry-engine.ts
+init_errors();
+
+// retry/keyword-classifier.ts
+var KeywordClassifier = class {
+  root;
+  constructor(rules) {
+    this.root = { children: /* @__PURE__ */ new Map(), output: void 0, fail: void 0, dict: void 0 };
+    for (const [keywords, cls] of rules) {
+      for (const kw of keywords) {
+        this.insert(kw.toLowerCase(), cls);
+      }
+    }
+    this.buildFailureLinks();
+  }
+  /**
+   * Classify a string by scanning it once for all keywords.
+   * Returns the classification of the highest-priority matching keyword, or undefined.
+   */
+  classify(text) {
+    let node = this.root;
+    for (let i = 0; i < text.length; i++) {
+      let ch = text.charCodeAt(i);
+      if (ch >= 65 && ch <= 90) ch += 32;
+      while (node !== this.root && !node.children.has(ch)) {
+        node = node.fail;
+      }
+      node = node.children.get(ch) ?? this.root;
+      if (node.output !== void 0) return node.output;
+      if (node.dict !== void 0 && node.dict.output !== void 0) {
+        return node.dict.output;
+      }
+    }
+    return void 0;
+  }
+  insert(word, cls) {
+    let node = this.root;
+    for (let i = 0; i < word.length; i++) {
+      const ch = word.charCodeAt(i);
+      let child = node.children.get(ch);
+      if (!child) {
+        child = { children: /* @__PURE__ */ new Map(), output: void 0, fail: void 0, dict: void 0 };
+        node.children.set(ch, child);
+      }
+      node = child;
+    }
+    if (node.output === void 0) {
+      node.output = cls;
+    }
+  }
+  buildFailureLinks() {
+    const queue = [];
+    for (const child of this.root.children.values()) {
+      child.fail = this.root;
+      child.dict = this.root;
+      queue.push(child);
+    }
+    let head = 0;
+    while (head < queue.length) {
+      const node = queue[head++];
+      for (const [ch, child] of node.children) {
+        let fail = node.fail;
+        while (fail !== this.root && !fail.children.has(ch)) {
+          fail = fail.fail;
+        }
+        child.fail = fail.children.get(ch) ?? this.root;
+        if (child.fail === child) child.fail = this.root;
+        child.dict = child.fail.output !== void 0 ? child.fail : child.fail.dict ?? void 0;
+        queue.push(child);
+      }
+    }
+  }
+};
+
+// retry/retry-engine.ts
+var errorClassifier = new KeywordClassifier([
+  // Blocked — checked first (most common heuristic case)
+  // NOTE: err_aborted is NOT here — it's handled specially in classifyError().
+  // Server already retries ERR_ABORTED internally; when it reaches the client,
+  // it's usually session interference (shared Chrome) not actual blocking.
+  // Reconnecting (new session) is the right fix, not stealth escalation.
+  [[
+    "bot detect",
+    "are you a robot",
+    "blocked",
+    "403",
+    "captcha",
+    "network security",
+    "human verification",
+    "verify you are human",
+    "checking your browser",
+    "bot protection",
+    "automated access",
+    "pardon our interruption",
+    "powered and protected by",
+    "request could not be processed",
+    "access to this page has been denied",
+    "access denied",
+    "please complete the security check",
+    "enable cookies",
+    "browser check",
+    "just a moment",
+    "rate limit exceeded",
+    "too many requests",
+    "err_blocked_by_client"
+  ], "blocked"],
+  // Auth
+  [["401", "402", "unauthorized"], "auth"],
+  // Backend down
+  [["backend unavailable", "no backend", "service unavailable", "503", "failed to create page target", "unexpected server response"], "backend_down"],
+  // Transient (connection)
+  [["err_connection_reset", "err_connection_closed", "err_empty_response", "err_ssl_protocol_error", "err_ssl_version_or_cipher_mismatch", "err_cert", "timeout"], "transient"],
+  // Transient (WebSocket / session)
+  [["websocket is not connected", "websocket closed", "session with given id not found", "content contamination", "insufficient content"], "transient"]
+]);
+var disconnectionClassifier = new KeywordClassifier([
+  // NOT disconnections (page-level) — checked first
+  // NOTE: err_aborted is intentionally NOT here — at high concurrency it's
+  // usually session interference (shared Chrome process), so reconnecting
+  // (new session) is the correct fix. For NavigationError, undefined → true.
+  [["err_blocked_by_client"], false],
+  // Actual disconnections (socket hang up = server killed the connection)
+  // Content contamination = shared Chrome leaked another session's content → new session fixes it
+  [[
+    "websocket is not connected",
+    "websocket closed",
+    "session destroyed",
+    "session with given id not found",
+    "err_connection_reset",
+    "err_connection_closed",
+    "err_empty_response",
+    "socket hang up",
+    "err_aborted",
+    "content contamination",
+    "insufficient content",
+    "err_ssl_protocol_error",
+    "err_ssl_version_or_cipher_mismatch"
+  ], true]
+]);
+var RetryEngine = class {
+  opts;
+  selector;
+  currentStealthLevel;
+  maxStealthLevel;
+  retryTimeoutMs;
+  commandTimeoutMs;
+  /** Browser backends that returned 503/unavailable — persists across stealth levels. */
+  downBackends = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    this.opts = opts;
+    this.selector = new BrowserSelector(new FailureTracker());
+    this.currentStealthLevel = opts.transportOpts.stealthLevel ?? 0;
+    this.maxStealthLevel = opts.maxStealthLevel ?? 3;
+    this.retryTimeoutMs = opts.retryTimeoutMs ?? 15e3;
+    this.commandTimeoutMs = opts.commandTimeoutMs ?? 3e4;
+  }
+  /** Current stealth level (0=auto, 1-3=explicit tiers). */
+  get stealthLevel() {
+    return this.currentStealthLevel;
+  }
+  /**
+   * Execute an action with stealth-first retry across browsers and stealth levels.
+   *
+   * Phase 1: Escalate stealth across primary browsers (chrome, chrome-new).
+   * Blocked errors skip remaining primary browsers and immediately escalate stealth.
+   *
+   * Phase 2: At max stealth only, try extended browsers (firefox, lightpanda, servo)
+   * for a different engine fingerprint with the best proxy quality.
+   */
+  async execute(fn, ctx) {
+    let lastError;
+    let totalAttempts = 0;
+    const budget = this.opts.maxRetries + 1;
+    this.downBackends.clear();
+    const stealthLevels = this.getStealthProgression();
+    const initialBrowser = ctx.transport.browser;
+    let consecutiveDisconnects = 0;
+    let wasBlocked = false;
+    for (let si = 0; si < stealthLevels.length; si++) {
+      if (totalAttempts >= budget) break;
+      const stealth = stealthLevels[si];
+      if (si > 0) {
+        const prev = stealthLevels[si - 1];
+        this.currentStealthLevel = stealth;
+        ctx.transport.stealthLevel = stealth;
+        logger.info(`retry: escalating stealth ${prev} -> ${stealth}`);
+        this.opts.emitter.emit("stealth.escalated", {
+          from: prev,
+          to: stealth,
+          reason: lastError ? this.classifyError(lastError) : "exhausted"
+        });
+        const domain = this.extractDomain(ctx.currentUrl);
+        if (domain) this.selector.failureTracker.clear(domain);
+      }
+      const primaryBrowsers = si === 0 ? this.orderedPrimaryBrowsers(initialBrowser) : [...PRIMARY_ROTATION];
+      let triedAny = false;
+      for (const browser of primaryBrowsers) {
+        if (totalAttempts >= budget) break;
+        if (this.downBackends.has(browser)) continue;
+        if (consecutiveDisconnects >= 6) {
+          logger.warn("retry: 6+ consecutive disconnects, server overloaded \u2014 aborting");
+          break;
+        }
+        const result = await this.tryBrowser(fn, ctx, browser, stealth, totalAttempts, budget, true);
+        totalAttempts = result.totalAttempts;
+        if (result.success) {
+          consecutiveDisconnects = 0;
+          return result.value;
+        }
+        if (result.triedAction) triedAny = true;
+        if (result.lastError) {
+          lastError = result.lastError;
+          const errorClass = this.classifyError(lastError);
+          wasBlocked = errorClass === "blocked";
+          if (errorClass === "auth") throw lastError;
+          if (this.isDisconnectionError(lastError)) {
+            consecutiveDisconnects++;
+          } else {
+            consecutiveDisconnects = 0;
+          }
+          if (wasBlocked) break;
+        }
+      }
+      if (!triedAny) {
+        logger.warn("retry: all browser backends unavailable, stopping");
+        break;
+      }
+    }
+    if (wasBlocked && totalAttempts < budget) {
+      for (const browser of EXTENDED_ROTATION) {
+        if (totalAttempts >= budget) break;
+        if (this.downBackends.has(browser)) continue;
+        const maxStealth = stealthLevels[stealthLevels.length - 1] ?? this.maxStealthLevel;
+        const result = await this.tryBrowser(fn, ctx, browser, maxStealth, totalAttempts, budget, false);
+        totalAttempts = result.totalAttempts;
+        if (result.success) return result.value;
+        if (result.lastError) {
+          lastError = result.lastError;
+          if (this.classifyError(lastError) === "auth") throw lastError;
+        }
+      }
+    }
+    throw lastError ?? new Error("All browsers and stealth levels exhausted");
+  }
+  /**
+   * Attempt an action on a specific browser, with optional transient retries.
+   *
+   * @param allowTransientRetries If true, retries up to 2x for transient errors
+   *   (reconnect + retry). If false, a single attempt only (for extended browsers).
+   */
+  async tryBrowser(fn, ctx, browser, stealth, totalAttempts, budget, allowTransientRetries) {
+    let lastError;
+    if (totalAttempts > 0) {
+      try {
+        const prevBrowser = ctx.transport.browser;
+        logger.info(`retry: switching ${prevBrowser} -> ${browser} (stealth=${stealth})`);
+        this.opts.emitter.emit("browser.switching", {
+          from: prevBrowser,
+          to: browser,
+          reason: lastError ? this.classifyError(lastError) : "rotation"
+        });
+        const prevTimeout = this.opts.transportOpts.connectTimeoutMs;
+        this.opts.transportOpts.connectTimeoutMs = this.retryTimeoutMs;
+        await this.switchBrowser(ctx, browser);
+        this.opts.transportOpts.connectTimeoutMs = prevTimeout;
+        this.opts.emitter.emit("browser.switched", { browser });
+      } catch (switchErr) {
+        logger.warn(`retry: switch to ${browser} failed, skipping`, {
+          error: switchErr instanceof Error ? switchErr.message : String(switchErr)
+        });
+        if (switchErr instanceof BackendUnavailableError) {
+          this.downBackends.add(browser);
+        }
+        return { success: false, totalAttempts, triedAction: false, lastError: switchErr instanceof Error ? switchErr : void 0 };
+      }
+    }
+    const MAX_TRANSIENT_RETRIES = allowTransientRetries ? 2 : 0;
+    const MAX_DISCONNECT_RETRIES = allowTransientRetries ? 2 : 0;
+    let transientRetries = 0;
+    let disconnectRetries = 0;
+    while (totalAttempts < budget) {
+      totalAttempts++;
+      try {
+        const result = await fn();
+        const domain = this.extractDomain(ctx.currentUrl);
+        if (domain) this.selector.failureTracker.recordSuccess(domain, browser);
+        return { success: true, value: result, totalAttempts, triedAction: true };
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        const errorClass = this.classifyError(lastError);
+        logger.warn(`retry: attempt ${totalAttempts}/${budget} failed`, {
+          error: lastError.message,
+          class: errorClass,
+          browser,
+          stealth
+        });
+        this.opts.emitter.emit("retry.attempt", {
+          attempt: totalAttempts,
+          maxRetries: this.opts.maxRetries,
+          error: lastError.message
+        });
+        if (errorClass === "auth") {
+          return { success: false, totalAttempts, triedAction: true, lastError };
+        }
+        if (errorClass === "rate_limit") {
+          const waitMs = lastError instanceof RateLimitError && lastError.retryAfterMs ? lastError.retryAfterMs : 2e3;
+          await sleep3(waitMs);
+          continue;
+        }
+        if (errorClass === "backend_down") {
+          this.downBackends.add(browser);
+          return { success: false, totalAttempts, triedAction: true, lastError };
+        }
+        if (errorClass === "blocked") {
+          const domain2 = this.extractDomain(ctx.currentUrl);
+          if (domain2) this.selector.failureTracker.recordFailure(domain2, browser);
+          return { success: false, totalAttempts, triedAction: true, lastError };
+        }
+        if (errorClass === "transient" && this.isDisconnectionError(lastError)) {
+          if (disconnectRetries < MAX_DISCONNECT_RETRIES) {
+            disconnectRetries++;
+            await sleep3(500);
+            try {
+              await this.switchBrowser(ctx, browser);
+            } catch {
+              const domain3 = this.extractDomain(ctx.currentUrl);
+              if (domain3) this.selector.failureTracker.recordFailure(domain3, browser);
+              return { success: false, totalAttempts, triedAction: true, lastError };
+            }
+            continue;
+          }
+          const domain2 = this.extractDomain(ctx.currentUrl);
+          if (domain2) this.selector.failureTracker.recordFailure(domain2, browser);
+          return { success: false, totalAttempts, triedAction: true, lastError };
+        }
+        if (errorClass === "transient" && transientRetries < MAX_TRANSIENT_RETRIES) {
+          transientRetries++;
+          await sleep3(100);
+          continue;
+        }
+        const domain = this.extractDomain(ctx.currentUrl);
+        if (domain) this.selector.failureTracker.recordFailure(domain, browser);
+        return { success: false, totalAttempts, triedAction: true, lastError };
+      }
+    }
+    return { success: false, totalAttempts, triedAction: true, lastError };
+  }
+  /** Check if an error indicates the WebSocket/session is dead and needs reconnection. */
+  isDisconnectionError(err) {
+    if (err instanceof NavigationError) {
+      const result = disconnectionClassifier.classify(err.message);
+      return result !== false;
+    }
+    return disconnectionClassifier.classify(err.message) === true;
+  }
+  /**
+   * Classify an error to determine retry strategy.
+   *
+   * Fast path: typed error instances (instanceof check, no string scan).
+   * Slow path: Aho-Corasick O(n) single-pass keyword matching on error message.
+   */
+  classifyError(err) {
+    if (err instanceof AuthError) return "auth";
+    if (err instanceof RateLimitError) return "rate_limit";
+    if (err instanceof BlockedError) return "blocked";
+    if (err instanceof BackendUnavailableError) return "backend_down";
+    if (err instanceof TimeoutError) return "transient";
+    if (err instanceof ConnectionError) {
+      const code = err.wsCode;
+      if (code === 1006 || code === 1011) return "transient";
+      if (code === 4001 || code === 4002) return "auth";
+      return "transient";
+    }
+    if (err instanceof NavigationError) {
+      const cls2 = errorClassifier.classify(err.message);
+      return cls2 === "blocked" ? "blocked" : "transient";
+    }
+    const cls = errorClassifier.classify(err.message);
+    if (cls) return cls;
+    if (err.message.includes("429")) return "rate_limit";
+    return "transient";
+  }
+  /** Reconnect with a (possibly different) browser, re-navigate to the same URL. */
+  async switchBrowser(ctx, newBrowser) {
+    ctx.adapter.destroy();
+    await ctx.transport.reconnect(newBrowser);
+    const adapterOpts = this.commandTimeoutMs !== 3e4 ? { commandTimeoutMs: this.commandTimeoutMs } : void 0;
+    const newAdapter = new ProtocolAdapter(
+      ctx.transport,
+      this.opts.emitter,
+      newBrowser,
+      adapterOpts
+    );
+    await newAdapter.init();
+    ctx.adapter = newAdapter;
+    ctx.onAdapterChanged(newAdapter);
+    if (ctx.currentUrl) {
+      await newAdapter.navigate(ctx.currentUrl);
+      await sleep3(200);
+    }
+  }
+  /**
+   * Get stealth progression: from current level up to maxStealthLevel.
+   * e.g. start=0, max=3 → [0, 1, 2, 3]
+   * e.g. start=2, max=3 → [2, 3]
+   */
+  getStealthProgression() {
+    const start = this.currentStealthLevel;
+    const levels = [start];
+    let next = start < 1 ? 1 : start + 1;
+    while (next <= this.maxStealthLevel) {
+      levels.push(next);
+      next++;
+    }
+    return levels;
+  }
+  /**
+   * Order PRIMARY browsers starting from `start`, then the rest in primary rotation order.
+   * If `start` is not in PRIMARY_ROTATION, returns primary rotation as-is.
+   */
+  orderedPrimaryBrowsers(start) {
+    const idx = PRIMARY_ROTATION.indexOf(start);
+    if (idx <= 0) return [...PRIMARY_ROTATION];
+    return [
+      ...PRIMARY_ROTATION.slice(idx),
+      ...PRIMARY_ROTATION.slice(0, idx)
+    ];
+  }
+  extractDomain(url) {
+    if (!url) return void 0;
+    try {
+      return new URL(url).hostname;
+    } catch {
+      return void 0;
+    }
+  }
+};
+function sleep3(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// ai/llm-provider.ts
+function createProvider(config) {
+  switch (config.provider) {
+    case "openai":
+    case "openrouter": {
+      const { OpenAICompatibleProvider: OpenAICompatibleProvider2 } = (init_openai(), __toCommonJS(openai_exports));
+      return new OpenAICompatibleProvider2(config);
+    }
+    case "anthropic": {
+      const { AnthropicProvider: AnthropicProvider2 } = (init_anthropic(), __toCommonJS(anthropic_exports));
+      return new AnthropicProvider2(config);
+    }
+    default:
+      throw new Error(`Unknown LLM provider: ${config.provider}`);
+  }
+}
+
+// ai/prompts.ts
+var SYSTEM_PROMPT = `You are an expert web automation agent. You interact with any webpage to solve challenges, fill forms, navigate sites, extract data, and complete complex multi-step tasks.
+
+## Input
+Each round you receive:
+- Screenshot of current page state
+- URL, title, HTML context
+- Round number and detected challenge types
+
+## Output
+Return a single JSON object (no prose):
+{
+  "label": "brief action description",
+  "done": true|false,
+  "steps": [...]
+}
+Set "done": true when the task is fully complete. Set "done": false to continue.
+
+## Coordinate System
+**ClickPoint coordinates use CSS pixels** (same as getBoundingClientRect()).
+- Screenshot pixels = viewport x DPR. Divide screenshot coordinates by DPR for CSS pixels.
+- Example: viewport 1280x960 at DPR 2 = screenshot 2560x1920. Visual point (500,400) in screenshot = (250,200) CSS.
+
+## Actions
+
+### Click
+- { "Click": "selector" } - CSS selector click
+- { "ClickPoint": { "x": 100, "y": 200 } } - CSS pixel coordinates
+- { "ClickAll": "selector" } - Click all matches
+- { "DoubleClick": "selector" } / { "DoubleClickPoint": { "x": 0, "y": 0 } }
+- { "RightClick": "selector" } / { "RightClickPoint": { "x": 0, "y": 0 } }
+- { "ClickHold": { "selector": "sel", "hold_ms": 500 } } / { "ClickHoldPoint": { "x": 0, "y": 0, "hold_ms": 500 } }
+- { "WaitForAndClick": "selector" }
+
+### Drag
+- { "ClickDrag": { "from": "sel1", "to": "sel2" } }
+- { "ClickDragPoint": { "from_x": 0, "from_y": 0, "to_x": 100, "to_y": 100 } }
+
+### Type & Input
+- { "Fill": { "selector": "input", "value": "text" } } - Clear and type
+- { "Type": { "value": "text" } } - Type into focused element
+- { "Clear": "selector" } - Clear input
+- { "Press": "Enter" } - Press key (Enter, Tab, Escape, ArrowDown, Space, etc.)
+- { "KeyDown": "Shift" } / { "KeyUp": "Shift" }
+
+### Select & Focus
+- { "Select": { "selector": "select", "value": "option" } }
+- { "Focus": "selector" } / { "Blur": "selector" }
+- { "Hover": "selector" } / { "HoverPoint": { "x": 0, "y": 0 } }
+
+### Scroll
+- { "ScrollY": 300 } - Scroll down (negative = up)
+- { "ScrollX": 200 } - Scroll right (negative = left)
+- { "ScrollTo": { "selector": "element" } } - Scroll element into view
+- { "ScrollToPoint": { "x": 0, "y": 500 } }
+- { "InfiniteScroll": 5 } - Scroll to bottom repeatedly
+
+### Wait
+- { "Wait": 1000 } - Wait milliseconds
+- { "WaitFor": "selector" } - Wait for element
+- { "WaitForWithTimeout": { "selector": "sel", "timeout": 5000 } }
+- { "WaitForNavigation": null } - Wait for page load
+- { "WaitForDom": { "selector": "sel", "timeout": 5000 } }
+
+### Navigate
+- { "Navigate": "https://url" } - Go to URL
+- { "GoBack": null } / { "GoForward": null } / { "Reload": null }
+
+### Viewport
+- { "SetViewport": { "width": 1920, "height": 1080, "device_scale_factor": 2.0 } } - Change viewport/DPR at runtime. Follow with { "Wait": 500 }.
+
+### JavaScript
+- { "Evaluate": "javascript code" } - Execute JS on the page
+
+**Evaluate notes:**
+- Return values are NOT sent back. To see results, inject into the page:
+  - Title: document.title = JSON.stringify(data) (visible in PAGE TITLE next round)
+  - DOM: inject a visible overlay div with the info (visible in screenshot)
+- **Do NOT use element.click() in Evaluate** - it does not trigger real browser events (mousedown/pointerdown). Always use real Click/ClickPoint actions for interactions.
+- **Always pair Evaluate with action steps** in the same round. Never submit a round with ONLY Evaluate.
+
+## Core Strategy
+
+1. **Be efficient**: Solve challenges in the fewest rounds possible. Combine Evaluate (read state) + action (click/fill) in the SAME round. Never spend a round only gathering data.
+2. **Batch operations**: When you need to click/select multiple elements, include multiple Click actions in a single step list rather than spreading across multiple rounds.
+3. **Evaluate = READ ONLY**: Use Evaluate to read DOM state, computed styles, coordinates. Set results in document.title. NEVER use el.click() inside Evaluate - it does NOT trigger real browser events. Use real Click/ClickPoint for all interactions.
+4. **Prefer selectors over coordinates**: Use CSS selectors when elements exist in DOM. Reserve ClickPoint for canvas/SVG or when selectors fail.
+5. **Handle stagnation**: If your last actions had no visible effect, try a different approach - different selector, different interaction method, or use Evaluate to understand why.
+6. **Never repeat failures**: If something fails twice, change strategy entirely. If verify/submit doesn't advance, your answer is likely wrong - re-examine.
+7. **Commit and iterate**: Submit your best answer rather than endlessly adjusting. Learn from the result.
+
+## Captcha & Challenge Strategies
+
+- **reCAPTCHA checkbox**: Click the iframe first, then the checkbox inside it.
+- **Cloudflare Turnstile**: The challenge is in an iframe. Look for \`iframe[src*="challenges.cloudflare.com"]\` and click inside it.
+- **Image selection (reCAPTCHA v2)**: Identify matching images and click them one at a time. After selecting, click the verify button. If incorrect, the grid refreshes - try again.
+- **Slider/puzzle captchas**: Use ClickDragPoint to drag the slider from start to end position.
+- **Text captchas**: Read the distorted text carefully, then Fill the answer input and Press Enter.
+- **Visual puzzles**: Describe what you see, reason about the solution, then act precisely.
+- **PerimeterX (px-captcha)**: This is a press-and-hold captcha. Find the button element inside the #px-captcha container or iframe with [role="button"]. Use ClickHold with hold_ms: 15000 (15 seconds). Wait for the captcha wrapper to disappear after release.
+- **DataDome**: Often shows an iframe from geo.captcha-delivery.com. Click inside the iframe to interact with the challenge. May include slider or image selection.
+- **Arkose Labs / FunCaptcha**: Interactive challenge in an iframe from arkoselabs.com. Follow on-screen instructions \u2014 typically image rotation, matching, or selection puzzles.
+- **Cookie/consent banners**: Click accept/dismiss buttons to clear overlays before solving the actual captcha.
+- **Multiple challenge steps**: Some captchas have multiple rounds (e.g., reCAPTCHA may ask to solve 3 image grids). Keep going until done.
+
+## Output Rules
+- JSON only, no markdown or prose
+- Always include "label", "done", and "steps"
+- "steps" array can have multiple actions per round`;
+function buildUserMessage(url, html, screenshotB64, extraContext) {
+  const truncatedHtml = truncateHtml(html, 12e3);
+  const userText = `URL: ${url}
+HTML (truncated):
+${truncatedHtml}
+
+${extraContext ?? "Complete the task on this page."}`;
+  return [
+    { type: "text", text: userText },
+    {
+      type: "image_url",
+      image_url: { url: `data:image/png;base64,${screenshotB64}` }
+    }
+  ];
+}
+function truncateHtml(html, maxChars) {
+  if (html.length <= maxChars) return html;
+  const slice = html.slice(0, maxChars);
+  const lastClose = slice.lastIndexOf(">");
+  return lastClose > 0 ? html.slice(0, lastClose + 1) : slice;
+}
+
+// ai/agent.ts
+init_errors();
+var Agent = class {
+  adapter;
+  llm;
+  emitter;
+  opts;
+  constructor(adapter, llm, emitter, options) {
+    this.adapter = adapter;
+    this.llm = llm;
+    this.emitter = emitter;
+    this.opts = {
+      maxRounds: options?.maxRounds ?? 30,
+      stepDelayMs: options?.stepDelayMs ?? 1500,
+      instruction: options?.instruction
+    };
+  }
+  /**
+   * Execute the agent loop until the task is done or max rounds reached.
+   */
+  async execute(instruction) {
+    let extracted = void 0;
+    let lastLabel = "";
+    await sleep4(500);
+    for (let round = 0; round < this.opts.maxRounds; round++) {
+      let screenshot;
+      try {
+        screenshot = await this.adapter.captureScreenshot();
+      } catch (err) {
+        logger.warn(`agent: screenshot failed round ${round}`, {
+          error: err instanceof Error ? err.message : String(err)
+        });
+        break;
+      }
+      let html;
+      try {
+        html = await this.adapter.getHTML();
+      } catch (err) {
+        logger.warn(`agent: get HTML failed round ${round}`, {
+          error: err instanceof Error ? err.message : String(err)
+        });
+        break;
+      }
+      const [url, title] = await Promise.all([
+        this.adapter.evaluate("window.location.href").catch(() => "unknown"),
+        this.adapter.evaluate("document.title").catch(() => "")
+      ]);
+      const context = `Round ${round + 1}/${this.opts.maxRounds}. Task: ${instruction}
+PAGE TITLE: ${title}`;
+      let plan;
+      try {
+        plan = await this.llm.chatJSON([
+          { role: "system", content: SYSTEM_PROMPT },
+          {
+            role: "user",
+            content: buildUserMessage(url, html, screenshot, context)
+          }
+        ]);
+      } catch (err) {
+        logger.warn(`agent: LLM call failed round ${round}`, {
+          error: err instanceof Error ? err.message : String(err)
+        });
+        await sleep4(2e3);
+        continue;
+      }
+      lastLabel = plan.label ?? "";
+      if (plan.extracted !== void 0) {
+        extracted = plan.extracted;
+      }
+      logger.info(`agent: round ${round + 1}`, {
+        label: plan.label,
+        done: plan.done,
+        steps: plan.steps?.length ?? 0
+      });
+      this.emitter.emit("agent.step", {
+        round: round + 1,
+        label: plan.label,
+        stepsCount: plan.steps?.length ?? 0
+      });
+      if (plan.done) {
+        this.emitter.emit("agent.done", { rounds: round + 1, result: extracted });
+        return { done: true, rounds: round + 1, extracted, label: lastLabel };
+      }
+      if (!plan.steps || plan.steps.length === 0) {
+        logger.info("agent: no steps, retrying");
+        await sleep4(this.opts.stepDelayMs);
+        continue;
+      }
+      for (let i = 0; i < plan.steps.length; i++) {
+        const action = plan.steps[i];
+        try {
+          await executeAction(this.adapter, action);
+        } catch (err) {
+          logger.warn(`agent: action failed round ${round} step ${i}`, {
+            action: JSON.stringify(action).slice(0, 100),
+            error: err instanceof Error ? err.message : String(err)
+          });
+          break;
+        }
+        await sleep4(200);
+      }
+      await sleep4(this.opts.stepDelayMs);
+    }
+    logger.warn("agent: max rounds exceeded");
+    this.emitter.emit("agent.error", {
+      error: "max rounds exceeded",
+      round: this.opts.maxRounds
+    });
+    return { done: false, rounds: this.opts.maxRounds, extracted, label: lastLabel };
+  }
+};
+async function executeAction(adapter, action) {
+  if ("Click" in action) {
+    const { x, y } = await getElementCenter(adapter, action.Click);
+    await adapter.clickPoint(x, y);
+    return;
+  }
+  if ("ClickAll" in action) {
+    const selector = action.ClickAll;
+    const points = await adapter.evaluate(`
+      (function() {
+        const els = document.querySelectorAll(${JSON.stringify(selector)});
+        return Array.from(els).map(el => {
+          const r = el.getBoundingClientRect();
+          return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
+        });
+      })()
+    `);
+    if (Array.isArray(points)) {
+      for (const pt of points) {
+        await adapter.clickPoint(pt.x, pt.y);
+        await sleep4(100);
+      }
+    }
+    return;
+  }
+  if ("ClickPoint" in action) {
+    const { x, y } = action.ClickPoint;
+    await adapter.clickPoint(x, y);
+    return;
+  }
+  if ("ClickHold" in action) {
+    const { selector, hold_ms } = action.ClickHold;
+    const { x, y } = await getElementCenter(adapter, selector);
+    await adapter.clickHoldPoint(x, y, hold_ms);
+    return;
+  }
+  if ("ClickHoldPoint" in action) {
+    const { x, y, hold_ms } = action.ClickHoldPoint;
+    await adapter.clickHoldPoint(x, y, hold_ms);
+    return;
+  }
+  if ("DoubleClick" in action) {
+    const { x, y } = await getElementCenter(adapter, action.DoubleClick);
+    await adapter.doubleClickPoint(x, y);
+    return;
+  }
+  if ("DoubleClickPoint" in action) {
+    const { x, y } = action.DoubleClickPoint;
+    await adapter.doubleClickPoint(x, y);
+    return;
+  }
+  if ("RightClick" in action) {
+    const { x, y } = await getElementCenter(adapter, action.RightClick);
+    await adapter.rightClickPoint(x, y);
+    return;
+  }
+  if ("RightClickPoint" in action) {
+    const { x, y } = action.RightClickPoint;
+    await adapter.rightClickPoint(x, y);
+    return;
+  }
+  if ("WaitForAndClick" in action) {
+    const selector = action.WaitForAndClick;
+    await waitForElement(adapter, selector, 5e3);
+    const { x, y } = await getElementCenter(adapter, selector);
+    await adapter.clickPoint(x, y);
+    return;
+  }
+  if ("ClickDrag" in action) {
+    const { from, to } = action.ClickDrag;
+    const f = await getElementCenter(adapter, from);
+    const t = await getElementCenter(adapter, to);
+    await adapter.dragPoint(f.x, f.y, t.x, t.y);
+    return;
+  }
+  if ("ClickDragPoint" in action) {
+    const { from_x, from_y, to_x, to_y } = action.ClickDragPoint;
+    await adapter.dragPoint(from_x, from_y, to_x, to_y);
+    return;
+  }
+  if ("Type" in action) {
+    await adapter.insertText(action.Type.value);
+    return;
+  }
+  if ("Fill" in action) {
+    const { selector, value } = action.Fill;
+    await adapter.evaluate(`
+      (function() {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (el) { el.focus(); el.value = ''; }
+      })()
+    `);
+    try {
+      const { x, y } = await getElementCenter(adapter, selector);
+      await adapter.clickPoint(x, y);
+    } catch {
+    }
+    await adapter.insertText(value);
+    await adapter.evaluate(`
+      (function() {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (el) {
+          el.dispatchEvent(new Event('input', { bubbles: true }));
+          el.dispatchEvent(new Event('change', { bubbles: true }));
+        }
+      })()
+    `);
+    return;
+  }
+  if ("Clear" in action) {
+    const selector = action.Clear;
+    await adapter.evaluate(`document.querySelector(${JSON.stringify(selector)}).value = ''`);
+    return;
+  }
+  if ("Press" in action) {
+    await adapter.pressKey(action.Press);
+    return;
+  }
+  if ("KeyDown" in action) {
+    await adapter.keyDown(action.KeyDown);
+    return;
+  }
+  if ("KeyUp" in action) {
+    await adapter.keyUp(action.KeyUp);
+    return;
+  }
+  if ("Select" in action) {
+    const { selector, value } = action.Select;
+    await adapter.evaluate(`
+      (function() {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (el) {
+          el.value = ${JSON.stringify(value)};
+          el.dispatchEvent(new Event('change', { bubbles: true }));
+        }
+      })()
+    `);
+    return;
+  }
+  if ("Focus" in action) {
+    await adapter.evaluate(`document.querySelector(${JSON.stringify(action.Focus)})?.focus()`);
+    return;
+  }
+  if ("Blur" in action) {
+    await adapter.evaluate(`document.querySelector(${JSON.stringify(action.Blur)})?.blur()`);
+    return;
+  }
+  if ("Hover" in action) {
+    const { x, y } = await getElementCenter(adapter, action.Hover);
+    await adapter.hoverPoint(x, y);
+    return;
+  }
+  if ("HoverPoint" in action) {
+    const { x, y } = action.HoverPoint;
+    await adapter.hoverPoint(x, y);
+    return;
+  }
+  if ("ScrollY" in action) {
+    await adapter.evaluate(`window.scrollBy(0, ${action.ScrollY})`);
+    return;
+  }
+  if ("ScrollX" in action) {
+    await adapter.evaluate(`window.scrollBy(${action.ScrollX}, 0)`);
+    return;
+  }
+  if ("ScrollTo" in action) {
+    const selector = action.ScrollTo.selector;
+    await adapter.evaluate(
+      `document.querySelector(${JSON.stringify(selector)})?.scrollIntoView({ behavior: 'smooth', block: 'center' })`
+    );
+    return;
+  }
+  if ("ScrollToPoint" in action) {
+    const { x, y } = action.ScrollToPoint;
+    await adapter.evaluate(`window.scrollTo(${x}, ${y})`);
+    return;
+  }
+  if ("InfiniteScroll" in action) {
+    const max = action.InfiniteScroll;
+    for (let i = 0; i < max; i++) {
+      await adapter.evaluate("window.scrollTo(0, document.body.scrollHeight)");
+      await sleep4(500);
+    }
+    return;
+  }
+  if ("Wait" in action) {
+    await sleep4(action.Wait);
+    return;
+  }
+  if ("WaitFor" in action) {
+    await waitForElement(adapter, action.WaitFor, 5e3);
+    return;
+  }
+  if ("WaitForWithTimeout" in action) {
+    const { selector, timeout } = action.WaitForWithTimeout;
+    await waitForElement(adapter, selector, timeout);
+    return;
+  }
+  if ("WaitForNavigation" in action) {
+    await sleep4(1e3);
+    return;
+  }
+  if ("WaitForDom" in action) {
+    const timeout = action.WaitForDom.timeout ?? 5e3;
+    await sleep4(timeout);
+    return;
+  }
+  if ("Navigate" in action) {
+    await adapter.navigate(action.Navigate);
+    return;
+  }
+  if ("GoBack" in action) {
+    await adapter.evaluate("window.history.back()");
+    return;
+  }
+  if ("GoForward" in action) {
+    await adapter.evaluate("window.history.forward()");
+    return;
+  }
+  if ("Reload" in action) {
+    await adapter.evaluate("window.location.reload()");
+    return;
+  }
+  if ("SetViewport" in action) {
+    const { width, height, device_scale_factor, mobile } = action.SetViewport;
+    await adapter.setViewport(width, height, device_scale_factor ?? 2, mobile ?? false);
+    return;
+  }
+  if ("Evaluate" in action) {
+    await adapter.evaluate(action.Evaluate);
+    return;
+  }
+  if ("Screenshot" in action) {
+    return;
+  }
+  logger.warn("agent: unknown action", { action: JSON.stringify(action).slice(0, 100) });
+}
+async function getElementCenter(adapter, selector) {
+  const result = await adapter.evaluate(`
+    (function() {
+      const el = document.querySelector(${JSON.stringify(selector)});
+      if (!el) return null;
+      el.scrollIntoView({ block: 'center', behavior: 'instant' });
+      const r = el.getBoundingClientRect();
+      return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
+    })()
+  `);
+  if (!result) {
+    throw new Error(`Element not found: ${selector}`);
+  }
+  return result;
+}
+async function waitForElement(adapter, selector, timeoutMs) {
+  const interval = 100;
+  const maxIter = Math.ceil(timeoutMs / interval);
+  const checkJs = `!!document.querySelector(${JSON.stringify(selector)})`;
+  for (let i = 0; i < maxIter; i++) {
+    const found = await adapter.evaluate(checkJs);
+    if (found) return;
+    await sleep4(interval);
+  }
+  throw new TimeoutError(`Timeout waiting for element: ${selector}`);
+}
+function sleep4(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// ai/act.ts
+async function act(adapter, llm, instruction) {
+  const [screenshot, html, url, title] = await Promise.all([
+    adapter.captureScreenshot(),
+    adapter.getHTML(),
+    adapter.evaluate("window.location.href"),
+    adapter.evaluate("document.title")
+  ]);
+  const context = `Task: ${instruction}
+PAGE TITLE: ${title}`;
+  const plan = await llm.chatJSON([
+    { role: "system", content: SYSTEM_PROMPT },
+    {
+      role: "user",
+      content: buildUserMessage(url, html, screenshot, context)
+    }
+  ]);
+  if (plan.steps && Array.isArray(plan.steps)) {
+    for (const step of plan.steps) {
+      await executeAction(adapter, step);
+      await sleep5(200);
+    }
+  }
+}
+function sleep5(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// utils/dom.ts
+var GET_INTERACTIVE_ELEMENTS = `
+(function() {
+  const interactiveSelectors = [
+    'a[href]',
+    'button',
+    'input',
+    'select',
+    'textarea',
+    '[role="button"]',
+    '[role="link"]',
+    '[role="tab"]',
+    '[role="menuitem"]',
+    '[role="checkbox"]',
+    '[role="radio"]',
+    '[role="switch"]',
+    '[role="combobox"]',
+    '[onclick]',
+    '[tabindex]',
+    'summary',
+    'details',
+    'label',
+  ];
+  const seen = new Set();
+  const results = [];
+  for (const sel of interactiveSelectors) {
+    for (const el of document.querySelectorAll(sel)) {
+      if (seen.has(el)) continue;
+      seen.add(el);
+      const r = el.getBoundingClientRect();
+      if (r.width === 0 && r.height === 0) continue;
+      if (r.bottom < 0 || r.right < 0) continue;
+
+      const tag = el.tagName.toLowerCase();
+      const type = el.getAttribute('type') || '';
+      const text = (el.textContent || '').trim().slice(0, 100);
+      const ariaLabel = el.getAttribute('aria-label') || '';
+      const placeholder = el.getAttribute('placeholder') || '';
+      const href = el.getAttribute('href') || '';
+      const value = (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)
+        ? el.value.slice(0, 50) : '';
+
+      // Build a unique-ish selector
+      let cssSelector = tag;
+      const id = el.getAttribute('id');
+      if (id) {
+        cssSelector = '#' + CSS.escape(id);
+      } else {
+        const cls = el.getAttribute('class');
+        if (cls) {
+          const classes = cls.trim().split(/\\s+/).slice(0, 2);
+          cssSelector = tag + classes.map(c => '.' + CSS.escape(c)).join('');
+        }
+        const name = el.getAttribute('name');
+        if (name) {
+          cssSelector = tag + '[name="' + CSS.escape(name) + '"]';
+        }
+      }
+
+      results.push({
+        selector: cssSelector,
+        tag,
+        type,
+        text,
+        ariaLabel,
+        placeholder,
+        href,
+        value,
+        rect: {
+          x: Math.round(r.x),
+          y: Math.round(r.y),
+          width: Math.round(r.width),
+          height: Math.round(r.height),
+        },
+      });
+    }
+  }
+  return results;
+})()
+`;
+
+// ai/observe.ts
+async function observe(adapter, instruction, llm) {
+  const elements = await adapter.evaluate(GET_INTERACTIVE_ELEMENTS);
+  if (!Array.isArray(elements) || elements.length === 0) {
+    return [];
+  }
+  if (!instruction || !llm) {
+    return elements;
+  }
+  const elementSummary = elements.map((el, i) => {
+    const parts = [`[${i}] <${el.tag}>`];
+    if (el.text) parts.push(`text="${el.text}"`);
+    if (el.ariaLabel) parts.push(`aria="${el.ariaLabel}"`);
+    if (el.placeholder) parts.push(`placeholder="${el.placeholder}"`);
+    if (el.href) parts.push(`href="${el.href}"`);
+    if (el.type) parts.push(`type="${el.type}"`);
+    return parts.join(" ");
+  }).join("\n");
+  const response = await llm.chatJSON([
+    {
+      role: "system",
+      content: 'You are an element selector. Given a list of page elements and an instruction, return a JSON object with an "indices" array of element indices that match the instruction. Order by relevance (most relevant first). Return {"indices": []} if none match.'
+    },
+    {
+      role: "user",
+      content: `Instruction: ${instruction}
+
+Elements:
+${elementSummary}`
+    }
+  ]);
+  const indices = response.indices ?? [];
+  return indices.filter((i) => i >= 0 && i < elements.length).map((i, rank) => ({
+    ...elements[i],
+    score: 1 - rank / Math.max(indices.length, 1)
+  }));
+}
+
+// utils/html.ts
+function truncateHtml2(html, maxChars = 12e3) {
+  if (html.length <= maxChars) return html;
+  const slice = html.slice(0, maxChars);
+  const lastClose = slice.lastIndexOf(">");
+  return lastClose > 0 ? html.slice(0, lastClose + 1) : slice;
+}
+
+// ai/extract.ts
+async function extract(adapter, llm, instruction, schema) {
+  const [screenshot, html, url, title] = await Promise.all([
+    adapter.captureScreenshot(),
+    adapter.getHTML(),
+    adapter.evaluate("window.location.href"),
+    adapter.evaluate("document.title")
+  ]);
+  const truncatedHtml = truncateHtml2(html, 12e3);
+  let schemaDesc = "";
+  if (schema) {
+    try {
+      schemaDesc = `
+
+Return data matching this JSON schema:
+${JSON.stringify(schema._def, null, 2)}`;
+    } catch {
+      schemaDesc = "\n\nReturn a JSON object matching the expected structure.";
+    }
+  }
+  const systemPrompt = `You are a data extraction agent. Given a webpage screenshot and HTML, extract the requested information as JSON.${schemaDesc}
+
+Return ONLY a valid JSON object. No prose, no markdown.`;
+  const userText = `URL: ${url}
+Title: ${title}
+Instruction: ${instruction}
+
+HTML (truncated):
+${truncatedHtml}`;
+  const result = await llm.chatJSON([
+    { role: "system", content: systemPrompt },
+    {
+      role: "user",
+      content: [
+        { type: "text", text: userText },
+        {
+          type: "image_url",
+          image_url: { url: `data:image/png;base64,${screenshot}` }
+        }
+      ]
+    }
+  ]);
+  if (schema) {
+    return schema.parse(result);
+  }
+  return result;
+}
+
+// spider-browser.ts
+var SpiderBrowser = class {
+  opts;
+  transport = null;
+  adapter = null;
+  retryEngine = null;
+  emitter = new SpiderEventEmitter();
+  _page = null;
+  llmProvider = null;
+  currentUrl;
+  constructor(options) {
+    this.opts = {
+      apiKey: options.apiKey,
+      serverUrl: options.serverUrl ?? "wss://browser.spider.cloud",
+      browser: options.browser ?? "auto",
+      captcha: options.captcha ?? "solve",
+      smartRetry: options.smartRetry ?? true,
+      maxRetries: options.maxRetries ?? 12,
+      stealth: options.stealth ?? 0,
+      maxStealthLevels: options.maxStealthLevels ?? 3,
+      connectTimeoutMs: options.connectTimeoutMs ?? 3e4,
+      commandTimeoutMs: options.commandTimeoutMs ?? 3e4,
+      retryTimeoutMs: options.retryTimeoutMs ?? 15e3,
+      url: options.url,
+      llm: options.llm
+    };
+    if (options.logLevel) {
+      logger.setLevel(options.logLevel);
+    }
+    if (this.opts.llm) {
+      this.llmProvider = createProvider(this.opts.llm);
+    }
+  }
+  /** The active page instance for deterministic browser control. */
+  get page() {
+    if (!this._page) {
+      throw new Error("SpiderBrowser not initialized. Call init() first.");
+    }
+    return this._page;
+  }
+  /** Current browser type. */
+  get browser() {
+    return this.transport?.browser ?? this.opts.browser;
+  }
+  /** Whether the WebSocket is connected. */
+  get connected() {
+    return this.transport?.connected ?? false;
+  }
+  /** Active stealth level (0=auto, 1-3=explicit tiers). */
+  get stealthLevel() {
+    return this.retryEngine?.stealthLevel ?? this.transport?.stealthLevel ?? this.opts.stealth;
+  }
+  /** Credits remaining from last upgrade response. */
+  get credits() {
+    return this.transport?.upgradeCredits;
+  }
+  /** Credits consumed during this session (from server Spider.metering event). */
+  get sessionCreditsUsed() {
+    return this.transport?.sessionCreditsUsed;
+  }
+  /**
+   * Request the exact session cost from the server.
+   * Unlike `sessionCreditsUsed` (which relies on async event delivery),
+   * this sends a Spider.getMetering command and waits for the response.
+   * Call this before close() for accurate per-session metering.
+   */
+  async getSessionCredits() {
+    if (!this.transport) return 0;
+    return this.transport.requestMetering();
+  }
+  /** Subscribe to events. */
+  on(event, handler) {
+    this.emitter.on(event, handler);
+    return this;
+  }
+  /** Unsubscribe from events. */
+  off(event, handler) {
+    this.emitter.off(event, handler);
+    return this;
+  }
+  /** Subscribe to an event once. */
+  once(event, handler) {
+    this.emitter.once(event, handler);
+    return this;
+  }
+  /**
+   * Connect to the browser server WebSocket and initialize the protocol.
+   */
+  async init() {
+    const transportOpts = {
+      apiKey: this.opts.apiKey,
+      serverUrl: this.opts.serverUrl,
+      browser: this.opts.browser,
+      url: this.opts.url,
+      captcha: this.opts.captcha,
+      stealthLevel: this.opts.stealth,
+      connectTimeoutMs: this.opts.connectTimeoutMs,
+      commandTimeoutMs: this.opts.commandTimeoutMs
+    };
+    this.transport = new Transport(transportOpts, this.emitter);
+    await this.transport.connect();
+    const activeBrowser = this.transport.browser;
+    this.adapter = new ProtocolAdapter(this.transport, this.emitter, activeBrowser, {
+      commandTimeoutMs: this.opts.commandTimeoutMs
+    });
+    await this.adapter.init();
+    this._page = new SpiderPage(this.adapter);
+    if (this.opts.smartRetry) {
+      const retryOpts = {
+        maxRetries: this.opts.maxRetries,
+        transportOpts,
+        emitter: this.emitter,
+        maxStealthLevel: this.opts.maxStealthLevels,
+        retryTimeoutMs: this.opts.retryTimeoutMs,
+        commandTimeoutMs: this.opts.commandTimeoutMs
+      };
+      this.retryEngine = new RetryEngine(retryOpts);
+    }
+    this.currentUrl = this.opts.url;
+    logger.info("SpiderBrowser initialized", { browser: activeBrowser });
+  }
+  /**
+   * Execute an action with smart retry. On failure, classifies the error and
+   * may switch browsers, reconnect, re-navigate, and retry.
+   */
+  async withRetry(fn) {
+    if (!this.retryEngine || !this.transport || !this.adapter) {
+      return fn();
+    }
+    return this.retryEngine.execute(fn, {
+      transport: this.transport,
+      adapter: this.adapter,
+      page: this._page,
+      currentUrl: this.currentUrl,
+      onAdapterChanged: (newAdapter) => {
+        this.adapter = newAdapter;
+        this._page._setAdapter(newAdapter);
+      }
+    });
+  }
+  // -------------------------------------------------------------------
+  // Navigation (with retry)
+  // -------------------------------------------------------------------
+  /**
+   * Navigate to a URL with smart retry.
+   *
+   * On ERR_ABORTED: closes the WebSocket, reconnects, and retries.
+   * On bot detection: switches to a different browser and retries.
+   *
+   * Also updates `currentUrl` for subsequent retries on other operations.
+   */
+  async goto(url) {
+    this.currentUrl = url;
+    await this.withRetry(async () => {
+      await this._page.goto(url);
+    });
+  }
+  // -------------------------------------------------------------------
+  // AI Methods (require LLM config)
+  // -------------------------------------------------------------------
+  /**
+   * Execute a single action from natural language.
+   *
+   * Example: `await browser.act('Click the login button')`
+   */
+  async act(instruction) {
+    this.requireLLM();
+    await this.withRetry(() => act(this.adapter, this.llmProvider, instruction));
+  }
+  /**
+   * Discover interactive elements on the page.
+   *
+   * Works WITHOUT an LLM — injects DOM traversal to collect elements.
+   * When instruction is provided + LLM is configured, adds ranking/filtering.
+   */
+  async observe(instruction) {
+    return this.withRetry(
+      () => observe(this.adapter, instruction, this.llmProvider ?? void 0)
+    );
+  }
+  /**
+   * Extract structured data from the page.
+   *
+   * Example: `await browser.extract('Product name and price', { schema: z.object({...}) })`
+   */
+  async extract(instruction, options) {
+    this.requireLLM();
+    return this.withRetry(
+      () => extract(this.adapter, this.llmProvider, instruction, options?.schema)
+    );
+  }
+  /**
+   * Create an autonomous agent that executes multi-step tasks.
+   *
+   * Uses the same action vocabulary and system prompt as Spider's
+   * server-side captcha solver for consistent behavior.
+   */
+  agent(options) {
+    this.requireLLM();
+    return new Agent(this.adapter, this.llmProvider, this.emitter, options);
+  }
+  /**
+   * Close the connection and clean up resources.
+   */
+  async close() {
+    this.adapter?.destroy();
+    this.transport?.close();
+    this.emitter.removeAllListeners();
+    this._page = null;
+    this.adapter = null;
+    this.transport = null;
+    logger.info("SpiderBrowser closed");
+  }
+  requireLLM() {
+    if (!this.llmProvider) {
+      throw new Error(
+        "LLM not configured. Pass `llm` option to SpiderBrowser constructor for AI methods."
+      );
+    }
+  }
+};
+
+// index.ts
+init_errors();
+export {
+  Agent,
+  AuthError,
+  BROWSER_ROTATION,
+  BackendUnavailableError,
+  BiDiSession,
+  BlockedError,
+  BrowserSelector,
+  CDPSession,
+  ConnectionError,
+  FailureTracker,
+  LLMError,
+  Logger,
+  NavigationError,
+  ProtocolAdapter,
+  ProtocolError,
+  RateLimitError,
+  RetryEngine,
+  SYSTEM_PROMPT,
+  SpiderBrowser,
+  SpiderError,
+  SpiderEventEmitter,
+  SpiderPage,
+  TimeoutError,
+  Transport,
+  act,
+  createProvider,
+  extract,
+  logger,
+  observe,
+  truncateHtml2 as truncateHtml
+};
+//# sourceMappingURL=index.js.map