@xbrowser/cli 1.0.0 → 1.0.2

package/dist/{chunk-2BQZIT3S.js → chunk-QIK2I3VQ.js}

@@ -1,2464 +1,15 @@
 import {
-  connectToCDP,
-  launchChrome
-} from "./chunk-T4J4C2NZ.js";
-import {
-  __require
-} from "./chunk-3RG5ZIWI.js";
-
-// src/browser.ts
-import { randomUUID } from "crypto";
-import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-
-// src/cdp-driver/browser.ts
-import { EventEmitter as EventEmitter3 } from "events";
-
-// src/cdp-driver/context.ts
-import { EventEmitter as EventEmitter2 } from "events";
-
-// src/cdp-driver/page.ts
-import { EventEmitter } from "events";
-
-// src/cdp-driver/mouse.ts
-var XBMouseImpl = class {
-  conn;
-  sessionId;
-  _x = 0;
-  _y = 0;
-  _button = "none";
-  constructor(conn, sessionId) {
-    this.conn = conn;
-    this.sessionId = sessionId;
-  }
-  /** Current cursor X position */
-  get x() {
-    return this._x;
-  }
-  /** Current cursor Y position */
-  get y() {
-    return this._y;
-  }
-  async click(x, y, opts = {}) {
-    const button = opts.button ?? "left";
-    const clickCount = opts.clickCount ?? 1;
-    const delay = opts.delay ?? 0;
-    await this.move(x, y);
-    await this.down({ button });
-    if (delay > 0) {
-      await sleep(delay);
-    }
-    await this.up({ button });
-    for (let i = 1; i < clickCount; i++) {
-      if (delay > 0) await sleep(delay);
-      await this.down({ button });
-      if (delay > 0) await sleep(delay);
-      await this.up({ button });
-    }
-  }
-  async dblclick(x, y, opts = {}) {
-    await this.click(x, y, { clickCount: 2, button: opts.button });
-  }
-  async down(opts = {}) {
-    const button = opts.button ?? "left";
-    this._button = button;
-    await this.send("Input.dispatchMouseEvent", {
-      type: "mousePressed",
-      x: this._x,
-      y: this._y,
-      button,
-      clickCount: 1
-    });
-  }
-  async up(opts = {}) {
-    const button = opts.button ?? "left";
-    this._button = "none";
-    await this.send("Input.dispatchMouseEvent", {
-      type: "mouseReleased",
-      x: this._x,
-      y: this._y,
-      button,
-      clickCount: 1
-    });
-  }
-  async move(x, y, opts = {}) {
-    const steps = Math.max(1, opts.steps ?? 1);
-    const fromX = this._x;
-    const fromY = this._y;
-    const dx = x - fromX;
-    const dy = y - fromY;
-    for (let i = 1; i <= steps; i++) {
-      const t = i / steps;
-      this._x = fromX + dx * t;
-      this._y = fromY + dy * t;
-      await this.send("Input.dispatchMouseEvent", {
-        type: "mouseMoved",
-        x: this._x,
-        y: this._y,
-        button: this._button
-      });
-    }
-    this._x = x;
-    this._y = y;
-  }
-  async wheel(deltaX, deltaY) {
-    await this.send("Input.dispatchMouseEvent", {
-      type: "mouseWheel",
-      x: this._x,
-      y: this._y,
-      deltaX,
-      deltaY
-    });
-  }
-  async send(method, params) {
-    await this.conn.send(method, params, this.sessionId);
-  }
-};
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/cdp-driver/keyboard.ts
-var XBKeyboardImpl = class {
-  conn;
-  sessionId;
-  constructor(conn, sessionId) {
-    this.conn = conn;
-    this.sessionId = sessionId;
-  }
-  async press(key, opts = {}) {
-    const delay = opts.delay ?? 0;
-    const mapping = resolveKeyMapping(key);
-    const downParams = {
-      type: "rawKeyDown",
-      key: mapping.key,
-      code: mapping.code
-    };
-    if (mapping.text) {
-      downParams.text = mapping.text;
-      downParams.unmodifiedText = mapping.text;
-    }
-    if (mapping.keyCode) {
-      downParams.windowsVirtualKeyCode = mapping.keyCode;
-    }
-    await this.dispatchKeyEvent(downParams);
-    if (mapping.text) {
-      await this.dispatchKeyEvent({
-        type: "char",
-        text: mapping.text
-      });
-    }
-    if (delay > 0) await sleep2(delay);
-    const upParams = {
-      type: "keyUp",
-      key: mapping.key,
-      code: mapping.code
-    };
-    if (mapping.keyCode) {
-      upParams.windowsVirtualKeyCode = mapping.keyCode;
-    }
-    await this.dispatchKeyEvent(upParams);
-  }
-  async down(key) {
-    const mapping = resolveKeyMapping(key);
-    const params = {
-      type: "rawKeyDown",
-      key: mapping.key,
-      code: mapping.code
-    };
-    if (mapping.text) {
-      params.text = mapping.text;
-      params.unmodifiedText = mapping.text;
-    }
-    if (mapping.keyCode) {
-      params.windowsVirtualKeyCode = mapping.keyCode;
-    }
-    await this.dispatchKeyEvent(params);
-  }
-  async up(key) {
-    const mapping = resolveKeyMapping(key);
-    const params = {
-      type: "keyUp",
-      key: mapping.key,
-      code: mapping.code
-    };
-    if (mapping.keyCode) {
-      params.windowsVirtualKeyCode = mapping.keyCode;
-    }
-    await this.dispatchKeyEvent(params);
-  }
-  async type(text, opts = {}) {
-    const delay = opts.delay ?? 0;
-    for (const char of text) {
-      if (delay > 0) await sleep2(delay);
-      const mapping = resolveKeyMapping(char);
-      const downParams = {
-        type: "rawKeyDown",
-        key: mapping.key,
-        code: mapping.code
-      };
-      if (mapping.text) {
-        downParams.text = mapping.text;
-        downParams.unmodifiedText = mapping.text;
-      }
-      if (mapping.keyCode) {
-        downParams.windowsVirtualKeyCode = mapping.keyCode;
-      }
-      await this.dispatchKeyEvent(downParams);
-      if (mapping.text) {
-        await this.dispatchKeyEvent({
-          type: "char",
-          text: mapping.text
-        });
-      }
-      await this.dispatchKeyEvent({
-        type: "keyUp",
-        key: mapping.key,
-        code: mapping.code,
-        ...mapping.keyCode ? { windowsVirtualKeyCode: mapping.keyCode } : {}
-      });
-    }
-  }
-  async insertText(text) {
-    await this.conn.send(
-      "Input.insertText",
-      { text },
-      this.sessionId
-    );
-  }
-  async dispatchKeyEvent(params) {
-    await this.conn.send("Input.dispatchKeyEvent", params, this.sessionId);
-  }
-};
-function resolveKeyMapping(key) {
-  if (KEY_MAP[key]) return KEY_MAP[key];
-  if (key.length === 1) {
-    const lower = key.toLowerCase();
-    if (lower >= "a" && lower <= "z") {
-      const code = `Key${lower.toUpperCase()}`;
-      const keyCode = lower.charCodeAt(0) - 32;
-      return { key, code, text: key, keyCode };
-    }
-    if (key >= "0" && key <= "9") {
-      const code = `Digit${key}`;
-      const keyCode = key.charCodeAt(0);
-      return { key, code, text: key, keyCode };
-    }
-    return { key, code: key, text: key };
-  }
-  return { key, code: key };
-}
-var KEY_MAP = {
-  Enter: { key: "Enter", code: "Enter", text: "\r" },
-  Tab: { key: "Tab", code: "Tab", text: "	" },
-  Escape: { key: "Escape", code: "Escape" },
-  Backspace: { key: "Backspace", code: "Backspace" },
-  Delete: { key: "Delete", code: "Delete" },
-  Space: { key: " ", code: "Space", text: " " },
-  ArrowUp: { key: "ArrowUp", code: "ArrowUp" },
-  ArrowDown: { key: "ArrowDown", code: "ArrowDown" },
-  ArrowLeft: { key: "ArrowLeft", code: "ArrowLeft" },
-  ArrowRight: { key: "ArrowRight", code: "ArrowRight" },
-  Home: { key: "Home", code: "Home" },
-  End: { key: "End", code: "End" },
-  PageUp: { key: "PageUp", code: "PageUp" },
-  PageDown: { key: "PageDown", code: "PageDown" },
-  Control: { key: "Control", code: "ControlLeft" },
-  Shift: { key: "Shift", code: "ShiftLeft" },
-  Alt: { key: "Alt", code: "AltLeft" },
-  Meta: { key: "Meta", code: "MetaLeft" },
-  F1: { key: "F1", code: "F1" },
-  F2: { key: "F2", code: "F2" },
-  F3: { key: "F3", code: "F3" },
-  F4: { key: "F4", code: "F4" },
-  F5: { key: "F5", code: "F5" },
-  F6: { key: "F6", code: "F6" },
-  F7: { key: "F7", code: "F7" },
-  F8: { key: "F8", code: "F8" },
-  F9: { key: "F9", code: "F9" },
-  F10: { key: "F10", code: "F10" },
-  F11: { key: "F11", code: "F11" },
-  F12: { key: "F12", code: "F12" }
-};
-function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/cdp-driver/actionability.ts
-async function waitForActionable(page, selector, opts = {}) {
-  const timeout = opts.timeout ?? 3e4;
-  if (opts.force) {
-    const nodeId = await page.querySelector(selector);
-    if (!nodeId) throw new Error(`Element not found: ${selector}`);
-    const rect = await page.getBoxModel(nodeId);
-    if (!rect) throw new Error(`Element has no box: ${selector}`);
-    return { nodeId, rect };
-  }
-  const deadline = Date.now() + timeout;
-  while (Date.now() < deadline) {
-    const result = await checkActionable(page, selector);
-    if (result.ok && result.rect) {
-      const nodeId = await page.querySelector(selector);
-      if (nodeId) return { nodeId, rect: result.rect };
-    }
-    await page.waitForTimeout(50);
-  }
-  throw new Error(`Actionability timeout: element '${selector}' not ready after ${timeout}ms`);
-}
-async function checkActionable(page, selector) {
-  const result = await page.evaluate(`
-    (function() {
-      const el = document.querySelector(${JSON.stringify(selector)});
-      if (!el) return { ok: false, reason: 'not_found' };
-
-      // Check attached to DOM
-      if (!el.isConnected) return { ok: false, reason: 'detached' };
-
-      // Check visibility
-      const style = window.getComputedStyle(el);
-      if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') {
-        return { ok: false, reason: 'invisible' };
-      }
-
-      // Check non-zero size
-      const rect = el.getBoundingClientRect();
-      if (rect.width === 0 || rect.height === 0) {
-        return { ok: false, reason: 'zero_size' };
-      }
-
-      // Check enabled (for form elements)
-      if (el.disabled) return { ok: false, reason: 'disabled' };
-      if (el.tagName === 'OPTION' && el.closest('select')?.disabled) {
-        return { ok: false, reason: 'parent_disabled' };
-      }
-
-      // Check not covered by another element at center
-      const cx = rect.x + rect.width / 2;
-      const cy = rect.y + rect.height / 2;
-      const topEl = document.elementFromPoint(cx, cy);
-      if (topEl && topEl !== el && !el.contains(topEl) && !topEl.contains(el)) {
-        return { ok: false, reason: 'covered', rect: { x: rect.x, y: rect.y, width: rect.width, height: rect.height } };
-      }
-
-      return {
-        ok: true,
-        rect: { x: rect.x, y: rect.y, width: rect.width, height: rect.height },
-      };
-    })()
-  `);
-  return result;
-}
-async function scrollIntoView(page, selector) {
-  await page.evaluate(`
-    (function() {
-      const el = document.querySelector(${JSON.stringify(selector)});
-      if (el) el.scrollIntoView({ block: 'center', inline: 'center', behavior: 'instant' });
-    })()
-  `);
-}
-
-// src/cdp-driver/locator.ts
-var XBLocatorImpl = class _XBLocatorImpl {
-  page;
-  selector;
-  constructor(page, selector) {
-    this.page = page;
-    this.selector = selector;
-  }
-  // ── Actions ─────────────────────────────────────────────────
-  async click(opts = {}) {
-    const { rect } = await waitForActionable(this.page, this.selector, opts);
-    await scrollIntoView(this.page, this.selector);
-    const updatedRect = await this.page.evaluate(`
-      (function() {
-        const el = document.querySelector(${JSON.stringify(this.selector)});
-        if (!el) return null;
-        const rect = el.getBoundingClientRect();
-        return { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
-      })()
-    `);
-    const finalRect = updatedRect ?? rect;
-    const cx = finalRect.x + finalRect.width / 2;
-    const cy = finalRect.y + finalRect.height / 2;
-    await this.page.mouse.click(cx, cy, {
-      button: opts.button ?? "left",
-      clickCount: opts.clickCount ?? 1,
-      delay: opts.delay
-    });
-  }
-  async fill(value, opts = {}) {
-    await waitForActionable(this.page, this.selector, opts);
-    await scrollIntoView(this.page, this.selector);
-    await this.page.evaluate(`
-      (function() {
-        const el = document.querySelector(${JSON.stringify(this.selector)});
-        if (!el) throw new Error('Element not found: ${this.selector.replace(/'/g, "\\'")}');
-        el.focus();
-        el.value = '';
-        el.dispatchEvent(new Event('input', { bubbles: true }));
-      })()
-    `);
-    await this.page.keyboard.insertText(value);
-    await this.page.evaluate(`
-      (function() {
-        const el = document.querySelector(${JSON.stringify(this.selector)});
-        if (el) {
-          el.dispatchEvent(new Event('input', { bubbles: true }));
-          el.dispatchEvent(new Event('change', { bubbles: true }));
-        }
-      })()
-    `);
-  }
-  async press(key, opts = {}) {
-    await waitForActionable(this.page, this.selector, { timeout: opts.timeout });
-    await scrollIntoView(this.page, this.selector);
-    await this.page.evaluate(`
-      (function() {
-        const el = document.querySelector(${JSON.stringify(this.selector)});
-        if (el) el.focus();
-      })()
-    `);
-    await this.page.keyboard.press(key);
-  }
-  async pressSequentially(text, opts = {}) {
-    await waitForActionable(this.page, this.selector, { timeout: opts.timeout });
-    await scrollIntoView(this.page, this.selector);
-    await this.page.evaluate(`
-      (function() {
-        const el = document.querySelector(${JSON.stringify(this.selector)});
-        if (el) el.focus();
-      })()
-    `);
-    await this.page.keyboard.type(text, { delay: opts.delay });
-  }
-  async hover(opts = {}) {
-    if (!opts.force) {
-      const { rect } = await waitForActionable(this.page, this.selector, { timeout: opts.timeout });
-      await scrollIntoView(this.page, this.selector);
-      const cx = rect.x + rect.width / 2;
-      const cy = rect.y + rect.height / 2;
-      await this.page.mouse.move(cx, cy);
-    } else {
-      await scrollIntoView(this.page, this.selector);
-      const rect = await this.page.evaluate(`
-        (function() {
-          const el = document.querySelector(${JSON.stringify(this.selector)});
-          if (!el) return { x: 0, y: 0, width: 0, height: 0 };
-          const r = el.getBoundingClientRect();
-          return { x: r.x, y: r.y, width: r.width, height: r.height };
-        })()
-      `);
-      const cx = rect.x + rect.width / 2;
-      const cy = rect.y + rect.height / 2;
-      await this.page.mouse.move(cx, cy);
-    }
-  }
-  async type(text, opts = {}) {
-    await this.pressSequentially(text, opts);
-  }
-  async check(opts = {}) {
-    await waitForActionable(this.page, this.selector, { timeout: opts.timeout });
-    const isChecked = await this.page.evaluate(`
-      (function() {
-        const el = document.querySelector(${JSON.stringify(this.selector)});
-        return el?.checked === true;
-      })()
-    `);
-    if (!isChecked) {
-      await this.click({ timeout: opts.timeout });
-    }
-  }
-  async uncheck(opts = {}) {
-    await waitForActionable(this.page, this.selector, { timeout: opts.timeout });
-    const isChecked = await this.page.evaluate(`
-      (function() {
-        const el = document.querySelector(${JSON.stringify(this.selector)});
-        return el?.checked === true;
-      })()
-    `);
-    if (isChecked) {
-      await this.click({ timeout: opts.timeout });
-    }
-  }
-  async selectOption(value) {
-    await waitForActionable(this.page, this.selector);
-    const values = Array.isArray(value) ? value : [value];
-    const selected = await this.page.evaluate(`
-      (function() {
-        const el = document.querySelector(${JSON.stringify(this.selector)});
-        if (!el || el.tagName !== 'SELECT') throw new Error('Not a select element');
-
-        const values = ${JSON.stringify(values)};
-        const selectedValues = [];
-
-        for (const opt of el.options) {
-          for (const v of values) {
-            if (typeof v === 'object') {
-              if (v.label && opt.label === v.label) { opt.selected = true; selectedValues.push(opt.value); }
-              else if (v.value && opt.value === v.value) { opt.selected = true; selectedValues.push(opt.value); }
-              else if (v.index !== undefined && opt.index === v.index) { opt.selected = true; selectedValues.push(opt.value); }
-            } else if (opt.value === v || opt.label === v) {
-              opt.selected = true;
-              selectedValues.push(opt.value);
-            }
-          }
-        }
-
-        el.dispatchEvent(new Event('input', { bubbles: true }));
-        el.dispatchEvent(new Event('change', { bubbles: true }));
-        return selectedValues;
-      })()
-    `);
-    return selected;
-  }
-  async screenshot(opts = {}) {
-    await waitForActionable(this.page, this.selector);
-    const nodeId = await this.page.querySelector(this.selector);
-    if (!nodeId) throw new Error(`Element not found: ${this.selector}`);
-    const box = await this.page.getBoxModel(nodeId);
-    if (!box) throw new Error("Element has no box");
-    return this.page.screenshot({
-      ...opts,
-      clip: { x: box.x, y: box.y, width: box.width, height: box.height }
-    });
-  }
-  // ── State checks ────────────────────────────────────────────
-  async waitFor(opts = {}) {
-    await this.page.waitForSelector(this.selector, opts);
-  }
-  async count() {
-    return this.page.evaluate(`
-      document.querySelectorAll(${JSON.stringify(this.selector)}).length
-    `);
-  }
-  async isVisible() {
-    try {
-      const result = await this.page.evaluate(`
-        (function() {
-          const el = document.querySelector(${JSON.stringify(this.selector)});
-          if (!el) return false;
-          if (!el.isConnected) return false;
-          const style = window.getComputedStyle(el);
-          if (style.display === 'none' || style.visibility === 'hidden') return false;
-          const rect = el.getBoundingClientRect();
-          return rect.width > 0 && rect.height > 0;
-        })()
-      `);
-      return Boolean(result);
-    } catch {
-      return false;
-    }
-  }
-  async isHidden() {
-    return !await this.isVisible();
-  }
-  async isEnabled() {
-    return this.page.evaluate(`
-      (function() {
-        const el = document.querySelector(${JSON.stringify(this.selector)});
-        if (!el) return false;
-        return !el.disabled;
-      })()
-    `);
-  }
-  async isDisabled() {
-    return !await this.isEnabled();
-  }
-  async boundingBox() {
-    const nodeId = await this.page.querySelector(this.selector);
-    if (!nodeId) return null;
-    return this.page.getBoxModel(nodeId);
-  }
-  // ── Text/HTML ───────────────────────────────────────────────
-  async textContent() {
-    return this.page.evaluate(`
-      (function() {
-        const el = document.querySelector(${JSON.stringify(this.selector)});
-        return el?.textContent ?? null;
-      })()
-    `);
-  }
-  async innerText() {
-    return this.page.evaluate(`
-      (function() {
-        const el = document.querySelector(${JSON.stringify(this.selector)});
-        if (!el) throw new Error('Element not found');
-        return el.innerText;
-      })()
-    `);
-  }
-  async innerHTML() {
-    return this.page.evaluate(`
-      (function() {
-        const el = document.querySelector(${JSON.stringify(this.selector)});
-        if (!el) throw new Error('Element not found');
-        return el.innerHTML;
-      })()
-    `);
-  }
-  async getAttribute(name) {
-    return this.page.evaluate(`
-      (function() {
-        const el = document.querySelector(${JSON.stringify(this.selector)});
-        return el?.getAttribute(${JSON.stringify(name)}) ?? null;
-      })()
-    `);
-  }
-  // ── Evaluate ────────────────────────────────────────────────
-  async evaluate(fn, ...args) {
-    const fnBody = typeof fn === "function" ? fn.toString() : fn;
-    return this.page.evaluate(
-      `(function(sel, fnStr, ...evalArgs) {
-        const el = document.querySelector(sel);
-        if (!el) throw new Error('No element found for selector: ' + sel);
-        const fn = new Function('return ' + fnStr)();
-        return fn(el, ...evalArgs);
-      })(${JSON.stringify(this.selector)}, ${JSON.stringify(fnBody)}${args.length > 0 ? ", " + args.map((a) => JSON.stringify(a)).join(", ") : ""})`
-    );
-  }
-  async ariaSnapshot() {
-    const result = await this.page._cdpSend(
-      "Accessibility.getFullAXTree"
-    );
-    return result.nodes.map((n) => `${n.role?.value}: ${n.name?.value ?? ""}`).join("\n");
-  }
-  // ── Filtering ───────────────────────────────────────────────
-  first() {
-    return new FilteredLocator(this.page, this.selector, 0);
-  }
-  last() {
-    return new FilteredLocator(this.page, this.selector, -1);
-  }
-  nth(index) {
-    return new FilteredLocator(this.page, this.selector, index);
-  }
-  filter(opts) {
-    if (opts.visible) {
-      return new VisibleFilteredLocator(this.page, this.selector);
-    }
-    return new _XBLocatorImpl(this.page, this.selector);
-  }
-  async all() {
-    const n = await this.page.evaluate(`
-      document.querySelectorAll(${JSON.stringify(this.selector)}).length
-    `);
-    const locators = [];
-    for (let i = 0; i < n; i++) {
-      locators.push(new FilteredLocator(this.page, this.selector, i));
-    }
-    return locators;
-  }
-  async focus() {
-    await this.page.evaluate(`
-      (function() {
-        const el = document.querySelector(${JSON.stringify(this.selector)});
-        if (el) el.focus();
-      })()
-    `);
-  }
-};
-var FilteredLocator = class extends XBLocatorImpl {
-  constructor(page, selector, index) {
-    const indexedSelector = index === -1 ? `${selector}:last-of-type` : `${selector}:nth-of-type(${index + 1})`;
-    super(page, indexedSelector);
-  }
-};
-var VisibleFilteredLocator = class extends XBLocatorImpl {
-  async _withVisibleTag(fn) {
-    const tag = `data-xb-vt-${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
-    const found = await this.page.evaluate(`
-      (function() {
-        const els = document.querySelectorAll(${JSON.stringify(this.selector)});
-        for (const el of els) {
-          if (!el.isConnected) continue;
-          const style = window.getComputedStyle(el);
-          if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') continue;
-          const rect = el.getBoundingClientRect();
-          if (rect.width === 0 || rect.height === 0) continue;
-          el.setAttribute(${JSON.stringify(tag)}, '');
-          return true;
-        }
-        return false;
-      })()
-    `);
-    if (!found) throw new Error(`No visible element found for: ${this.selector}`);
-    try {
-      return await fn(`[${tag}]`);
-    } finally {
-      await this.page.evaluate(`
-        document.querySelectorAll(${JSON.stringify(`[${tag}]`)}).forEach(el => el.removeAttribute(${JSON.stringify(tag)}))
-      `);
-    }
-  }
-  async click(opts) {
-    return this._withVisibleTag((tagSel) => new XBLocatorImpl(this.page, tagSel).click(opts));
-  }
-  async fill(value, opts) {
-    return this._withVisibleTag((tagSel) => new XBLocatorImpl(this.page, tagSel).fill(value, opts));
-  }
-  async press(key, opts) {
-    return this._withVisibleTag((tagSel) => new XBLocatorImpl(this.page, tagSel).press(key, opts));
-  }
-  async hover(opts) {
-    return this._withVisibleTag((tagSel) => new XBLocatorImpl(this.page, tagSel).hover(opts));
-  }
-  async count() {
-    return this.page.evaluate(`
-      (function() {
-        let count = 0;
-        const els = document.querySelectorAll(${JSON.stringify(this.selector)});
-        for (const el of els) {
-          if (!el.isConnected) continue;
-          const style = window.getComputedStyle(el);
-          if (style.display === 'none' || style.visibility === 'hidden') continue;
-          const rect = el.getBoundingClientRect();
-          if (rect.width === 0 || rect.height === 0) continue;
-          count++;
-        }
-        return count;
-      })()
-    `);
-  }
-  async isVisible() {
-    try {
-      const result = await this.page.evaluate(`
-        (function() {
-          const els = document.querySelectorAll(${JSON.stringify(this.selector)});
-          for (const el of els) {
-            if (!el.isConnected) continue;
-            const style = window.getComputedStyle(el);
-            if (style.display === 'none' || style.visibility === 'hidden') continue;
-            const rect = el.getBoundingClientRect();
-            if (rect.width > 0 && rect.height > 0) return true;
-          }
-          return false;
-        })()
-      `);
-      return result;
-    } catch {
-      return false;
-    }
-  }
-  async textContent() {
-    return this._withVisibleTag((tagSel) => new XBLocatorImpl(this.page, tagSel).textContent());
-  }
-  async innerText() {
-    return this._withVisibleTag((tagSel) => new XBLocatorImpl(this.page, tagSel).innerText());
-  }
-  async waitFor(opts) {
-    const deadline = Date.now() + (opts?.timeout ?? 3e4);
-    while (Date.now() < deadline) {
-      if (await this.isVisible()) return;
-      await this.page.waitForTimeout(50);
-    }
-    throw new Error(`Timeout waiting for visible element: ${this.selector}`);
-  }
-};
-
-// src/cdp-driver/element-handle.ts
-var XBElementHandleImpl = class {
-  page;
-  nodeId;
-  disposed = false;
-  constructor(page, nodeId) {
-    this.page = page;
-    this.nodeId = nodeId;
-  }
-  get _nodeId() {
-    return this.nodeId;
-  }
-  async click(opts = {}) {
-    if (this.disposed) throw new Error("Element handle disposed");
-    const box = await this.boundingBox();
-    if (!box) throw new Error("Element has no box");
-    await this.scrollIntoViewIfNeeded();
-    const cx = box.x + box.width / 2;
-    const cy = box.y + box.height / 2;
-    await this.page.mouse.click(cx, cy, {
-      button: opts.button ?? "left",
-      clickCount: opts.clickCount ?? 1,
-      delay: opts.delay
-    });
-  }
-  async fill(value, _opts = {}) {
-    if (this.disposed) throw new Error("Element handle disposed");
-    const objectId = await this.page.resolveNode(this.nodeId);
-    await this.page.callFunctionOn(
-      objectId,
-      `function(value) {
-        this.focus();
-        this.value = '';
-        this.dispatchEvent(new Event('input', { bubbles: true }));
-      }`,
-      [value]
-    );
-    await this.page.keyboard.insertText(value);
-    await this.page.callFunctionOn(
-      objectId,
-      `function() {
-        this.dispatchEvent(new Event('input', { bubbles: true }));
-        this.dispatchEvent(new Event('change', { bubbles: true }));
-      }`
-    );
-  }
-  async hover() {
-    const box = await this.boundingBox();
-    if (!box) throw new Error("Element has no box");
-    await this.scrollIntoViewIfNeeded();
-    await this.page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
-  }
-  async press(key) {
-    const objectId = await this.page.resolveNode(this.nodeId);
-    await this.page.callFunctionOn(objectId, "function() { this.focus(); }");
-    await this.page.keyboard.press(key);
-  }
-  async screenshot(opts = {}) {
-    const box = await this.boundingBox();
-    if (!box) throw new Error("Element has no box");
-    return this.page.screenshot({
-      ...opts,
-      clip: box
-    });
-  }
-  async boundingBox() {
-    return this.page.getBoxModel(this.nodeId);
-  }
-  async isVisible() {
-    try {
-      const objectId = await this.page.resolveNode(this.nodeId);
-      const result = await this.page.callFunctionOn(
-        objectId,
-        `function() {
-          if (!this.isConnected) return false;
-          const style = window.getComputedStyle(this);
-          if (style.display === 'none' || style.visibility === 'hidden') return false;
-          const rect = this.getBoundingClientRect();
-          return rect.width > 0 && rect.height > 0;
-        }`
-      );
-      return Boolean(result);
-    } catch {
-      return false;
-    }
-  }
-  async isEnabled() {
-    const objectId = await this.page.resolveNode(this.nodeId);
-    return this.page.callFunctionOn(objectId, "function() { return !this.disabled; }");
-  }
-  async textContent() {
-    const objectId = await this.page.resolveNode(this.nodeId);
-    return this.page.callFunctionOn(objectId, "function() { return this.textContent; }");
-  }
-  async innerText() {
-    const objectId = await this.page.resolveNode(this.nodeId);
-    return this.page.callFunctionOn(objectId, "function() { return this.innerText; }");
-  }
-  async innerHTML() {
-    const objectId = await this.page.resolveNode(this.nodeId);
-    return this.page.callFunctionOn(objectId, "function() { return this.innerHTML; }");
-  }
-  async getAttribute(name) {
-    const objectId = await this.page.resolveNode(this.nodeId);
-    return this.page.callFunctionOn(objectId, `function() { return this.getAttribute(${JSON.stringify(name)}); }`);
-  }
-  async scrollIntoViewIfNeeded() {
-    if (this.disposed) return;
-    const objectId = await this.page.resolveNode(this.nodeId);
-    await this.page.callFunctionOn(
-      objectId,
-      'function() { this.scrollIntoView({ block: "center", inline: "center", behavior: "instant" }); }'
-    );
-  }
-  dispose() {
-    this.disposed = true;
-  }
-};
-
-// src/cdp-driver/page-helpers.ts
-function globToRegex(glob) {
-  let pattern = glob.replace(/[\\^${}()|[\]+]/g, "\\$&").replace(/\./g, "\\.").replace(/\*\*/g, "{{DOUBLESTAR}}").replace(/\*/g, "[^/]*").replace(/{{DOUBLESTAR}}/g, ".*").replace(/\?/g, ".");
-  if (!pattern.startsWith("http") && !pattern.startsWith("\\.")) {
-    pattern = ".*" + pattern;
-  }
-  return new RegExp("^" + pattern + "$", "i");
-}
-function matchGlob(pattern, url) {
-  return globToRegex(pattern).test(url);
-}
-function createResponsePredicate(urlOrPredicate) {
-  if (typeof urlOrPredicate === "function") {
-    return urlOrPredicate;
-  }
-  if (urlOrPredicate instanceof RegExp) {
-    return (resp) => urlOrPredicate.test(resp.url());
-  }
-  const regex = globToRegex(urlOrPredicate);
-  return (resp) => regex.test(resp.url());
-}
-function createRequestPredicate(urlOrPredicate) {
-  if (typeof urlOrPredicate === "function") {
-    return urlOrPredicate;
-  }
-  if (urlOrPredicate instanceof RegExp) {
-    return (req) => urlOrPredicate.test(req.url());
-  }
-  const regex = globToRegex(urlOrPredicate);
-  return (req) => regex.test(req.url());
-}
-function createXBResponse(data, conn, sessionId, requestData) {
-  const request = requestData ? createXBRequest(null, requestData) : createXBRequest(null, { requestId: data.requestId, url: data.url, method: "GET", headers: {}, postData: null, resourceType: "other" });
-  return {
-    status: () => data.status,
-    statusText: () => "",
-    url: () => data.url,
-    headers: () => data.headers,
-    ok: () => data.status >= 200 && data.status < 300,
-    body: async () => {
-      if (!conn) throw new Error("Response body not available");
-      try {
-        const resp = await conn.send(
-          "Network.getResponseBody",
-          { requestId: data.requestId },
-          sessionId
-        );
-        return Buffer.from(resp.body, resp.base64Encoded ? "base64" : "utf8");
-      } catch {
-        throw new Error("Response body not available");
-      }
-    },
-    text: async () => {
-      if (!conn) throw new Error("Response body not available");
-      try {
-        const resp = await conn.send(
-          "Network.getResponseBody",
-          { requestId: data.requestId },
-          sessionId
-        );
-        return resp.base64Encoded ? Buffer.from(resp.body, "base64").toString("utf8") : resp.body;
-      } catch {
-        throw new Error("Response body not available");
-      }
-    },
-    json: async () => {
-      const text = await (async () => {
-        if (!conn) throw new Error("Response body not available");
-        try {
-          const resp = await conn.send(
-            "Network.getResponseBody",
-            { requestId: data.requestId },
-            sessionId
-          );
-          return resp.base64Encoded ? Buffer.from(resp.body, "base64").toString("utf8") : resp.body;
-        } catch {
-          throw new Error("Response body not available");
-        }
-      })();
-      return JSON.parse(text);
-    },
-    request: () => request
-  };
-}
-function createXBRequest(page, data) {
-  return {
-    url: () => data.url,
-    method: () => data.method,
-    headers: () => data.headers,
-    postData: () => data.postData,
-    resourceType: () => data.resourceType,
-    response: async () => {
-      if (!page?._networkResponses) return null;
-      const resp = page._networkResponses.get(data.requestId);
-      if (!resp) return null;
-      return createXBResponse(resp, page._connection, page.sessionId, data);
-    }
-  };
-}
-function createXBRouteFetch(conn, sessionId, params) {
-  const request = createXBRequest(null, {
-    requestId: params.requestId,
-    url: params.request.url,
-    method: params.request.method,
-    headers: params.request.headers,
-    postData: params.request.postData ?? null,
-    resourceType: params.resourceType
-  });
-  return {
-    request: () => request,
-    abort: async (errorCode) => {
-      await conn.send("Fetch.failRequest", {
-        requestId: params.requestId,
-        errorReason: errorCode || "Failed"
-      }, sessionId);
-    },
-    continue: async (opts) => {
-      await conn.send("Fetch.continueRequest", {
-        requestId: params.requestId,
-        url: opts?.url,
-        method: opts?.method,
-        headers: opts?.headers ? Object.entries(opts.headers).map(([k, v]) => ({ name: k, value: v })) : void 0,
-        postData: opts?.postData ? Buffer.from(opts.postData).toString("base64") : void 0
-      }, sessionId);
-    },
-    fulfill: async (opts) => {
-      const bodyStr = typeof opts.body === "string" ? opts.body : opts.body ? opts.body.toString("utf8") : "";
-      const bodyBytes = Buffer.from(bodyStr, "utf8");
-      const headers = { ...opts.headers };
-      if (opts.contentType) headers["content-type"] = opts.contentType;
-      headers["access-control-allow-origin"] = "*";
-      await conn.send("Fetch.fulfillRequest", {
-        requestId: params.requestId,
-        responseCode: opts.status ?? 200,
-        responseHeaders: Object.entries(headers).map(([k, v]) => ({ name: k, value: v })),
-        body: bodyBytes.toString("base64")
-      }, sessionId);
-    }
-  };
-}
-
-// src/cdp-driver/page.ts
-var XBPageImpl = class _XBPageImpl {
-  conn;
-  _emitter = new EventEmitter();
-  _subscriptions = [];
-  sessionId;
-  _targetId;
-  _contextImpl;
-  _browserImpl;
-  _closed = false;
-  _url = "about:blank";
-  _title = "";
-  _viewportSize = null;
-  _loadState = {
-    loadFired: true,
-    domContentFired: true,
-    networkIdle: true
-  };
-  mouse;
-  keyboard;
-  // Network tracking for waitForLoadState('networkidle')
-  inflightRequests = /* @__PURE__ */ new Set();
-  networkIdleResolve = null;
-  networkIdleTimer = null;
-  static NETWORK_IDLE_MS = 500;
-  constructor(conn, sessionId, targetId, context, browser) {
-    this.conn = conn;
-    this.sessionId = sessionId;
-    this._targetId = targetId;
-    this._contextImpl = context;
-    this._browserImpl = browser;
-    this.mouse = new XBMouseImpl(conn, sessionId);
-    this.keyboard = new XBKeyboardImpl(conn, sessionId);
-  }
-  _emit(event, ...args) {
-    this._emitter.emit(event, ...args);
-  }
-  /** Internal initialization — must be called after construction */
-  async _init() {
-    await this.conn.send("Page.enable", void 0, this.sessionId);
-    await this.conn.send("Runtime.enable", void 0, this.sessionId);
-    await this.conn.send("Network.enable", void 0, this.sessionId);
-    this.setupPageEvents();
-    this.setupNetworkEvents();
-    this.setupConsoleEvents();
-    await this.conn.send("Runtime.runIfWaitingForDebugger", void 0, this.sessionId).catch(() => {
-    });
-    try {
-      const info = await this.conn.send(
-        "Target.getTargetInfo",
-        { targetId: this._targetId }
-      );
-      this._url = info.url;
-      this._title = info.title;
-    } catch {
-    }
-  }
-  get _connection() {
-    return this.conn;
-  }
-  // ── Navigation ──────────────────────────────────────────────
-  async goto(url, opts = {}) {
-    if (this._closed) throw new Error("Page is closed");
-    const waitUntil = opts.waitUntil ?? "load";
-    const timeout = opts.timeout ?? 3e4;
-    this._loadState = { loadFired: false, domContentFired: false, networkIdle: false };
-    const result = await this.conn.send(
-      "Page.navigate",
-      { url, referrer: opts.referer },
-      this.sessionId
-    );
-    if (result.errorText) {
-      throw new Error(`Navigation failed: ${result.errorText}`);
-    }
-    await this.waitForLoadState(waitUntil, timeout);
-    this._url = url;
-    const statusCode = 200;
-    const finalUrl = url;
-    const headers = {};
-    return {
-      status: () => statusCode,
-      ok: () => statusCode >= 200 && statusCode < 300,
-      url: () => finalUrl,
-      headers: () => headers
-    };
-  }
-  async goBack(opts = {}) {
-    await this.evaluate("() => history.back()");
-    await this.waitForLoadState(opts.waitUntil ?? "load", opts.timeout);
-  }
-  async goForward(opts = {}) {
-    await this.evaluate("() => history.forward()");
-    await this.waitForLoadState(opts.waitUntil ?? "load", opts.timeout);
-  }
-  async reload(opts = {}) {
-    this._loadState = { loadFired: false, domContentFired: false, networkIdle: false };
-    await this.conn.send("Page.reload", void 0, this.sessionId);
-    await this.waitForLoadState(opts.waitUntil ?? "load", opts.timeout);
-  }
-  async waitForLoadState(state = "load", timeout = 3e4) {
-    if (this._closed) throw new Error("Page is closed");
-    const checkState = () => {
-      switch (state) {
-        case "domcontentloaded":
-          return this._loadState.domContentFired;
-        case "load":
-          return this._loadState.loadFired;
-        case "networkidle":
-          return this._loadState.networkIdle;
-        case "commit":
-          return this._loadState.domContentFired;
-        default:
-          return true;
-      }
-    };
-    if (checkState()) return;
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        reject(new Error(`waitForLoadState('${state}') timeout after ${timeout}ms`));
-      }, timeout);
-      const check = () => {
-        if (checkState()) {
-          clearTimeout(timer);
-          resolve();
-        } else {
-          setTimeout(check, 50);
-        }
-      };
-      check();
-    });
-  }
-  async waitForTimeout(ms) {
-    await new Promise((resolve) => {
-      const timer = setTimeout(resolve, ms);
-      if (typeof timer.unref === "function") timer.unref();
-    });
-  }
-  async waitForSelector(selector, opts = {}) {
-    const state = opts.state ?? "visible";
-    const timeout = opts.timeout ?? 3e4;
-    const deadline = Date.now() + timeout;
-    while (Date.now() < deadline) {
-      const exists = await this.evaluate(
-        `(function() { const el = document.querySelector(${JSON.stringify(selector)}); return !!el; })()`
-      );
-      if (state === "attached" && exists) return;
-      if (state === "detached" && !exists) return;
-      if (state === "visible" && exists) {
-        const visible = await this.evaluate(
-          `(function() { const el = document.querySelector(${JSON.stringify(selector)}); if (!el) return false; const rect = el.getBoundingClientRect(); const style = window.getComputedStyle(el); return rect.width > 0 && rect.height > 0 && style.visibility !== 'hidden' && style.display !== 'none'; })()`
-        );
-        if (visible) return;
-      }
-      if (state === "hidden") {
-        if (!exists) return;
-        const visible = await this.evaluate(
-          `(function() { const el = document.querySelector(${JSON.stringify(selector)}); if (!el) return false; const rect = el.getBoundingClientRect(); const style = window.getComputedStyle(el); return rect.width > 0 && rect.height > 0 && style.visibility !== 'hidden' && style.display !== 'none'; })()`
-        );
-        if (!visible) return;
-      }
-      await this.waitForTimeout(100);
-    }
-    throw new Error(`waitForSelector('${selector}', state='${state}') timeout after ${timeout}ms`);
-  }
-  async waitForFunction(fn, opts = {}, ...args) {
-    const timeout = opts.timeout ?? 3e4;
-    const polling = opts.polling ?? 100;
-    const deadline = Date.now() + timeout;
-    const fnBody = typeof fn === "function" ? fn.toString() : fn;
-    let lastError = null;
-    while (Date.now() < deadline) {
-      try {
-        const result = await this.evaluate(
-          `(function(fnStr, ...evalArgs) { const fn = new Function('return ' + fnStr); return fn(...evalArgs); })(${JSON.stringify(fnBody)}${args.length > 0 ? ", " + args.map((a) => JSON.stringify(a)).join(", ") : ""})`
-        );
-        if (result) return result;
-      } catch (err) {
-        lastError = err;
-      }
-      const pollMs = typeof polling === "number" ? polling : 16;
-      await this.waitForTimeout(pollMs);
-    }
-    const detail = lastError ? `
-Last error: ${lastError.message}` : "";
-    throw new Error(`waitForFunction timeout after ${timeout}ms${detail}`);
-  }
-  url() {
-    return this._url;
-  }
-  async title() {
-    this._title = await this.evaluate("document.title");
-    return this._title;
-  }
-  async content() {
-    return this.evaluate("document.documentElement.outerHTML");
-  }
-  // ── Evaluation ──────────────────────────────────────────────
-  async evaluate(fn, ...args) {
-    if (this._closed) throw new Error("Page is closed");
-    let expression;
-    if (typeof fn === "string") {
-      expression = fn;
-    } else {
-      const argStr = args.length > 0 ? `...${JSON.stringify(args)}` : "";
-      expression = `(()=>{const __fn=(${fn.toString()});return __fn(${argStr});})()`;
-    }
-    const result = await this.conn.send("Runtime.evaluate", {
-      expression,
-      returnByValue: true,
-      awaitPromise: true
-    }, this.sessionId);
-    if (result.exceptionDetails) {
-      const detail = result.exceptionDetails.exception?.description ?? result.exceptionDetails.exception?.value ?? result.exceptionDetails.text;
-      throw new Error(`${detail}`);
-    }
-    return result.result?.value;
-  }
-  async $eval(selector, fn, ...args) {
-    const fnBody = typeof fn === "function" ? fn.toString() : fn;
-    return this.evaluate(
-      `(function(sel, fnStr, ...evalArgs) {
-        const el = document.querySelector(sel);
-        if (!el) throw new Error('No element found for selector: ' + sel);
-        const fn = new Function('return ' + fnStr)();
-        return fn(el, ...evalArgs);
-      })(${JSON.stringify(selector)}, ${JSON.stringify(fnBody)}${args.length > 0 ? ", " + args.map((a) => JSON.stringify(a)).join(", ") : ""})`
-    );
-  }
-  async $$eval(selector, fn, ...args) {
-    const fnBody = typeof fn === "function" ? fn.toString() : fn;
-    return this.evaluate(
-      `(function(sel, fnStr, ...evalArgs) {
-        const els = Array.from(document.querySelectorAll(sel));
-        const fn = new Function('return ' + fnStr)();
-        return fn(els, ...evalArgs);
-      })(${JSON.stringify(selector)}, ${JSON.stringify(fnBody)}${args.length > 0 ? ", " + args.map((a) => JSON.stringify(a)).join(", ") : ""})`
-    );
-  }
-  // ── Locator ─────────────────────────────────────────────────
-  locator(selector) {
-    return new XBLocatorImpl(this, selector);
-  }
-  getByText(text, opts) {
-    const escaped = text.replace(/'/g, "\\'");
-    if (opts?.exact) {
-      return this.locator(`xpath=//*[normalize-space(text())='${escaped}']`);
-    }
-    return this.locator(`xpath=//*[contains(text(),'${escaped}')]`);
-  }
-  getByRole(role, opts) {
-    let sel = `[role="${role}"]`;
-    if (opts?.name) {
-      sel += opts.exact ? `[aria-label="${opts.name}"]` : `[aria-label*="${opts.name}"]`;
-    }
-    return this.locator(sel);
-  }
-  getByLabel(label, opts) {
-    const escaped = label.replace(/'/g, "\\'");
-    const sel = opts?.exact ? `xpath=//*[@aria-label='${escaped}' or @id=//label[normalize-space(text())='${escaped}']/@for]` : `xpath=//*[contains(@aria-label,'${escaped}') or @id=//label[contains(text(),'${escaped}')]/@for]`;
-    return this.locator(sel);
-  }
-  getByPlaceholder(text, opts) {
-    return this.locator(
-      opts?.exact ? `[placeholder="${text}"]` : `[placeholder*="${text}"]`
-    );
-  }
-  getByTestId(id) {
-    return this.locator(`[data-testid="${id}"]`);
-  }
-  getByAltText(text, opts) {
-    return this.locator(opts?.exact ? `[alt="${text}"]` : `[alt*="${text}"]`);
-  }
-  getByTitle(title, opts) {
-    return this.locator(
-      opts?.exact ? `[title="${title}"]` : `[title*="${title}"]`
-    );
-  }
-  // ── Interaction shortcuts ───────────────────────────────────
-  async click(selector, opts = {}) {
-    await this.locator(selector).click(opts);
-  }
-  async dblclick(selector, opts = {}) {
-    await this.locator(selector).click({ ...opts, clickCount: 2 });
-  }
-  async fill(selector, value, opts = {}) {
-    await this.locator(selector).fill(value, opts);
-  }
-  async press(selector, key, opts) {
-    await this.locator(selector).press(key, opts);
-  }
-  async hover(selector, opts) {
-    await this.locator(selector).hover(opts);
-  }
-  async type(selector, text, opts = {}) {
-    await this.locator(selector).type(text, opts);
-  }
-  async check(selector, opts) {
-    await this.locator(selector).check(opts);
-  }
-  async uncheck(selector, opts) {
-    await this.locator(selector).uncheck(opts);
-  }
-  async selectOption(selector, value) {
-    return this.locator(selector).selectOption(value);
-  }
-  // ── Convenience selectors ───────────────────────────────────
-  async textContent(selector) {
-    return this.evaluate(
-      `(function() { const el = document.querySelector(${JSON.stringify(selector)}); return el?.textContent ?? null; })()`
-    );
-  }
-  async innerText(selector) {
-    return this.evaluate(
-      `(function() { const el = document.querySelector(${JSON.stringify(selector)}); if (!el) throw new Error('Element not found'); return el.innerText; })()`
-    );
-  }
-  async innerHTML(selector) {
-    return this.evaluate(
-      `(function() { const el = document.querySelector(${JSON.stringify(selector)}); if (!el) throw new Error('Element not found'); return el.innerHTML; })()`
-    );
-  }
-  async getAttribute(selector, name) {
-    return this.evaluate(
-      `(function() { const el = document.querySelector(${JSON.stringify(selector)}); return el?.getAttribute(${JSON.stringify(name)}) ?? null; })()`
-    );
-  }
-  // ── Query ───────────────────────────────────────────────────
-  async $(selector) {
-    const nodeId = await this.querySelector(selector);
-    if (!nodeId) return null;
-    return new XBElementHandleImpl(this, nodeId);
-  }
-  async $$(selector) {
-    const nodeIds = await this.querySelectorAll(selector);
-    return nodeIds.map((id) => new XBElementHandleImpl(this, id));
-  }
-  // ── Screen ──────────────────────────────────────────────────
-  async screenshot(opts = {}) {
-    const params = {
-      format: opts.type ?? "png"
-    };
-    if (opts.quality !== void 0 && (opts.type === "jpeg" || !opts.type && opts.quality)) {
-      params.quality = opts.quality;
-    }
-    if (opts.fullPage) {
-      params.captureBeyondViewport = true;
-    }
-    if (opts.clip) {
-      const clip = {
-        x: Math.round(opts.clip.x),
-        y: Math.round(opts.clip.y),
-        width: Math.round(Math.max(1, opts.clip.width)),
-        height: Math.round(Math.max(1, opts.clip.height)),
-        scale: 1
-      };
-      params.clip = clip;
-    }
-    if (opts.omitBackground) {
-      params.omitBackground = true;
-    }
-    const result = await this.conn.send(
-      "Page.captureScreenshot",
-      params,
-      this.sessionId
-    );
-    return Buffer.from(result.data, "base64");
-  }
-  async pdf(opts = {}) {
-    const params = {};
-    if (opts.landscape !== void 0) params.landscape = opts.landscape;
-    if (opts.printBackground !== void 0) params.printBackground = opts.printBackground;
-    if (opts.scale !== void 0) params.scale = opts.scale;
-    if (opts.format) params.paperFormat = opts.format;
-    if (opts.preferCSSPageSize !== void 0) params.preferCSSPageSize = opts.preferCSSPageSize;
-    if (opts.margin) {
-      if (opts.margin.top) params.marginTop = parseFloat(opts.margin.top);
-      if (opts.margin.bottom) params.marginBottom = parseFloat(opts.margin.bottom);
-      if (opts.margin.left) params.marginLeft = parseFloat(opts.margin.left);
-      if (opts.margin.right) params.marginRight = parseFloat(opts.margin.right);
-    }
-    const result = await this.conn.send("Page.printToPDF", params, this.sessionId);
-    return Buffer.from(result.data, "base64");
-  }
-  viewportSize() {
-    return this._viewportSize ?? null;
-  }
-  async setViewportSize(size) {
-    await this.conn.send(
-      "Emulation.setDeviceMetricsOverride",
-      {
-        width: size.width,
-        height: size.height,
-        deviceScaleFactor: 1,
-        mobile: false
-      },
-      this.sessionId
-    );
-    this._viewportSize = size;
-  }
-  // ── Scripts ─────────────────────────────────────────────────
-  async addInitScript(script) {
-    await this.conn.send(
-      "Page.addScriptToEvaluateOnNewDocument",
-      { source: script },
-      this.sessionId
-    );
-  }
-  /** Internal: set user agent */
-  async _setUserAgent(userAgent) {
-    await this.conn.send(
-      "Network.setUserAgentOverride",
-      { userAgent },
-      this.sessionId
-    );
-  }
-  /** Internal: set extra HTTP headers */
-  async _setExtraHTTPHeaders(headers) {
-    await this.setExtraHTTPHeaders(headers);
-  }
-  async bringToFront() {
-    await this.conn.send("Page.bringToFront", void 0, this.sessionId);
-  }
-  async setExtraHTTPHeaders(headers) {
-    await this.conn.send("Network.setExtraHTTPHeaders", { headers }, this.sessionId);
-  }
-  // ── Events ──────────────────────────────────────────────────
-  on(event, handler) {
-    this._emitter.on(event, handler);
-  }
-  off(event, handler) {
-    this._emitter.off(event, handler);
-  }
-  // ── Lifecycle ───────────────────────────────────────────────
-  async close() {
-    if (this._closed) return;
-    this._closed = true;
-    if (this.networkIdleTimer) {
-      clearTimeout(this.networkIdleTimer);
-      this.networkIdleTimer = null;
-    }
-    for (const unsub of this._subscriptions) {
-      unsub();
-    }
-    this._subscriptions = [];
-    await this._browserImpl._closeTarget(this._targetId).catch(() => {
-    });
-    await this._browserImpl._detachFromTarget(this.sessionId).catch(() => {
-    });
-    this._emitter.emit("close");
-  }
-  isClosed() {
-    return this._closed;
-  }
-  context() {
-    return this._contextImpl;
-  }
-  browser() {
-    return this._browserImpl;
-  }
-  mainFrame() {
-    return {
-      url: () => this._url,
-      name: () => "",
-      isDetached: () => this._closed,
-      page: () => this,
-      evaluate: (fn, ...args) => this.evaluate(fn, ...args),
-      $: (sel) => this.$(sel),
-      $$: (sel) => this.$$(sel)
-    };
-  }
-  frames() {
-    return [this.mainFrame()];
-  }
-  // ── CDP helpers exposed for locator/element ─────────────────
-  /** Query a single element, returns CDP nodeId or 0 if not found */
-  async querySelector(selector) {
-    const doc = await this.conn.send(
-      "DOM.getDocument",
-      { depth: 0 },
-      this.sessionId
-    );
-    const result = await this.conn.send(
-      "DOM.querySelector",
-      { nodeId: doc.root.nodeId, selector },
-      this.sessionId
-    );
-    return result.nodeId;
-  }
-  /** Query all matching elements, returns array of CDP nodeIds */
-  async querySelectorAll(selector) {
-    const doc = await this.conn.send(
-      "DOM.getDocument",
-      { depth: 0 },
-      this.sessionId
-    );
-    const result = await this.conn.send(
-      "DOM.querySelectorAll",
-      { nodeId: doc.root.nodeId, selector },
-      this.sessionId
-    );
-    return result.nodeIds ?? [];
-  }
-  /** Resolve a CDP nodeId to a RemoteObject for evaluate */
-  async resolveNode(nodeId) {
-    const result = await this.conn.send(
-      "DOM.resolveNode",
-      { nodeId },
-      this.sessionId
-    );
-    return result.object.objectId;
-  }
-  /** Get the box model for a nodeId */
-  async getBoxModel(nodeId) {
-    try {
-      const result = await this.conn.send("DOM.getBoxModel", { nodeId }, this.sessionId);
-      const c = result.model?.content;
-      if (!c || c.length < 8) return null;
-      const x1 = c[0];
-      const y1 = c[1];
-      const x2 = c[4];
-      const y2 = c[5];
-      return {
-        x: Math.min(x1, x2),
-        y: Math.min(y1, y2),
-        width: Math.abs(x2 - x1),
-        height: Math.abs(y2 - y1)
-      };
-    } catch {
-      return null;
-    }
-  }
-  /** Call a function on a RemoteObject */
-  async callFunctionOn(objectId, functionDeclaration, args = []) {
-    const result = await this.conn.send("Runtime.callFunctionOn", {
-      objectId,
-      functionDeclaration,
-      arguments: args.map((a) => ({ value: a })),
-      returnByValue: true
-    }, this.sessionId);
-    if (result.exceptionDetails) {
-      throw new Error(`CallFunctionOn error: ${result.exceptionDetails.text}`);
-    }
-    return result.result?.value;
-  }
-  /** Send a CDP command scoped to this page's session */
-  async _cdpSend(method, params) {
-    return this.conn.send(method, params, this.sessionId);
-  }
-  /** Subscribe to a CDP event on this page's session. Returns unsubscribe function. */
-  _subscribe(event, handler) {
-    return this.conn.subscribe(event, this.sessionId, handler);
-  }
-  // ── Private: Event Setup ────────────────────────────────────
-  setupPageEvents() {
-    this._subscriptions.push(
-      this.conn.subscribe("Page.frameNavigated", this.sessionId, (params) => {
-        const p = params;
-        if (p.frame) {
-          this._url = p.frame.url;
-        }
-        this._emit("framenavigated", this.mainFrame());
-      })
-    );
-    this._subscriptions.push(
-      this.conn.subscribe("Page.loadEventFired", this.sessionId, () => {
-        this._loadState.loadFired = true;
-      })
-    );
-    this._subscriptions.push(
-      this.conn.subscribe("Page.domContentEventFired", this.sessionId, () => {
-        this._loadState.domContentFired = true;
-      })
-    );
-    this._subscriptions.push(
-      this.conn.subscribe("Page.javascriptDialogOpening", this.sessionId, (params) => {
-        const p = params;
-        const dialog = {
-          type: p.type,
-          message: () => p.message,
-          defaultValue: () => p.defaultValue,
-          accept: async (text) => {
-            await this.conn.send("Page.handleJavaScriptDialog", {
-              accept: true,
-              promptText: text
-            }, this.sessionId);
-          },
-          dismiss: async () => {
-            await this.conn.send("Page.handleJavaScriptDialog", {
-              accept: false
-            }, this.sessionId);
-          }
-        };
-        this._emit("dialog", dialog);
-      })
-    );
-  }
-  setupNetworkEvents() {
-    this._subscriptions.push(
-      this.conn.subscribe("Network.requestWillBeSent", this.sessionId, (params) => {
-        const p = params;
-        this.inflightRequests.add(p.requestId);
-        this._storeNetworkRequest(p.requestId, {
-          url: p.request.url,
-          method: p.request.method,
-          headers: p.request.headers,
-          postData: p.request.postData ?? null,
-          resourceType: p.type
-        });
-        this._emit("request", p);
-        this.checkNetworkIdle();
-      })
-    );
-    this._subscriptions.push(
-      this.conn.subscribe("Network.responseReceived", this.sessionId, (params) => {
-        const p = params;
-        this._storeNetworkResponse(p.requestId, {
-          status: p.response.status,
-          url: p.response.url,
-          headers: p.response.headers
-        });
-        this._emit("response", p);
-      })
-    );
-    this._subscriptions.push(
-      this.conn.subscribe("Network.loadingFinished", this.sessionId, (params) => {
-        const p = params;
-        this.inflightRequests.delete(p.requestId);
-        this._emit("requestfinished", p);
-        this.checkNetworkIdle();
-      })
-    );
-    this._subscriptions.push(
-      this.conn.subscribe("Network.loadingFailed", this.sessionId, (params) => {
-        const p = params;
-        this.inflightRequests.delete(p.requestId);
-        this.checkNetworkIdle();
-      })
-    );
-  }
-  setupConsoleEvents() {
-    this._subscriptions.push(
-      this.conn.subscribe("Runtime.consoleAPICalled", this.sessionId, (params) => {
-        const p = params;
-        const text = p.args.map((a) => {
-          if (a.value !== void 0) return String(a.value);
-          return a.description ?? "";
-        }).join(" ");
-        const location = p.stackTrace?.callFrames?.[0] ? {
-          url: p.stackTrace.callFrames[0].url,
-          lineNumber: p.stackTrace.callFrames[0].lineNumber,
-          columnNumber: p.stackTrace.callFrames[0].columnNumber
-        } : { url: "", lineNumber: 0, columnNumber: 0 };
-        const msg = {
-          type: () => p.type,
-          text: () => text,
-          location: () => location
-        };
-        this._emit("console", msg);
-      })
-    );
-  }
-  checkNetworkIdle() {
-    if (this.inflightRequests.size === 0) {
-      if (this.networkIdleTimer) clearTimeout(this.networkIdleTimer);
-      this.networkIdleTimer = setTimeout(() => {
-        if (this.inflightRequests.size === 0) {
-          this._loadState.networkIdle = true;
-          if (this.networkIdleResolve) {
-            this.networkIdleResolve();
-            this.networkIdleResolve = null;
-          }
-        }
-      }, _XBPageImpl.NETWORK_IDLE_MS);
-    } else {
-      if (this.networkIdleTimer) {
-        clearTimeout(this.networkIdleTimer);
-        this.networkIdleTimer = null;
-      }
-    }
-  }
-  // ── Network Data Store (for waitForResponse/waitForRequest) ──
-  _networkResponses = /* @__PURE__ */ new Map();
-  _networkRequests = /* @__PURE__ */ new Map();
-  _routeHandlers = [];
-  _interceptionEnabled = false;
-  /** Store network data — called by browser.ts installNetworkCapture or internal event handlers */
-  _storeNetworkRequest(requestId, data) {
-    this._networkRequests.set(requestId, { requestId, ...data });
-  }
-  _storeNetworkResponse(requestId, data) {
-    this._networkResponses.set(requestId, { requestId, ...data });
-  }
-  // ── waitForResponse ─────────────────────────────────────────
-  async waitForResponse(urlOrPredicate, opts = {}) {
-    const timeout = opts.timeout ?? 3e4;
-    const predicate = createResponsePredicate(urlOrPredicate);
-    for (const [, data] of this._networkResponses) {
-      const response = createXBResponse(data, this.conn, this.sessionId);
-      if (predicate(response)) return response;
-    }
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this._emitter.removeListener("response", handler);
-        reject(new Error(`waitForResponse timed out after ${timeout}ms`));
-      }, timeout);
-      const handler = (params) => {
-        const p = params;
-        const data = {
-          requestId: p.requestId,
-          status: p.response.status,
-          url: p.response.url,
-          headers: p.response.headers
-        };
-        const response = createXBResponse(data, this.conn, this.sessionId);
-        if (predicate(response)) {
-          clearTimeout(timer);
-          this._emitter.removeListener("response", handler);
-          resolve(response);
-        }
-      };
-      this._emitter.on("response", handler);
-    });
-  }
-  // ── waitForRequest ──────────────────────────────────────────
-  async waitForRequest(urlOrPredicate, opts = {}) {
-    const timeout = opts.timeout ?? 3e4;
-    const predicate = createRequestPredicate(urlOrPredicate);
-    for (const [, data] of this._networkRequests) {
-      const request = createXBRequest(this, data);
-      if (predicate(request)) return request;
-    }
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this._emitter.removeListener("request", handler);
-        reject(new Error(`waitForRequest timed out after ${timeout}ms`));
-      }, timeout);
-      const handler = (params) => {
-        const p = params;
-        const data = {
-          requestId: p.requestId,
-          url: p.request.url,
-          method: p.request.method,
-          headers: p.request.headers,
-          postData: p.request.postData ?? null,
-          resourceType: p.type
-        };
-        const request = createXBRequest(this, data);
-        if (predicate(request)) {
-          clearTimeout(timer);
-          this._emitter.removeListener("request", handler);
-          resolve(request);
-        }
-      };
-      this._emitter.on("request", handler);
-    });
-  }
-  // ── waitForURL ──────────────────────────────────────────────
-  async waitForURL(url, opts = {}) {
-    const timeout = opts.timeout ?? 3e4;
-    const checkFn = typeof url === "function" ? url : typeof url === "string" ? (current) => matchGlob(url, current) : (current) => url.test(current);
-    if (checkFn(this._url)) return;
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this._emitter.removeListener("framenavigated", handler);
-        reject(new Error(`waitForURL timed out after ${timeout}ms`));
-      }, timeout);
-      const handler = () => {
-        if (checkFn(this._url)) {
-          clearTimeout(timer);
-          this._emitter.removeListener("framenavigated", handler);
-          resolve();
-        }
-      };
-      this._emitter.on("framenavigated", handler);
-    });
-  }
-  // ── route / unroute ─────────────────────────────────────────
-  async route(url, handler) {
-    const regex = typeof url === "string" ? globToRegex(url) : url;
-    this._routeHandlers.push({ pattern: String(url), regex, handler });
-    if (!this._interceptionEnabled) {
-      this._interceptionEnabled = true;
-      await this.conn.send("Fetch.enable", {
-        patterns: [{ urlPattern: "*", requestStage: "Request" }]
-      }, this.sessionId);
-      this._subscriptions.push(
-        this.conn.subscribe("Fetch.requestPaused", this.sessionId, (params) => {
-          this._handleRequestPaused(params);
-        })
-      );
-    }
-  }
-  async unroute(url, handler) {
-    const regex = typeof url === "string" ? globToRegex(url) : url;
-    this._routeHandlers = this._routeHandlers.filter(
-      (h) => !(regex.source === h.regex.source && (!handler || h.handler === handler))
-    );
-    if (this._routeHandlers.length === 0 && this._interceptionEnabled) {
-      this._interceptionEnabled = false;
-      await this.conn.send("Fetch.disable", void 0, this.sessionId).catch(() => {
-      });
-    }
-  }
-  async _handleRequestPaused(params) {
-    const requestUrl = params.request.url;
-    for (const { regex, handler } of this._routeHandlers) {
-      if (regex.test(requestUrl)) {
-        const route = createXBRouteFetch(this.conn, this.sessionId, params);
-        try {
-          await handler(route);
-        } catch {
-          await this.conn.send("Fetch.continueRequest", {
-            requestId: params.requestId
-          }, this.sessionId).catch(() => {
-          });
-        }
-        return;
-      }
-    }
-    await this.conn.send("Fetch.continueRequest", {
-      requestId: params.requestId
-    }, this.sessionId).catch(() => {
-    });
-  }
-  // ── setInputFiles ───────────────────────────────────────────
-  async setInputFiles(selector, files) {
-    const fileArr = Array.isArray(files) ? files : [files];
-    const fileList = fileArr.map((f) => ({
-      name: f.name,
-      type: f.mimeType,
-      dataBase64: f.buffer.toString("base64")
-    }));
-    await this.evaluate(`
-      (function() {
-        var selector = ${JSON.stringify(selector)};
-        var input = document.querySelector(selector);
-        if (!input) throw new Error('Element not found: ' + selector);
-
-        var fileList = ${JSON.stringify(fileList)};
-        var dt = new DataTransfer();
-
-        fileList.forEach(function(f) {
-          var binary = atob(f.dataBase64);
-          var bytes = new Uint8Array(binary.length);
-          for (var i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-          var blob = new Blob([bytes], { type: f.type });
-          var file = new File([blob], f.name, { type: f.type });
-          dt.items.add(file);
-        });
-
-        input.files = dt.files;
-        input.dispatchEvent(new Event('input', { bubbles: true }));
-        input.dispatchEvent(new Event('change', { bubbles: true }));
-      })()
-    `);
-  }
-  // ── dragAndDrop ─────────────────────────────────────────────
-  async dragAndDrop(source, target) {
-    const sourceRect = await this.evaluate(`
-      (function() {
-        const el = document.querySelector(${JSON.stringify(source)});
-        if (!el) throw new Error('Source not found: ${source}');
-        el.scrollIntoView({ behavior: 'instant', block: 'center' });
-        const r = el.getBoundingClientRect();
-        return { x: r.x, y: r.y, width: r.width, height: r.height };
-      })()
-    `);
-    const targetRect = await this.evaluate(`
-      (function() {
-        const el = document.querySelector(${JSON.stringify(target)});
-        if (!el) throw new Error('Target not found: ${target}');
-        el.scrollIntoView({ behavior: 'instant', block: 'center' });
-        const r = el.getBoundingClientRect();
-        return { x: r.x, y: r.y, width: r.width, height: r.height };
-      })()
-    `);
-    const sx = sourceRect.x + sourceRect.width / 2;
-    const sy = sourceRect.y + sourceRect.height / 2;
-    const tx = targetRect.x + targetRect.width / 2;
-    const ty = targetRect.y + targetRect.height / 2;
-    try {
-      await this.conn.send("Input.dispatchDragEvent", {
-        type: "dragStart",
-        x: sx,
-        y: sy,
-        data: { items: [], dragOperations: ["copy", "move", "link"] }
-      }, this.sessionId);
-      await this.conn.send("Input.dispatchDragEvent", {
-        type: "dragOver",
-        x: tx,
-        y: ty,
-        data: { items: [], dragOperations: ["copy", "move", "link"] }
-      }, this.sessionId);
-      await this.conn.send("Input.dispatchDragEvent", {
-        type: "drop",
-        x: tx,
-        y: ty,
-        data: { items: [], dragOperations: ["copy", "move", "link"] }
-      }, this.sessionId);
-      await this.conn.send("Input.dispatchDragEvent", {
-        type: "dragCancel",
-        x: sx,
-        y: sy,
-        data: { items: [], dragOperations: ["copy", "move", "link"] }
-      }, this.sessionId);
-    } catch {
-      await this.mouse.move(sx, sy);
-      await this.mouse.down();
-      await this.mouse.move(tx, ty, { steps: 10 });
-      await this.mouse.up();
-    }
-  }
-  // ── setOfflineMode ──────────────────────────────────────────
-  async setOfflineMode(offline) {
-    await this.conn.send("Network.emulateNetworkConditions", {
-      offline,
-      latency: 0,
-      downloadThroughput: offline ? 0 : -1,
-      uploadThroughput: offline ? 0 : -1
-    }, this.sessionId);
-  }
-};
-
-// src/cdp-driver/cdp-session.ts
-var XBCDPSessionImpl = class {
-  conn;
-  sessionId;
-  constructor(conn, sessionId) {
-    this.conn = conn;
-    this.sessionId = sessionId;
-  }
-  async send(method, params) {
-    return this.conn.send(method, params, this.sessionId);
-  }
-  on(event, handler) {
-    this.conn.on(event, (params, sid) => {
-      if (sid === this.sessionId || !this.sessionId && !sid) {
-        handler(params);
-      }
-    });
-  }
-  off(event, handler) {
-    this.conn.off(event, handler);
-  }
-  async detach() {
-    if (!this.sessionId) return;
-  }
-};
-
-// src/cdp-driver/context.ts
-var XBContextImpl = class {
-  conn;
-  _emitter = new EventEmitter2();
-  _browser;
-  contextId;
-  _pages = [];
-  closed = false;
-  options;
-  targetAttachedHandler = null;
-  _initScripts = [];
-  constructor(conn, contextId, browser, opts) {
-    this.conn = conn;
-    this.contextId = contextId;
-    this._browser = browser;
-    this.options = opts;
-    this.setupAutoAttach();
-  }
-  async newPage() {
-    if (this.closed) throw new Error("Context is closed");
-    const { targetId } = await this._browser._createTarget(this.contextId);
-    const sessionId = await this._browser._attachToTarget(targetId);
-    const page = new XBPageImpl(this.conn, sessionId, targetId, this, this._browser);
-    await page._init();
-    this._pages.push(page);
-    if (this.options.viewport) {
-      await page.setViewportSize(this.options.viewport).catch(() => {
-      });
-    }
-    if (this.options.userAgent) {
-      await page._setUserAgent(this.options.userAgent);
-    }
-    if (this.options.extraHTTPHeaders) {
-      await page._setExtraHTTPHeaders(this.options.extraHTTPHeaders);
-    }
-    for (const script of this._initScripts) {
-      await page.addInitScript(script);
-    }
-    return page;
-  }
-  pages() {
-    return [...this._pages];
-  }
-  browser() {
-    return this._browser;
-  }
-  async close() {
-    if (this.closed) return;
-    this.closed = true;
-    for (const page of this._pages) {
-      await page.close().catch(() => {
-      });
-    }
-    this._pages = [];
-    if (this.targetAttachedHandler) {
-      this.conn.off("Target.attachedToTarget", this.targetAttachedHandler);
-      this.targetAttachedHandler = null;
-    }
-    if (this.contextId && this.contextId !== "default") {
-      await this.conn.send("Target.disposeBrowserContext", {
-        browserContextId: this.contextId
-      }).catch(() => {
-      });
-    }
-    this._browser._removeContext(this.contextId);
-  }
-  async newCDPSession(_page) {
-    return new XBCDPSessionImpl(this.conn);
-  }
-  async addInitScript(script) {
-    this._initScripts.push(script);
-    for (const page of this._pages) {
-      await page.addInitScript(script);
-    }
-  }
-  // ── Cookies ─────────────────────────────────────────────────
-  async cookies(urls) {
-    const urlList = typeof urls === "string" ? [urls] : urls;
-    const result = await this.conn.send("Network.getCookies", urlList ? { urls: urlList } : void 0);
-    return result.cookies;
-  }
-  async addCookies(cookies) {
-    const cdpCookies = cookies.map((c) => ({
-      name: c.name,
-      value: c.value,
-      domain: c.domain,
-      path: c.path || "/",
-      expires: c.expires,
-      httpOnly: c.httpOnly,
-      secure: c.secure,
-      sameSite: c.sameSite
-    }));
-    await this.conn.send("Network.setCookies", { cookies: cdpCookies });
-  }
-  async clearCookies() {
-    await this.conn.send("Network.clearBrowserCookies");
-  }
-  on(event, handler) {
-    this._emitter.on(event, handler);
-  }
-  off(event, handler) {
-    this._emitter.off(event, handler);
-  }
-  // ── Private ─────────────────────────────────────────────────
-  setupAutoAttach() {
-    this.targetAttachedHandler = (paramsRaw) => {
-      const params = paramsRaw;
-      if (this.contextId !== "default" && params.targetInfo.browserContextId !== this.contextId) return;
-      if (params.targetInfo.type !== "page") return;
-      const exists = this._pages.some(
-        (p) => p._targetId === params.targetInfo.targetId
-      );
-      if (exists) return;
-      const page = new XBPageImpl(
-        this.conn,
-        params.sessionId,
-        params.targetInfo.targetId,
-        this,
-        this._browser
-      );
-      this.conn.send("Runtime.runIfWaitingForDebugger", void 0, params.sessionId).catch(() => {
-      });
-      page._init().then(async () => {
-        for (const script of this._initScripts) {
-          await page.addInitScript(script).catch(() => {
-          });
-        }
-        this._pages.push(page);
-        this._emitter.emit("page", page);
-      });
-    };
-    this.conn.on("Target.attachedToTarget", this.targetAttachedHandler);
-  }
-};
-
-// src/cdp-driver/browser.ts
-var XBBrowserImpl = class {
-  conn;
-  _emitter = new EventEmitter3();
-  _contexts = /* @__PURE__ */ new Map();
-  _disconnected = false;
-  childProcess = null;
-  tmpDir;
-  _exitHandler = null;
-  constructor(conn, childProcess, tmpDir) {
-    this.conn = conn;
-    this.childProcess = childProcess ?? null;
-    this.tmpDir = tmpDir;
-    conn.on("disconnect", () => {
-      this._disconnected = true;
-      this._emitter.emit("disconnected");
-    });
-    if (this.childProcess) {
-      this._exitHandler = () => {
-        try {
-          if (this.childProcess?.exitCode === null) {
-            this.childProcess.kill("SIGKILL");
-          }
-        } catch {
-        }
-        if (this.tmpDir) {
-          try {
-            const { rmSync } = __require("fs");
-            rmSync(this.tmpDir, { recursive: true, force: true });
-          } catch {
-          }
-        }
-      };
-      process.on("exit", this._exitHandler);
-    }
-  }
-  get disconnected() {
-    return this._disconnected;
-  }
-  /** The underlying CDP connection (for advanced use) */
-  get connection() {
-    return this.conn;
-  }
-  async close() {
-    if (this._disconnected) return;
-    this._disconnected = true;
-    for (const [, info] of this._contexts) {
-      await info.context.close().catch(() => {
-      });
-    }
-    this._contexts.clear();
-    if (this._exitHandler) {
-      process.removeListener("exit", this._exitHandler);
-      this._exitHandler = null;
-    }
-    if (this.childProcess) {
-      const { killChrome: killChrome2 } = await import("./launcher-KA7J32K5.js");
-      await killChrome2(this.childProcess, this.tmpDir);
-    }
-    await this.conn.close();
-    this._emitter.emit("disconnected");
-  }
-  async newContext(opts = {}) {
-    if (this._disconnected) {
-      throw new Error("Browser is disconnected");
-    }
-    let contextId = "default";
-    try {
-      const result = await this.conn.send(
-        "Target.createBrowserContext",
-        { disposeOnDetach: true },
-        void 0,
-        1e4
-        // 10s timeout instead of default 30s
-      );
-      contextId = result.browserContextId;
-    } catch {
-    }
-    const context = new XBContextImpl(this.conn, contextId, this, opts);
-    context.on("page", (page) => {
-      this._emitter.emit("page", page);
-    });
-    this._contexts.set(contextId, {
-      contextId,
-      context
-    });
-    return context;
-  }
-  contexts() {
-    return Array.from(this._contexts.values()).map((info) => info.context);
-  }
-  on(event, handler) {
-    this._emitter.on(event, handler);
-  }
-  off(event, handler) {
-    this._emitter.off(event, handler);
-  }
-  /** Called by context.close() to remove from registry */
-  _removeContext(contextId) {
-    this._contexts.delete(contextId);
-  }
-  // ── CDP helpers exposed for context/page ────────────────────
-  /** Attach to a target and get a session ID for flat protocol */
-  async _attachToTarget(targetId) {
-    const result = await this.conn.send(
-      "Target.attachToTarget",
-      { targetId, flatten: true }
-    );
-    return result.sessionId;
-  }
-  /** Detach from a target session */
-  async _detachFromTarget(sessionId) {
-    await this.conn.send("Target.detachFromTarget", { sessionId });
-  }
-  /** Create a new page target within a browser context */
-  async _createTarget(contextId, url = "about:blank") {
-    const params = { url };
-    if (contextId && contextId !== "default") {
-      params.browserContextId = contextId;
-    }
-    return this.conn.send("Target.createTarget", params);
-  }
-  /** Close a target */
-  async _closeTarget(targetId) {
-    await this.conn.send("Target.closeTarget", { targetId });
-  }
-  /** Enable auto-attach for new targets */
-  async _enableAutoAttach() {
-    await this.conn.send("Target.setAutoAttach", {
-      autoAttach: true,
-      waitForDebuggerOnStart: true,
-      flatten: true
-    });
-  }
-};
-
-// src/cdp-driver/connection.ts
-import { EventEmitter as EventEmitter4 } from "events";
-import { WebSocket } from "ws";
-var CDPConnection = class extends EventEmitter4 {
-  ws;
-  nextId = 1;
-  pending = /* @__PURE__ */ new Map();
-  closed = false;
-  closeReason = null;
-  /** Default session ID for flat session protocol (Target.attachToTarget) */
-  defaultSessionId;
-  constructor(wsOrUrl, sessionId) {
-    super();
-    this.defaultSessionId = sessionId;
-    if (typeof wsOrUrl === "string") {
-      this.ws = new WebSocket(wsOrUrl);
-    } else {
-      this.ws = wsOrUrl;
-    }
-    this.bindWebSocket();
-  }
-  /** Wait for the connection to be fully open */
-  async ready() {
-    if (this.ws.readyState === WebSocket.OPEN) return;
-    if (this.ws.readyState === WebSocket.CLOSED || this.ws.readyState === WebSocket.CLOSING) {
-      throw new Error(`WebSocket already closed: ${this.closeReason ?? "unknown"}`);
-    }
-    return new Promise((resolve, reject) => {
-      const onOpen = () => {
-        this.ws.off("error", onError);
-        resolve();
-      };
-      const onError = (err) => {
-        this.ws.off("open", onOpen);
-        reject(err);
-      };
-      this.ws.once("open", onOpen);
-      this.ws.once("error", onError);
-    });
-  }
-  /** Is the underlying WebSocket alive? */
-  get isOpen() {
-    return !this.closed && this.ws.readyState === WebSocket.OPEN;
-  }
-  /**
-   * Send a CDP command and await its response.
-   *
-   * @param method — CDP domain.method (e.g. "Page.navigate")
-   * @param params — method parameters
-   * @param sessionId — optional flat session ID for sub-targets
-   * @param timeoutMs — response timeout (default: 30s)
-   * @returns the `result` field from the CDP response
-   */
-  async send(method, params, sessionId, timeoutMs = 3e4) {
-    if (this.closed) {
-      throw new Error(`CDP connection closed: ${this.closeReason ?? "unknown"}`);
-    }
-    if (!this.isOpen) {
-      throw new Error(`CDP connection not open (state: ${this.ws.readyState})`);
-    }
-    const id = this.nextId++;
-    const sid = sessionId ?? this.defaultSessionId;
-    const message = { id, method };
-    if (params !== void 0) message.params = params;
-    if (sid !== void 0) message.sessionId = sid;
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.pending.delete(id);
-        reject(new Error(`CDP timeout: ${method} (${timeoutMs}ms)`));
-      }, timeoutMs);
-      this.pending.set(id, {
-        resolve: (v) => {
-          clearTimeout(timeout);
-          this.pending.delete(id);
-          resolve(v);
-        },
-        reject: (err) => {
-          clearTimeout(timeout);
-          this.pending.delete(id);
-          reject(err);
-        },
-        method,
-        timeout
-      });
-      const data = JSON.stringify(message);
-      try {
-        this.ws.send(data);
-      } catch (err) {
-        clearTimeout(timeout);
-        this.pending.delete(id);
-        reject(new Error(`CDP send failed: ${method} \u2014 ${err instanceof Error ? err.message : String(err)}`));
-      }
-    });
-  }
-  /**
-   * Subscribe to a CDP event.
-   *
-   * @param event — full event name (e.g. "Page.frameNavigated")
-   * @param handler — called with the event params
-   * @param sessionId — optional session filter
-   */
-  on(event, handler) {
-    return super.on(event, handler);
-  }
-  once(event, handler) {
-    return super.once(event, handler);
-  }
-  /** Remove an event listener */
-  off(event, handler) {
-    super.off(event, handler);
-    return this;
-  }
-  /**
-   * Subscribe to a CDP event for a specific session.
-   * Returns an unsubscribe function.
-   */
-  subscribe(event, sessionId, handler) {
-    const wrapper = (params, sid) => {
-      if (sid === sessionId || !sessionId && !sid) handler(params);
-    };
-    this.on(event, wrapper);
-    return () => this.off(event, wrapper);
-  }
-  /** Close the WebSocket */
-  async close() {
-    if (this.closed) return;
-    this.closed = true;
-    this.closeReason = "closed by caller";
-    for (const [id, pending] of this.pending) {
-      clearTimeout(pending.timeout);
-      pending.reject(new Error(`Connection closed: ${pending.method}`));
-      this.pending.delete(id);
-    }
-    if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
-      this.ws.close(1e3, "normal closure");
-    }
-  }
-  /** Set the default session ID for flat protocol */
-  setDefaultSessionId(sid) {
-    this.defaultSessionId = sid;
-  }
-  // ── Private ─────────────────────────────────────────────────
-  bindWebSocket() {
-    this.ws.on("message", (raw) => {
-      let msg;
-      try {
-        msg = JSON.parse(raw.toString());
-      } catch {
-        return;
-      }
-      if (msg.id !== void 0) {
-        const pending = this.pending.get(msg.id);
-        if (!pending) return;
-        if (msg.error) {
-          pending.reject(new CDPProtocolError(msg.error.code, msg.error.message, pending.method));
-        } else {
-          pending.resolve(msg.result ?? {});
-        }
-        return;
-      }
-      if (msg.method) {
-        this.emit(msg.method, msg.params ?? {}, msg.sessionId);
-        this.emit("*", msg.method, msg.params ?? {}, msg.sessionId);
-      }
-    });
-    this.ws.on("close", (code, reason) => {
-      if (this.closed) return;
-      this.closed = true;
-      this.closeReason = `WebSocket closed: ${code} ${reason?.toString() ?? ""}`.trim();
-      for (const [id, pending] of this.pending) {
-        clearTimeout(pending.timeout);
-        pending.reject(new Error(`Connection closed: ${pending.method}`));
-        this.pending.delete(id);
-      }
-      this.emit("disconnect");
-    });
-    this.ws.on("error", (err) => {
-      if (this.closed) return;
-      this.emit("ws-error", err);
-    });
-  }
-};
-var CDPProtocolError = class extends Error {
-  code;
-  method;
-  data;
-  constructor(code, message, method, data) {
-    super(`CDP error [${code}] in ${method}: ${message}`);
-    this.name = "CDPProtocolError";
-    this.code = code;
-    this.method = method;
-    this.data = data;
-  }
-};
+  launch
+} from "./chunk-PPG4D2EW.js";
 
-// src/cdp-driver/index.ts
-async function launch(options = {}) {
-  let wsEndpoint;
-  let childProcess;
-  let tmpDir;
-  if (options.cdpEndpoint) {
-    wsEndpoint = await connectToCDP(options.cdpEndpoint);
-  } else {
-    const result = await launchChrome({
-      executablePath: options.executablePath,
-      headless: options.headless,
-      args: options.args,
-      userDataDir: options.userDataDir,
-      timeout: options.timeout,
-      env: options.env
-    });
-    wsEndpoint = result.wsEndpoint;
-    childProcess = result.process;
-    tmpDir = result.tmpDir;
-  }
-  const conn = new CDPConnection(wsEndpoint);
-  await conn.ready();
-  const browser = new XBBrowserImpl(conn, childProcess, tmpDir);
-  return { browser, wsEndpoint };
-}
+// src/browser.ts
+import { randomUUID } from "crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
 
 // src/cdp-interceptor/proxy.ts
-import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
+import { WebSocketServer, WebSocket } from "ws";
 
 // src/cdp-interceptor/rules/shared.ts
 var PLAYWRIGHT_INTERNAL_MARKERS = [
@@ -3695,9 +1246,9 @@ var CDPInterceptorProxy = class {
     let browserWs = null;
     let isAlive = true;
     const pendingMessages = [];
-    browserWs = new WebSocket2(this.config.cdpEndpoint);
+    browserWs = new WebSocket(this.config.cdpEndpoint);
     clientWs.on("message", (raw) => {
-      if (browserWs && browserWs.readyState === WebSocket2.OPEN) {
+      if (browserWs && browserWs.readyState === WebSocket.OPEN) {
         this.handleClientMessage(clientWs, browserWs, raw);
       } else {
         pendingMessages.push(raw);
@@ -3713,7 +1264,7 @@ var CDPInterceptorProxy = class {
       this.logger.info("Browser WebSocket error", { error: String(err) });
     });
     browserWs.on("close", (code, reason) => {
-      if (isAlive && clientWs.readyState === WebSocket2.OPEN) {
+      if (isAlive && clientWs.readyState === WebSocket.OPEN) {
         this.logger.info("Browser WS closed, closing client", { code, reason: String(reason) });
         clientWs.close();
       }
@@ -3723,14 +1274,14 @@ var CDPInterceptorProxy = class {
     });
     const cleanup = () => {
       isAlive = false;
-      if (browserWs && browserWs.readyState === WebSocket2.OPEN) {
+      if (browserWs && browserWs.readyState === WebSocket.OPEN) {
         browserWs.close();
       }
     };
     clientWs.on("close", cleanup);
     clientWs.on("error", cleanup);
     browserWs.on("close", () => {
-      if (isAlive && clientWs.readyState === WebSocket2.OPEN) {
+      if (isAlive && clientWs.readyState === WebSocket.OPEN) {
         clientWs.close();
       }
     });
@@ -3879,6 +1430,7 @@ async function resolveCDPEndpoint(raw) {
 }
 
 // src/browser.ts
+import { SessionStore } from "@dyyz1993/xcli-core";
 function logSessionEvent(event, details) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").substring(0, 19);
   const pid = process.pid;
@@ -3891,7 +1443,7 @@ function sessionFile(name) {
 function ensureSessionDir() {
   mkdirSync(SESSION_DIR, { recursive: true });
 }
-var sessions = /* @__PURE__ */ new Map();
+var sessions = new SessionStore();
 var _sharedBrowser = null;
 var _sharedCdpProxy = null;
 var IDLE_TIMEOUT_MS = (process.env.XBROWSER_IDLE_TIMEOUT ? parseInt(process.env.XBROWSER_IDLE_TIMEOUT, 10) : 30) * 60 * 1e3;
@@ -3902,7 +1454,7 @@ function resetIdleTimer() {
     const now = Date.now();
     let allIdle = true;
     const idleSessions = [];
-    for (const [, s] of sessions) {
+    for (const s of sessions) {
       if (now - s.lastActivityAt < IDLE_TIMEOUT_MS) {
         allIdle = false;
       } else {
@@ -3925,7 +1477,7 @@ function touchSession(id) {
   resetIdleTimer();
 }
 process.on("exit", () => {
-  for (const session of sessions.values()) {
+  for (const session of sessions.list()) {
     if (session.isCDP) {
       logSessionEvent("process_exit", `Session "${session.name}": CDP connection (not closing external browser).`);
     } else {
@@ -3953,7 +1505,7 @@ process.on("exit", () => {
   }
   sessions.clear();
 });
-async function getCDPTargets2(cdpEndpoint) {
+async function getCDPTargets(cdpEndpoint) {
   try {
     const ep = String(cdpEndpoint);
     let host = "localhost";
@@ -3973,7 +1525,7 @@ async function getCDPTargets2(cdpEndpoint) {
   }
 }
 async function findTargetPage(cdpEndpoint, target) {
-  const targets = await getCDPTargets2(cdpEndpoint);
+  const targets = await getCDPTargets(cdpEndpoint);
   const pages = targets.filter((t) => t.url && !t.url.startsWith("about:blank") && !t.url.startsWith("chrome://"));
   const byId = pages.find((t) => t.id === target);
   if (byId) return { pageId: byId.id, wsUrl: byId.webSocketDebuggerUrl, title: byId.title, url: byId.url };
@@ -4015,6 +1567,9 @@ async function createBrowser(options) {
       return browser3;
     }
     const { browser: browser2 } = await launch({ cdpEndpoint: realEndpoint });
+    await browser2.discoverContexts().catch((err) => {
+      console.error(`[browser] discoverContexts failed: ${err.message}`);
+    });
     return browser2;
   }
   const executablePath = options?.executablePath || process.env.XBROWSER_CHROMIUM_PATH || discoverChromiumPath();
@@ -4029,10 +1584,7 @@ async function getBrowser(options) {
   return _sharedBrowser;
 }
 function findSession(name) {
-  for (const [, session] of sessions) {
-    if (session.name === name) return session;
-  }
-  return void 0;
+  return sessions.find(name);
 }
 function getSessionById(id) {
   return sessions.get(id);
@@ -4111,7 +1663,7 @@ async function findOrRestoreSession(name, cdpEndpoint) {
     }
     page = page || fallbackPage;
     if (!page) {
-      const targets = await getCDPTargets2(ep);
+      const targets = await getCDPTargets(ep);
       const matchTarget = targets.find(
         (t) => t.url && t.url !== "about:blank" && !t.url.startsWith("chrome://") && (targetHostname ? t.url.includes(targetHostname) : true)
       );
@@ -4136,9 +1688,14 @@ async function findOrRestoreSession(name, cdpEndpoint) {
       return void 0;
     }
     const targetUrl = meta.conversationUrl || meta.url;
-    if (targetUrl && page.url() !== targetUrl && !page.url().includes(new URL(targetUrl).hostname)) {
-      await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 3e4 }).catch(() => {
-      });
+    if (targetUrl && page.url() !== targetUrl) {
+      try {
+        if (!page.url().includes(new URL(targetUrl).hostname)) {
+          await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 3e4 }).catch(() => {
+          });
+        }
+      } catch {
+      }
     }
     const session = {
       id: meta.id || randomUUID(),
@@ -4151,13 +1708,13 @@ async function findOrRestoreSession(name, cdpEndpoint) {
       isCDP: true,
       cdpEndpoint: ep
     };
-    for (const [existingId, existingSession] of sessions) {
+    for (const existingSession of sessions.list()) {
       if (existingSession.name === name) {
-        logSessionEvent("remove_stale", `Removing stale session name="${name}" id="${existingId}" during restore`);
-        sessions.delete(existingId);
+        logSessionEvent("remove_stale", `Removing stale session name="${name}" id="${existingSession.id}" during restore`);
+        sessions.removeById(existingSession.id);
       }
     }
-    sessions.set(session.id, session);
+    sessions.set(session);
     resetIdleTimer();
     await installNetworkCapture(page, name);
     return session;
@@ -4173,7 +1730,12 @@ async function createEphemeralContext(options) {
     const { browser: b2 } = await launch({ cdpEndpoint: endpoint });
     const contexts = b2.contexts();
     const ctx = contexts[0] || await b2.newContext();
-    const page2 = await ctx.newPage();
+    const allPages = ctx.pages();
+    const existingPages = allPages.filter((p) => {
+      const url = p.url();
+      return url !== "about:blank" && !url.startsWith("chrome://");
+    });
+    const page2 = existingPages.length > 0 ? existingPages[0] : allPages.length > 0 ? allPages[0] : await ctx.newPage();
     resetIdleTimer();
     ephemeralConnections.set(page2, b2);
     return { context: ctx, page: page2 };
@@ -4205,11 +1767,11 @@ async function closeEphemeralContext(context) {
   }
 }
 function getAllSessions() {
-  return Array.from(sessions.values());
+  return sessions.list();
 }
 async function installNetworkCapture(page, sessionName) {
   if (process.env.XBROWSER_DAEMON_WORKER !== "1") return;
-  const { networkStore } = await import("./network-store-BN6QEZ7R.js");
+  const { networkStore } = await import("./network-store-XGZ25FFC.js");
   const requestData = /* @__PURE__ */ new Map();
   const responseMeta = /* @__PURE__ */ new Map();
   const xbPage = page;
@@ -4330,19 +1892,41 @@ async function createSession(name, url, options) {
     }
     context = contexts[0] || await b.newContext();
     let targetPage = null;
-    for (const ctx of contexts) {
-      const pages = ctx.pages();
-      for (const p of pages) {
-        const pUrl = p.url();
-        if (pUrl && pUrl !== "about:blank" && !pUrl.startsWith("chrome://")) {
-          targetPage = p;
-          break;
+    const targetHostname = url ? (() => {
+      try {
+        return new URL(url).hostname;
+      } catch {
+        return "";
+      }
+    })() : "";
+    if (targetHostname) {
+      for (const ctx of contexts) {
+        const pages = ctx.pages();
+        for (const p of pages) {
+          const pUrl = p.url();
+          if (pUrl && pUrl !== "about:blank" && !pUrl.startsWith("chrome://") && pUrl.includes(targetHostname)) {
+            targetPage = p;
+            break;
+          }
+        }
+        if (targetPage) break;
+      }
+    }
+    if (!targetPage) {
+      for (const ctx of contexts) {
+        const pages = ctx.pages();
+        for (const p of pages) {
+          const pUrl = p.url();
+          if (pUrl && pUrl !== "about:blank" && !pUrl.startsWith("chrome://")) {
+            targetPage = p;
+            break;
+          }
         }
+        if (targetPage) break;
       }
-      if (targetPage) break;
     }
     if (!targetPage && options?.cdpEndpoint) {
-      const targets = await getCDPTargets2(options.cdpEndpoint);
+      const targets = await getCDPTargets(options.cdpEndpoint);
       const matchTarget = targets.find(
         (t) => t.url && t.url !== "about:blank" && !t.url.startsWith("chrome://") && (url ? t.url.includes(new URL(url).hostname) : true)
       );
@@ -4380,14 +1964,14 @@ async function createSession(name, url, options) {
     isCDP,
     cdpEndpoint: options?.cdpEndpoint
   };
-  sessions.set(session.id, session);
+  sessions.set(session);
   logSessionEvent("create_session", `name="${name}" id="${session.id}" url="${url || "(no url)"}" isCDP=${isCDP} cdpEndpoint=${options?.cdpEndpoint || "(none)"}`);
   resetIdleTimer();
   await installNetworkCapture(page, name);
   return session;
 }
 async function closeSessionByName(name) {
-  for (const [id, session] of sessions) {
+  for (const session of sessions) {
     if (session.name === name || session.id === name) {
       logSessionEvent("close_session", `name="${session.name}" id="${session.id}" url="${session.page.url()}"`);
       if (session.isCDP) {
@@ -4406,20 +1990,20 @@ async function closeSessionByName(name) {
           });
         }
       }
-      sessions.delete(id);
+      sessions.removeById(session.id);
       const file2 = sessionFile(session.name);
       try {
         unlinkSync(file2);
       } catch {
       }
       try {
-        const { networkStore, commandLogStore } = await import("./network-store-BN6QEZ7R.js");
+        const { networkStore, commandLogStore } = await import("./network-store-XGZ25FFC.js");
         networkStore.clear(session.name);
         commandLogStore.clear(session.name);
       } catch {
       }
       try {
-        const { SessionRecorder } = await import("./session-recorder-MA75PKTQ.js");
+        const { SessionRecorder } = await import("./session-recorder-YI7YYM36.js");
         SessionRecorder.cleanup(session.name);
       } catch {
       }
@@ -4434,9 +2018,9 @@ async function closeSessionByName(name) {
   return false;
 }
 async function closeAllSessions() {
-  const names = [...sessions.values()].map((s) => `${s.name}(${s.page.url()})`).join(", ");
+  const names = sessions.list().map((s) => `${s.name}(${s.page.url()})`).join(", ");
   if (names) logSessionEvent("close_all_sessions", `Closing ${sessions.size} sessions: ${names}`);
-  for (const [id, session] of sessions) {
+  for (const session of sessions.list()) {
     try {
       if (!session.isCDP) {
         await session.context.close();
@@ -4445,9 +2029,9 @@ async function closeAllSessions() {
         await session.browser.close().catch(() => {
         });
       }
-      sessions.delete(id);
+      sessions.removeById(session.id);
     } catch {
-      sessions.delete(id);
+      sessions.removeById(session.id);
     }
   }
 }
@@ -4485,7 +2069,7 @@ async function ensureProcessCanExit() {
     clearTimeout(idleTimer);
     idleTimer = null;
   }
-  for (const session of sessions.values()) {
+  for (const session of sessions.list()) {
     if (session.browser) {
       if (session.isCDP) {
         await session.browser.close().catch(() => {
@@ -4511,6 +2095,7 @@ async function ensureProcessCanExit() {
 
 export {
   createRuleEngine,
+  resolveCDPEndpoint,
   touchSession,
   findTargetPage,
   resolveLaunchOpts,