@ohos-ports/vibium 26.5.31-beta.0

package/dist/index.js

@@ -0,0 +1,3395 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Browser: () => Browser,
+  BrowserContext: () => BrowserContext,
+  BrowserContextSync: () => BrowserContextSync,
+  BrowserCrashedError: () => BrowserCrashedError,
+  BrowserSync: () => BrowserSync,
+  Clock: () => Clock,
+  ClockSync: () => ClockSync,
+  ConnectionError: () => ConnectionError,
+  ConsoleMessage: () => ConsoleMessage,
+  Dialog: () => Dialog,
+  Download: () => Download,
+  Element: () => Element,
+  ElementNotFoundError: () => ElementNotFoundError,
+  ElementSync: () => ElementSync,
+  Keyboard: () => Keyboard,
+  KeyboardSync: () => KeyboardSync,
+  Mouse: () => Mouse,
+  MouseSync: () => MouseSync,
+  Page: () => Page,
+  PageSync: () => PageSync,
+  Recording: () => Recording,
+  RecordingSync: () => RecordingSync,
+  Request: () => Request,
+  Response: () => Response,
+  Route: () => Route,
+  TimeoutError: () => TimeoutError,
+  Touch: () => Touch,
+  TouchSync: () => TouchSync,
+  WebSocketInfo: () => WebSocketInfo,
+  browser: () => browser,
+  fluent: () => fluent
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/clicker/platform.ts
+var import_os = __toESM(require("os"));
+function getPlatform() {
+  const platform = import_os.default.platform();
+  if (platform === "linux" || platform === "darwin" || platform === "win32") {
+    return platform;
+  }
+  if (platform === "openharmony") {
+    return "linux";
+  }
+  throw new Error(`Unsupported platform: ${platform}`);
+}
+function getArch() {
+  const arch = import_os.default.arch();
+  if (arch === "x64" || arch === "arm64") {
+    return arch;
+  }
+  throw new Error(`Unsupported architecture: ${arch}`);
+}
+
+// src/clicker/binary.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_module = require("module");
+var moduleRequire = (0, import_module.createRequire)(__filename);
+function getVibiumBinPath() {
+  const envPath = process.env.VIBIUM_BIN_PATH;
+  if (envPath && import_fs.default.existsSync(envPath)) {
+    return envPath;
+  }
+  const platform = getPlatform();
+  const arch = getArch();
+  const packageName = `@ohos-ports/vibium-${platform}-${arch}`;
+  const binaryName = platform === "win32" ? "vibium.exe" : "vibium";
+  try {
+    const packagePath = moduleRequire.resolve(`${packageName}/package.json`);
+    const packageDir = import_path.default.dirname(packagePath);
+    const binaryPath = import_path.default.join(packageDir, "bin", binaryName);
+    if (import_fs.default.existsSync(binaryPath)) {
+      return binaryPath;
+    }
+  } catch {
+  }
+  const localPaths = [
+    // From vibium/ root
+    import_path.default.resolve(process.cwd(), "clicker", "bin", binaryName),
+    // From clients/javascript/
+    import_path.default.resolve(process.cwd(), "..", "..", "clicker", "bin", binaryName)
+  ];
+  for (const localPath of localPaths) {
+    if (import_fs.default.existsSync(localPath)) {
+      return localPath;
+    }
+  }
+  throw new Error(
+    `Could not find vibium binary. Set VIBIUM_BIN_PATH environment variable or install ${packageName}. On HarmonyOS, the vibium binary is a static Go binary that runs after signing with binary-sign-tool, but browser automation also requires Chrome/Chromium which is not available on HarmonyOS.`
+  );
+}
+
+// src/clicker/process.ts
+var import_child_process = require("child_process");
+
+// src/utils/errors.ts
+var ConnectionError = class extends Error {
+  constructor(url, cause) {
+    super(cause ? `Failed to connect to ${url}: ${cause.message}` : `Failed to connect to ${url}`);
+    this.url = url;
+    this.cause = cause;
+    this.name = "ConnectionError";
+  }
+};
+var TimeoutError = class extends Error {
+  constructor(selector, timeout, reason) {
+    const msg = reason ? `Timeout after ${timeout}ms waiting for '${selector}': ${reason}` : `Timeout after ${timeout}ms waiting for '${selector}'`;
+    super(msg);
+    this.selector = selector;
+    this.timeout = timeout;
+    this.reason = reason;
+    this.name = "TimeoutError";
+  }
+};
+var ElementNotFoundError = class extends Error {
+  constructor(selector) {
+    super(`Element not found: ${selector}`);
+    this.selector = selector;
+    this.name = "ElementNotFoundError";
+  }
+};
+var BrowserCrashedError = class extends Error {
+  constructor(exitCode, output) {
+    const msg = output ? `Browser crashed with exit code ${exitCode}: ${output}` : `Browser crashed with exit code ${exitCode}`;
+    super(msg);
+    this.exitCode = exitCode;
+    this.output = output;
+    this.name = "BrowserCrashedError";
+  }
+};
+
+// src/clicker/process.ts
+var VibiumProcess = class _VibiumProcess {
+  constructor(process2, preReadyLines) {
+    this._stopped = false;
+    this._preReadyLines = [];
+    this._cleanupListeners = null;
+    this._process = process2;
+    this._preReadyLines = preReadyLines;
+  }
+  /** The child process stdin stream (for sending commands). */
+  get stdin() {
+    return this._process.stdin;
+  }
+  /** The child process stdout stream (for receiving responses/events). */
+  get stdout() {
+    return this._process.stdout;
+  }
+  /** Lines received before the vibium:lifecycle.ready signal (buffered events). */
+  get preReadyLines() {
+    return this._preReadyLines;
+  }
+  static async start(options = {}) {
+    const binaryPath = options.executablePath || getVibiumBinPath();
+    const args = ["pipe"];
+    if (options.headless === true) {
+      args.push("--headless=old");
+    }
+    if (options.connectURL) {
+      args.push("--connect", options.connectURL);
+    }
+    if (options.connectHeaders) {
+      for (const [key, value] of Object.entries(options.connectHeaders)) {
+        args.push("--connect-header", `${key}: ${value}`);
+      }
+    }
+    const proc = (0, import_child_process.spawn)(binaryPath, args, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const killSpawnedChild = () => {
+      try {
+        if (proc.exitCode === null) proc.kill("SIGKILL");
+      } catch {
+      }
+    };
+    const preReadyLines = [];
+    let readyOK = false;
+    try {
+      await new Promise((resolve, reject) => {
+        let buffer = "";
+        let stderrBuffer = "";
+        let resolved = false;
+        const timeout = setTimeout(() => {
+          if (!resolved) {
+            resolved = true;
+            reject(new TimeoutError("vibium", 6e4, "waiting for vibium ready signal"));
+          }
+        }, 6e4);
+        const handleData = (data) => {
+          buffer += data.toString();
+          let newlineIdx;
+          while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+            const line = buffer.slice(0, newlineIdx).trim();
+            buffer = buffer.slice(newlineIdx + 1);
+            if (!line) continue;
+            try {
+              const msg = JSON.parse(line);
+              if (msg.method === "vibium:lifecycle.ready") {
+                if (!resolved) {
+                  resolved = true;
+                  clearTimeout(timeout);
+                  proc.stdout?.removeListener("data", handleData);
+                  resolve();
+                }
+                return;
+              }
+            } catch {
+            }
+            preReadyLines.push(line);
+          }
+        };
+        proc.stdout?.on("data", handleData);
+        proc.stderr?.on("data", (data) => {
+          stderrBuffer += data.toString();
+        });
+        proc.on("error", (err) => {
+          if (!resolved) {
+            resolved = true;
+            clearTimeout(timeout);
+            reject(err);
+          }
+        });
+        proc.on("exit", (code) => {
+          if (!resolved) {
+            resolved = true;
+            clearTimeout(timeout);
+            let combinedOutput = (buffer + (stderrBuffer ? "\n" + stderrBuffer : "")).trim();
+            if (process.platform === "openharmony" && /chromedriver|chrome|browser/i.test(combinedOutput)) {
+              combinedOutput += "\n\n[HarmonyOS] Local browser launch failed. Chromium is available via Alpine musl + LD_PRELOAD. Ensure Alpine Chromium and shared libraries are installed.\n  export VIBIUM_CONNECT_URL=ws://<remote-host>:9222/session\n  browser.start() will auto-detect VIBIUM_CONNECT_URL";
+            }
+            reject(new BrowserCrashedError(code ?? 1, combinedOutput));
+          }
+        });
+      });
+      readyOK = true;
+    } finally {
+      if (!readyOK) killSpawnedChild();
+    }
+    const vp = new _VibiumProcess(proc, preReadyLines);
+    const cleanup = () => vp.stop();
+    process.on("exit", cleanup);
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    vp._cleanupListeners = cleanup;
+    return vp;
+  }
+  async stop() {
+    if (this._stopped) return;
+    this._stopped = true;
+    if (this._cleanupListeners) {
+      process.removeListener("exit", this._cleanupListeners);
+      process.removeListener("SIGINT", this._cleanupListeners);
+      process.removeListener("SIGTERM", this._cleanupListeners);
+      this._cleanupListeners = null;
+    }
+    return new Promise((resolve) => {
+      let resolved = false;
+      const done = () => {
+        if (!resolved) {
+          resolved = true;
+          resolve();
+        }
+      };
+      this._process.on("exit", done);
+      try {
+        this._process.stdin?.end();
+      } catch {
+      }
+      if (process.platform === "win32") {
+        try {
+          (0, import_child_process.execFileSync)("taskkill", ["/T", "/F", "/PID", this._process.pid.toString()], { stdio: "ignore" });
+        } catch {
+        }
+        done();
+      } else {
+        setTimeout(() => {
+          if (!resolved) {
+            try {
+              this._process.kill("SIGTERM");
+            } catch {
+            }
+          }
+        }, 1e3);
+        setTimeout(() => {
+          if (!resolved) {
+            try {
+              this._process.kill("SIGKILL");
+            } catch {
+            }
+          }
+        }, 4e3);
+        setTimeout(done, 5e3);
+      }
+    });
+  }
+};
+
+// src/bidi/types.ts
+function isResponse(msg) {
+  return "id" in msg;
+}
+function isEvent(msg) {
+  return !("id" in msg) && "method" in msg;
+}
+
+// src/bidi/client.ts
+var import_readline = require("readline");
+var DEFAULT_COMMAND_TIMEOUT = 6e4;
+var BiDiClient = class _BiDiClient {
+  constructor(stdin, stdout) {
+    this.nextId = 1;
+    this.pendingCommands = /* @__PURE__ */ new Map();
+    this.eventHandlers = [];
+    this._closed = false;
+    this.stdin = stdin;
+    this.rl = (0, import_readline.createInterface)({ input: stdout, crlfDelay: Infinity });
+    this.rl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      try {
+        const msg = JSON.parse(trimmed);
+        if (isResponse(msg)) {
+          this.handleResponse(msg);
+        } else if (isEvent(msg)) {
+          this.handleEvent(msg);
+        }
+      } catch (err) {
+      }
+    });
+    this.rl.on("close", () => {
+      this._closed = true;
+      for (const [id, pending] of this.pendingCommands) {
+        clearTimeout(pending.timer);
+        pending.reject(new Error("Connection closed unexpectedly"));
+        this.pendingCommands.delete(id);
+      }
+    });
+  }
+  /**
+   * Create a BiDiClient from stdin/stdout streams.
+   * Optionally replay pre-ready lines (events received before the ready signal).
+   */
+  static fromStreams(stdin, stdout, preReadyLines = []) {
+    const client = new _BiDiClient(stdin, stdout);
+    for (const line of preReadyLines) {
+      try {
+        const msg = JSON.parse(line);
+        if (isEvent(msg)) {
+          client.handleEvent(msg);
+        }
+      } catch {
+      }
+    }
+    return client;
+  }
+  handleResponse(response) {
+    const pending = this.pendingCommands.get(response.id);
+    if (!pending) {
+      return;
+    }
+    clearTimeout(pending.timer);
+    this.pendingCommands.delete(response.id);
+    if (response.type === "error" && response.error) {
+      pending.reject(new Error(`${response.error}: ${response.message}`));
+    } else {
+      pending.resolve(response.result);
+    }
+  }
+  handleEvent(event) {
+    for (const handler of this.eventHandlers) {
+      handler(event);
+    }
+  }
+  onEvent(handler) {
+    this.eventHandlers.push(handler);
+  }
+  offEvent(handler) {
+    this.eventHandlers = this.eventHandlers.filter((h) => h !== handler);
+  }
+  send(method, params = {}, timeout = DEFAULT_COMMAND_TIMEOUT) {
+    return new Promise((resolve, reject) => {
+      const id = this.nextId++;
+      const command = { id, method, params };
+      const timer = setTimeout(() => {
+        this.pendingCommands.delete(id);
+        reject(new Error(`Command '${method}' timed out after ${timeout}ms`));
+      }, timeout);
+      this.pendingCommands.set(id, {
+        resolve,
+        reject,
+        timer
+      });
+      try {
+        if (this._closed) {
+          throw new Error("Connection closed");
+        }
+        this.stdin.write(JSON.stringify(command) + "\n");
+      } catch (err) {
+        clearTimeout(timer);
+        this.pendingCommands.delete(id);
+        reject(err);
+      }
+    });
+  }
+  async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    for (const [id, pending] of this.pendingCommands) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Connection closed"));
+      this.pendingCommands.delete(id);
+    }
+    this.rl.close();
+    try {
+      this.stdin.end();
+    } catch {
+    }
+  }
+};
+
+// src/element.ts
+var customInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var Element = class _Element {
+  constructor(client, context, selector, info2, index, params) {
+    this.client = client;
+    this.context = context;
+    this.selector = selector;
+    this.info = info2;
+    this._index = index;
+    this._params = params || {};
+  }
+  /** Build the common params sent to vibium: commands for element resolution. */
+  commandParams(extra) {
+    return {
+      ...this._params,
+      context: this.context,
+      selector: this.selector,
+      index: this._index,
+      ...extra
+    };
+  }
+  /** Return params that can identify this element for use as a target (e.g. dragTo). */
+  toParams() {
+    return {
+      ...this._params,
+      selector: this.selector,
+      index: this._index
+    };
+  }
+  /**
+   * Click the element.
+   * Waits for element to be visible, stable, receive events, and enabled.
+   */
+  async click(options) {
+    await this.client.send("vibium:element.click", this.commandParams({
+      timeout: options?.timeout
+    }));
+  }
+  /** Double-click the element. */
+  async dblclick(options) {
+    await this.client.send("vibium:element.dblclick", this.commandParams({
+      timeout: options?.timeout
+    }));
+  }
+  /**
+   * Fill the element with text (clears existing content first).
+   * For inputs and textareas.
+   */
+  async fill(value, options) {
+    await this.client.send("vibium:element.fill", this.commandParams({
+      value,
+      timeout: options?.timeout
+    }));
+  }
+  /**
+   * Type text into the element (appends to existing content).
+   * Waits for element to be visible, stable, receive events, enabled, and editable.
+   */
+  async type(text, options) {
+    await this.client.send("vibium:element.type", this.commandParams({
+      text,
+      timeout: options?.timeout
+    }));
+  }
+  /**
+   * Press a key while the element is focused.
+   * Supports key names ("Enter", "Tab") and combos ("Control+a").
+   */
+  async press(key, options) {
+    await this.client.send("vibium:element.press", this.commandParams({
+      key,
+      timeout: options?.timeout
+    }));
+  }
+  /** Clear the element's content (select all + delete). */
+  async clear(options) {
+    await this.client.send("vibium:element.clear", this.commandParams({
+      timeout: options?.timeout
+    }));
+  }
+  /** Check a checkbox (no-op if already checked). */
+  async check(options) {
+    await this.client.send("vibium:element.check", this.commandParams({
+      timeout: options?.timeout
+    }));
+  }
+  /** Uncheck a checkbox (no-op if already unchecked). */
+  async uncheck(options) {
+    await this.client.send("vibium:element.uncheck", this.commandParams({
+      timeout: options?.timeout
+    }));
+  }
+  /** Select an option in a <select> element by value. */
+  async selectOption(value, options) {
+    await this.client.send("vibium:element.selectOption", this.commandParams({
+      value,
+      timeout: options?.timeout
+    }));
+  }
+  /** Hover over the element (move mouse to center, no click). */
+  async hover(options) {
+    await this.client.send("vibium:element.hover", this.commandParams({
+      timeout: options?.timeout
+    }));
+  }
+  /** Focus the element. */
+  async focus(options) {
+    await this.client.send("vibium:element.focus", this.commandParams({
+      timeout: options?.timeout
+    }));
+  }
+  /** Drag this element to a target element. */
+  async dragTo(target, options) {
+    await this.client.send("vibium:element.dragTo", this.commandParams({
+      target: target.toParams(),
+      timeout: options?.timeout
+    }));
+  }
+  /** Tap the element (touch action). */
+  async tap(options) {
+    await this.client.send("vibium:element.tap", this.commandParams({
+      timeout: options?.timeout
+    }));
+  }
+  /** Scroll the element into view. */
+  async scrollIntoView(options) {
+    await this.client.send("vibium:element.scrollIntoView", this.commandParams({
+      timeout: options?.timeout
+    }));
+  }
+  /** Dispatch a DOM event on the element. */
+  async dispatchEvent(eventType, eventInit, options) {
+    await this.client.send("vibium:element.dispatchEvent", this.commandParams({
+      eventType,
+      eventInit,
+      timeout: options?.timeout
+    }));
+  }
+  /** Set files on an <input type="file"> element. */
+  async setFiles(files, options) {
+    await this.client.send("vibium:element.setFiles", this.commandParams({
+      files,
+      timeout: options?.timeout
+    }));
+  }
+  // --- Element State ---
+  /** Get the element's textContent (trimmed). */
+  async text() {
+    const result = await this.client.send("vibium:element.text", this.commandParams());
+    return result.text;
+  }
+  /** Get the element's innerText (rendered text only). */
+  async innerText() {
+    const result = await this.client.send("vibium:element.innerText", this.commandParams());
+    return result.text;
+  }
+  /** Get the element's innerHTML. */
+  async html() {
+    const result = await this.client.send("vibium:element.html", this.commandParams());
+    return result.html;
+  }
+  /** Get the element's value (for inputs, textareas, selects). */
+  async value() {
+    const result = await this.client.send("vibium:element.value", this.commandParams());
+    return result.value;
+  }
+  /** Get an attribute value. Short name for getAttribute. */
+  async attr(name) {
+    const result = await this.client.send("vibium:element.attr", this.commandParams({ name }));
+    return result.value;
+  }
+  /** Get an attribute value. Alias for attr(). */
+  async getAttribute(name) {
+    return this.attr(name);
+  }
+  /** Get the element's bounding box. Short name for boundingBox. */
+  async bounds() {
+    const result = await this.client.send("vibium:element.bounds", this.commandParams());
+    return result;
+  }
+  /** Get the element's bounding box. Alias for bounds(). */
+  async boundingBox() {
+    return this.bounds();
+  }
+  /** Check if the element is visible (has dimensions, not display:none/visibility:hidden/opacity:0). */
+  async isVisible() {
+    const result = await this.client.send("vibium:element.isVisible", this.commandParams());
+    return result.visible;
+  }
+  /** Check if the element is hidden (inverse of isVisible). */
+  async isHidden() {
+    const result = await this.client.send("vibium:element.isHidden", this.commandParams());
+    return result.hidden;
+  }
+  /** Check if the element is enabled (not disabled). */
+  async isEnabled() {
+    const result = await this.client.send("vibium:element.isEnabled", this.commandParams());
+    return result.enabled;
+  }
+  /** Check if the element is checked (for checkboxes/radios). */
+  async isChecked() {
+    const result = await this.client.send("vibium:element.isChecked", this.commandParams());
+    return result.checked;
+  }
+  /** Check if the element is editable (not disabled and not readonly). */
+  async isEditable() {
+    const result = await this.client.send("vibium:element.isEditable", this.commandParams());
+    return result.editable;
+  }
+  /** Get the element's computed ARIA role. */
+  async role() {
+    const result = await this.client.send("vibium:element.role", this.commandParams());
+    return result.role;
+  }
+  /** Get the element's accessible name (label). */
+  async label() {
+    const result = await this.client.send("vibium:element.label", this.commandParams());
+    return result.label;
+  }
+  /** Take a screenshot of just this element. Returns a PNG buffer. */
+  async screenshot() {
+    const result = await this.client.send("vibium:element.screenshot", this.commandParams());
+    return Buffer.from(result.data, "base64");
+  }
+  /** Wait until the element reaches a state: "visible", "hidden", "attached", or "detached". */
+  async waitUntil(state, options) {
+    await this.client.send("vibium:element.waitFor", this.commandParams({
+      state,
+      timeout: options?.timeout
+    }));
+  }
+  /** Find a child element by CSS selector or semantic options. Scoped to this element. */
+  find(selector, options) {
+    const promise = (async () => {
+      const params = {
+        context: this.context,
+        scope: this.selector,
+        timeout: options?.timeout
+      };
+      if (typeof selector === "string") {
+        params.selector = selector;
+      } else {
+        Object.assign(params, selector);
+        if (selector.timeout) params.timeout = selector.timeout;
+      }
+      const result = await this.client.send("vibium:element.find", params);
+      const info2 = { tag: result.tag, text: result.text, box: result.box };
+      const childSelector = typeof selector === "string" ? selector : "";
+      const childParams = typeof selector === "string" ? { selector } : { ...selector };
+      return new _Element(this.client, this.context, childSelector, info2, void 0, childParams);
+    })();
+    return fluent(promise);
+  }
+  /** Find all child elements by CSS selector or semantic options. Scoped to this element. */
+  async findAll(selector, options) {
+    const params = {
+      context: this.context,
+      scope: this.selector,
+      timeout: options?.timeout
+    };
+    if (typeof selector === "string") {
+      params.selector = selector;
+    } else {
+      Object.assign(params, selector);
+      if (selector.timeout) params.timeout = selector.timeout;
+    }
+    const result = await this.client.send("vibium:element.findAll", params);
+    const selectorStr = typeof selector === "string" ? selector : "";
+    const selectorParams = typeof selector === "string" ? { selector } : { ...selector };
+    return result.elements.map((el) => {
+      const info2 = { tag: el.tag, text: el.text, box: el.box };
+      return new _Element(this.client, this.context, selectorStr, info2, el.index, selectorParams);
+    });
+  }
+  [customInspect]() {
+    const text = this.info.text.length > 50 ? this.info.text.slice(0, 50) + "..." : this.info.text;
+    return `Element { tag: '${this.info.tag}', text: '${text}' }`;
+  }
+  getCenter() {
+    return {
+      x: this.info.box.x + this.info.box.width / 2,
+      y: this.info.box.y + this.info.box.height / 2
+    };
+  }
+};
+function fluent(promise) {
+  const p = promise;
+  p.click = (opts) => promise.then((el) => el.click(opts));
+  p.dblclick = (opts) => promise.then((el) => el.dblclick(opts));
+  p.fill = (value, opts) => promise.then((el) => el.fill(value, opts));
+  p.type = (text, opts) => promise.then((el) => el.type(text, opts));
+  p.press = (key, opts) => promise.then((el) => el.press(key, opts));
+  p.clear = (opts) => promise.then((el) => el.clear(opts));
+  p.check = (opts) => promise.then((el) => el.check(opts));
+  p.uncheck = (opts) => promise.then((el) => el.uncheck(opts));
+  p.selectOption = (value, opts) => promise.then((el) => el.selectOption(value, opts));
+  p.hover = (opts) => promise.then((el) => el.hover(opts));
+  p.focus = (opts) => promise.then((el) => el.focus(opts));
+  p.dragTo = (target, opts) => promise.then((el) => el.dragTo(target, opts));
+  p.tap = (opts) => promise.then((el) => el.tap(opts));
+  p.scrollIntoView = (opts) => promise.then((el) => el.scrollIntoView(opts));
+  p.dispatchEvent = (type, init, opts) => promise.then((el) => el.dispatchEvent(type, init, opts));
+  p.setFiles = (files, opts) => promise.then((el) => el.setFiles(files, opts));
+  p.text = () => promise.then((el) => el.text());
+  p.innerText = () => promise.then((el) => el.innerText());
+  p.html = () => promise.then((el) => el.html());
+  p.value = () => promise.then((el) => el.value());
+  p.attr = (name) => promise.then((el) => el.attr(name));
+  p.getAttribute = (name) => promise.then((el) => el.getAttribute(name));
+  p.bounds = () => promise.then((el) => el.bounds());
+  p.boundingBox = () => promise.then((el) => el.boundingBox());
+  p.isVisible = () => promise.then((el) => el.isVisible());
+  p.isHidden = () => promise.then((el) => el.isHidden());
+  p.isEnabled = () => promise.then((el) => el.isEnabled());
+  p.isChecked = () => promise.then((el) => el.isChecked());
+  p.isEditable = () => promise.then((el) => el.isEditable());
+  p.role = () => promise.then((el) => el.role());
+  p.label = () => promise.then((el) => el.label());
+  p.screenshot = () => promise.then((el) => el.screenshot());
+  p.waitUntil = (state, opts) => promise.then((el) => el.waitUntil(state, opts));
+  p.find = (sel, opts) => fluent(promise.then((el) => el.find(sel, opts)));
+  p.findAll = (sel, opts) => promise.then((el) => el.findAll(sel, opts));
+  return p;
+}
+
+// src/recording.ts
+var Recording = class {
+  constructor(client, userContextId) {
+    this.client = client;
+    this.userContextId = userContextId;
+  }
+  /** Start recording. */
+  async start(options = {}) {
+    await this.client.send("vibium:recording.start", {
+      userContext: this.userContextId,
+      ...options
+    });
+  }
+  /** Stop recording and return the recording zip as a Buffer. */
+  async stop(options = {}) {
+    const result = await this.client.send("vibium:recording.stop", {
+      userContext: this.userContextId,
+      ...options
+    });
+    if (options.path) {
+      const fs3 = await import("fs");
+      return fs3.readFileSync(result.path);
+    }
+    return Buffer.from(result.data, "base64");
+  }
+  /** Start a new recording chunk (resets event buffer, keeps resources). */
+  async startChunk(options = {}) {
+    await this.client.send("vibium:recording.startChunk", {
+      userContext: this.userContextId,
+      ...options
+    });
+  }
+  /** Stop the current chunk and return the recording zip as a Buffer. */
+  async stopChunk(options = {}) {
+    const result = await this.client.send("vibium:recording.stopChunk", {
+      userContext: this.userContextId,
+      ...options
+    });
+    if (options.path) {
+      const fs3 = await import("fs");
+      return fs3.readFileSync(result.path);
+    }
+    return Buffer.from(result.data, "base64");
+  }
+  /** Start a named group of actions in the recording. */
+  async startGroup(name, options = {}) {
+    await this.client.send("vibium:recording.startGroup", {
+      userContext: this.userContextId,
+      name,
+      ...options
+    });
+  }
+  /** End the current group. */
+  async stopGroup() {
+    await this.client.send("vibium:recording.stopGroup", {
+      userContext: this.userContextId
+    });
+  }
+};
+
+// src/context.ts
+var BrowserContext = class {
+  constructor(client, userContextId) {
+    this.client = client;
+    this.userContextId = userContextId;
+    this.recording = new Recording(client, userContextId);
+  }
+  /** The user context ID for this browser context. */
+  get id() {
+    return this.userContextId;
+  }
+  /** Create a new page (tab) in this context. */
+  async newPage() {
+    const result = await this.client.send("vibium:context.newPage", {
+      userContext: this.userContextId
+    });
+    return new Page(this.client, result.context, this.userContextId);
+  }
+  /** Close this context and all its pages. */
+  async close() {
+    await this.client.send("browser.removeUserContext", {
+      userContext: this.userContextId
+    });
+  }
+  /** Get cookies for this context. Optionally filter by URLs. */
+  async cookies(urls) {
+    const params = { userContext: this.userContextId };
+    if (urls && urls.length > 0) {
+      params.urls = urls;
+    }
+    const result = await this.client.send("vibium:context.cookies", params);
+    return result.cookies;
+  }
+  /** Set cookies in this context. */
+  async setCookies(cookies) {
+    await this.client.send("vibium:context.setCookies", {
+      userContext: this.userContextId,
+      cookies
+    });
+  }
+  /** Clear all cookies in this context. */
+  async clearCookies() {
+    await this.client.send("vibium:context.clearCookies", {
+      userContext: this.userContextId
+    });
+  }
+  /** Get the storage state (cookies + localStorage + sessionStorage). */
+  async storage() {
+    const result = await this.client.send("vibium:context.storage", {
+      userContext: this.userContextId
+    });
+    return result;
+  }
+  /** Set the storage state (cookies + localStorage + sessionStorage). */
+  async setStorage(state) {
+    await this.client.send("vibium:context.setStorage", {
+      userContext: this.userContextId,
+      state
+    });
+  }
+  /** Clear all storage (cookies + localStorage + sessionStorage). */
+  async clearStorage() {
+    await this.client.send("vibium:context.clearStorage", {
+      userContext: this.userContextId
+    });
+  }
+  /** Add an init script that runs before page scripts in this context. */
+  async addInitScript(script) {
+    const result = await this.client.send("vibium:context.addInitScript", {
+      userContext: this.userContextId,
+      script
+    });
+    return result.script;
+  }
+};
+
+// src/route.ts
+function isRaceConditionError(e) {
+  if (!(e instanceof Error)) return false;
+  const msg = e.message;
+  return msg === "Connection closed" || msg.includes("Invalid state") || msg.includes("No blocked request") || msg.includes("no such request");
+}
+var Route = class {
+  constructor(client, requestId, request) {
+    this.client = client;
+    this.requestId = requestId;
+    this.request = request;
+  }
+  /** Fulfill the request with a custom response (mock response). */
+  async fulfill(response = {}) {
+    try {
+      const params = { request: this.requestId };
+      if (response.status !== void 0) params.statusCode = response.status;
+      if (response.headers) params.headers = response.headers;
+      if (response.contentType) params.contentType = response.contentType;
+      if (response.body !== void 0) params.body = response.body;
+      await this.client.send("vibium:network.fulfill", params);
+    } catch (e) {
+      if (isRaceConditionError(e)) return;
+      throw e;
+    }
+  }
+  /** Continue the request with optional overrides. */
+  async continue(overrides) {
+    try {
+      const params = { request: this.requestId };
+      if (overrides?.url) params.url = overrides.url;
+      if (overrides?.method) params.method = overrides.method;
+      if (overrides?.headers) params.headers = overrides.headers;
+      if (overrides?.postData) params.postData = overrides.postData;
+      await this.client.send("vibium:network.continue", params);
+    } catch (e) {
+      if (isRaceConditionError(e)) return;
+      throw e;
+    }
+  }
+  /** Abort the request. */
+  async abort() {
+    try {
+      await this.client.send("vibium:network.abort", {
+        request: this.requestId
+      });
+    } catch (e) {
+      if (isRaceConditionError(e)) return;
+      throw e;
+    }
+  }
+};
+
+// src/network.ts
+var Request = class {
+  constructor(data, client) {
+    this.data = data;
+    this.client = client ?? null;
+  }
+  /** The request URL. */
+  url() {
+    const req = this.data.request;
+    return req?.url ?? "";
+  }
+  /** The HTTP method (GET, POST, etc.). */
+  method() {
+    const req = this.data.request;
+    return req?.method ?? "";
+  }
+  /** Request headers as a simple key-value object. */
+  headers() {
+    const req = this.data.request;
+    const entries = req?.headers ?? [];
+    return convertHeaders(entries);
+  }
+  /** The request ID (BiDi network request identifier). */
+  requestId() {
+    const req = this.data.request;
+    return req?.request ?? "";
+  }
+  /** Request body / post data. Uses BiDi network.getData when a data collector is active. */
+  async postData() {
+    if (!this.client) return null;
+    const reqId = this.requestId();
+    if (!reqId) return null;
+    try {
+      const result = await this.client.send(
+        "network.getData",
+        { dataType: "request", request: reqId }
+      );
+      return result?.bytes?.value ?? null;
+    } catch {
+      return null;
+    }
+  }
+};
+var Response = class {
+  constructor(data, client) {
+    this.data = data;
+    this.client = client ?? null;
+  }
+  /** The response URL. */
+  url() {
+    const resp = this.data.response;
+    return resp?.url ?? this.data.url ?? "";
+  }
+  /** The HTTP status code. */
+  status() {
+    const resp = this.data.response;
+    return resp?.status ?? 0;
+  }
+  /** Response headers as a simple key-value object. */
+  headers() {
+    const resp = this.data.response;
+    const entries = resp?.headers ?? [];
+    return convertHeaders(entries);
+  }
+  /** The request ID associated with this response. */
+  requestId() {
+    const req = this.data.request;
+    return req?.request ?? "";
+  }
+  /** Response body as a string. Requires a data collector (set up by onResponse/expect.response). */
+  async body() {
+    if (!this.client) return null;
+    const reqId = this.requestId();
+    if (!reqId) return null;
+    try {
+      const result = await this.client.send(
+        "network.getData",
+        { dataType: "response", request: reqId }
+      );
+      if (!result?.bytes?.value) return null;
+      if (result.bytes.type === "base64") {
+        return Buffer.from(result.bytes.value, "base64").toString("utf-8");
+      }
+      return result.bytes.value;
+    } catch {
+      return null;
+    }
+  }
+  /** Response body parsed as JSON. Requires a data collector (set up by onResponse/expect.response). */
+  async json() {
+    const text = await this.body();
+    if (text === null) return null;
+    return JSON.parse(text);
+  }
+};
+function convertHeaders(entries) {
+  const result = {};
+  for (const entry of entries) {
+    result[entry.name] = entry.value?.value ?? "";
+  }
+  return result;
+}
+
+// src/dialog.ts
+function isDialogRaceError(e) {
+  if (!(e instanceof Error)) return false;
+  const msg = e.message;
+  return msg === "Connection closed" || msg.includes("no such alert") || msg.includes("No dialog");
+}
+var Dialog = class {
+  constructor(client, contextId, data) {
+    this.client = client;
+    this.contextId = contextId;
+    this.data = data;
+  }
+  /** The dialog message text. */
+  message() {
+    return this.data.message ?? "";
+  }
+  /** The dialog type: 'alert', 'confirm', 'prompt', or 'beforeunload'. */
+  type() {
+    return this.data.type ?? "alert";
+  }
+  /** The default value for prompt dialogs. */
+  defaultValue() {
+    return this.data.defaultValue ?? "";
+  }
+  /** Accept the dialog. For prompt dialogs, optionally provide text. */
+  async accept(promptText) {
+    try {
+      const params = {
+        context: this.contextId,
+        accept: true
+      };
+      if (promptText !== void 0) params.userText = promptText;
+      await this.client.send("browsingContext.handleUserPrompt", params);
+    } catch (e) {
+      if (isDialogRaceError(e)) return;
+      throw e;
+    }
+  }
+  /** Dismiss the dialog (cancel/close). */
+  async dismiss() {
+    try {
+      await this.client.send("browsingContext.handleUserPrompt", {
+        context: this.contextId,
+        accept: false
+      });
+    } catch (e) {
+      if (isDialogRaceError(e)) return;
+      throw e;
+    }
+  }
+};
+
+// src/console.ts
+var ConsoleMessage = class {
+  constructor(data) {
+    this.data = data;
+  }
+  /** The console method: 'log', 'warn', 'error', 'debug', 'info', etc. */
+  type() {
+    return this.data.method ?? "log";
+  }
+  /** The message text. */
+  text() {
+    return this.data.text ?? "";
+  }
+  /** The serialized arguments passed to the console call. */
+  args() {
+    return this.data.args ?? [];
+  }
+  /** The source location of the console call, if available. */
+  location() {
+    const stack = this.data.stackTrace;
+    const frame = stack?.callFrames?.[0];
+    if (!frame) return null;
+    return { url: frame.url, lineNumber: frame.lineNumber, columnNumber: frame.columnNumber };
+  }
+};
+
+// src/download.ts
+var DOWNLOAD_TIMEOUT_MS = 3e5;
+var Download = class {
+  constructor(client, url, suggestedFilename) {
+    this.client = client;
+    this._url = url;
+    this._suggestedFilename = suggestedFilename;
+    this._completionPromise = new Promise((resolve) => {
+      this._resolve = resolve;
+    });
+  }
+  /** The URL of the download. */
+  url() {
+    return this._url;
+  }
+  /** The filename suggested by the server (from Content-Disposition). */
+  suggestedFilename() {
+    return this._suggestedFilename;
+  }
+  /** Wait for the download completion promise with a timeout. */
+  _waitForCompletion() {
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+      timer = setTimeout(
+        () => reject(new Error(`Download timed out after ${DOWNLOAD_TIMEOUT_MS / 1e3}s`)),
+        DOWNLOAD_TIMEOUT_MS
+      );
+    });
+    return Promise.race([this._completionPromise, timeoutPromise]).finally(() => {
+      clearTimeout(timer);
+    });
+  }
+  /** Wait for the download to complete, then save to the specified path. */
+  async saveAs(path2) {
+    const result = await this._waitForCompletion();
+    if (result.status !== "complete" || !result.filepath) {
+      throw new Error(`Download failed with status: ${result.status}`);
+    }
+    await this.client.send("vibium:download.saveAs", {
+      sourcePath: result.filepath,
+      destPath: path2
+    });
+  }
+  /** Wait for the download to complete and return the temp file path, or null if failed. */
+  async path() {
+    const result = await this._waitForCompletion();
+    return result.filepath;
+  }
+  /** Internal: called by Page when downloadCompleted fires. */
+  _complete(status, filepath) {
+    this._resolve({ status, filepath });
+  }
+};
+
+// src/websocket.ts
+var WebSocketInfo = class {
+  constructor(url) {
+    this._isClosed = false;
+    this.messageHandlers = [];
+    this.closeHandlers = [];
+    this._url = url;
+  }
+  url() {
+    return this._url;
+  }
+  onMessage(fn) {
+    this.messageHandlers.push(fn);
+  }
+  onClose(fn) {
+    this.closeHandlers.push(fn);
+  }
+  isClosed() {
+    return this._isClosed;
+  }
+  /** @internal */
+  _emitMessage(data, direction) {
+    for (const fn of this.messageHandlers) fn(data, { direction });
+  }
+  /** @internal */
+  _emitClose(code, reason) {
+    this._isClosed = true;
+    for (const fn of this.closeHandlers) fn(code, reason);
+  }
+};
+
+// src/clock.ts
+function normalizeTime(time) {
+  if (typeof time === "number") return time;
+  if (time instanceof Date) return time.getTime();
+  return new Date(time).getTime();
+}
+var Clock = class {
+  constructor(client, contextId) {
+    this.client = client;
+    this.contextId = contextId;
+  }
+  /** Install fake clock, overriding Date, setTimeout, setInterval, etc. */
+  async install(options) {
+    const params = { context: this.contextId };
+    if (options?.time !== void 0) {
+      params.time = normalizeTime(options.time);
+    }
+    if (options?.timezone !== void 0) {
+      params.timezone = options.timezone;
+    }
+    await this.client.send("vibium:clock.install", params);
+  }
+  /** Jump forward by ticks ms, fire each due timer at most once. */
+  async fastForward(ticks) {
+    await this.client.send("vibium:clock.fastForward", {
+      context: this.contextId,
+      ticks
+    });
+  }
+  /** Advance ticks ms, firing all callbacks systematically (including interval reschedules). */
+  async runFor(ticks) {
+    await this.client.send("vibium:clock.runFor", {
+      context: this.contextId,
+      ticks
+    });
+  }
+  /** Jump to a specific time and pause — no timers fire until resumed/advanced. */
+  async pauseAt(time) {
+    await this.client.send("vibium:clock.pauseAt", {
+      context: this.contextId,
+      time: normalizeTime(time)
+    });
+  }
+  /** Resume real-time progression from current fake time. */
+  async resume() {
+    await this.client.send("vibium:clock.resume", {
+      context: this.contextId
+    });
+  }
+  /** Freeze Date.now() at a value permanently. Timers still run. */
+  async setFixedTime(time) {
+    await this.client.send("vibium:clock.setFixedTime", {
+      context: this.contextId,
+      time: normalizeTime(time)
+    });
+  }
+  /** Set Date.now() without triggering timers. */
+  async setSystemTime(time) {
+    await this.client.send("vibium:clock.setSystemTime", {
+      context: this.contextId,
+      time: normalizeTime(time)
+    });
+  }
+  /** Override the browser timezone. Pass an IANA timezone ID, or empty string to reset to system default. */
+  async setTimezone(timezone) {
+    await this.client.send("vibium:clock.setTimezone", {
+      context: this.contextId,
+      timezone
+    });
+  }
+};
+
+// src/utils/match.ts
+function matchPattern(pattern, url) {
+  if (!pattern.includes("*") && !pattern.includes("{")) {
+    return url === pattern;
+  }
+  const braces = [];
+  let withPlaceholders = pattern.replace(/\{([^}]+)\}/g, (_match, inner) => {
+    braces.push(inner);
+    return `{{BRACE${braces.length - 1}}}`;
+  });
+  let regex = withPlaceholders.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  regex = regex.replace(/\*\*/g, "{{GLOBSTAR}}");
+  regex = regex.replace(/\*/g, "[^/]*");
+  regex = regex.replace(/\{\{GLOBSTAR\}\}/g, ".*");
+  for (let i = 0; i < braces.length; i++) {
+    const alternatives = braces[i].split(",").map((s) => s.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join("|");
+    regex = regex.replace(`\\{\\{BRACE${i}\\}\\}`, `(?:${alternatives})`);
+  }
+  return new RegExp(`^${regex}$`).test(url);
+}
+
+// src/utils/debug.ts
+var isDebugEnabled = process.env.VIBIUM_DEBUG === "1" || process.env.VIBIUM_DEBUG === "true";
+function debug(message, data) {
+  if (!isDebugEnabled) return;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const logObj = {
+    time: timestamp,
+    level: "debug",
+    msg: message,
+    ...data
+  };
+  console.error(JSON.stringify(logObj));
+}
+function info(message, data) {
+  if (!isDebugEnabled) return;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const logObj = {
+    time: timestamp,
+    level: "info",
+    msg: message,
+    ...data
+  };
+  console.error(JSON.stringify(logObj));
+}
+
+// src/page.ts
+var customInspect2 = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var Keyboard = class {
+  constructor(client, contextId) {
+    this.client = client;
+    this.contextId = contextId;
+  }
+  /** Press and release a key. Supports combos like "Control+a". */
+  async press(key) {
+    await this.client.send("vibium:keyboard.press", {
+      context: this.contextId,
+      key
+    });
+  }
+  /** Press a key down (without releasing). */
+  async down(key) {
+    await this.client.send("vibium:keyboard.down", {
+      context: this.contextId,
+      key
+    });
+  }
+  /** Release a key. */
+  async up(key) {
+    await this.client.send("vibium:keyboard.up", {
+      context: this.contextId,
+      key
+    });
+  }
+  /** Type a string of text character by character. */
+  async type(text) {
+    await this.client.send("vibium:keyboard.type", {
+      context: this.contextId,
+      text
+    });
+  }
+};
+var Mouse = class {
+  constructor(client, contextId) {
+    this.client = client;
+    this.contextId = contextId;
+  }
+  /** Click at (x, y) coordinates. */
+  async click(x, y) {
+    await this.client.send("vibium:mouse.click", {
+      context: this.contextId,
+      x,
+      y
+    });
+  }
+  /** Move mouse to (x, y) coordinates. */
+  async move(x, y) {
+    await this.client.send("vibium:mouse.move", {
+      context: this.contextId,
+      x,
+      y
+    });
+  }
+  /** Press mouse button down. */
+  async down() {
+    await this.client.send("vibium:mouse.down", {
+      context: this.contextId
+    });
+  }
+  /** Release mouse button. */
+  async up() {
+    await this.client.send("vibium:mouse.up", {
+      context: this.contextId
+    });
+  }
+  /** Scroll the mouse wheel. */
+  async wheel(deltaX, deltaY) {
+    await this.client.send("vibium:mouse.wheel", {
+      context: this.contextId,
+      x: 0,
+      y: 0,
+      deltaX,
+      deltaY
+    });
+  }
+};
+var Touch = class {
+  constructor(client, contextId) {
+    this.client = client;
+    this.contextId = contextId;
+  }
+  /** Tap at (x, y) coordinates. */
+  async tap(x, y) {
+    await this.client.send("vibium:touch.tap", {
+      context: this.contextId,
+      x,
+      y
+    });
+  }
+};
+var Page = class _Page {
+  constructor(client, contextId, userContextId = "default") {
+    // Network interception state
+    this.routes = [];
+    this.requestCallbacks = [];
+    this.responseCallbacks = [];
+    this.dialogCallbacks = [];
+    this.consoleCallbacks = [];
+    this.errorCallbacks = [];
+    this.downloadCallbacks = [];
+    this.navigationCallbacks = [];
+    this.pendingDownloads = /* @__PURE__ */ new Map();
+    this.wsCallbacks = [];
+    this.wsConnections = /* @__PURE__ */ new Map();
+    this.eventHandler = null;
+    this.interceptId = null;
+    this.dataCollectorId = null;
+    // Console/error collect-mode buffers (null = not collecting)
+    this._consoleBuffer = null;
+    this._errorBuffer = null;
+    this.client = client;
+    this.contextId = contextId;
+    this._context = new BrowserContext(client, userContextId);
+    this.keyboard = new Keyboard(client, contextId);
+    this.mouse = new Mouse(client, contextId);
+    this.touch = new Touch(client, contextId);
+    this.clock = new Clock(client, contextId);
+    const self = this;
+    this.capture = {
+      response(pattern, fn, options) {
+        const promise = self._captureResponse(pattern, options);
+        if (fn) return fn().then(() => promise);
+        return promise;
+      },
+      request(pattern, fn, options) {
+        const promise = self._captureRequest(pattern, options);
+        if (fn) return fn().then(() => promise);
+        return promise;
+      },
+      navigation(fn, options) {
+        const promise = self._captureNavigation(options);
+        if (fn) return fn().then(() => promise);
+        return promise;
+      },
+      download(fn, options) {
+        const promise = self._captureDownload(options);
+        if (fn) return fn().then(() => promise);
+        return promise;
+      },
+      dialog(fn, options) {
+        const promise = self._captureDialog(options);
+        if (fn) return fn().then(() => promise);
+        return promise;
+      },
+      event(name, fn, options) {
+        const promise = self._captureEvent(name, options);
+        if (fn) return fn().then(() => promise);
+        return promise;
+      }
+    };
+    this.waitUntil = Object.assign(
+      (fn, options) => self._waitForFunction(fn, options),
+      {
+        url: (pattern, options) => self._waitForURL(pattern, options),
+        loaded: (state, options) => self._waitForLoad(state, options)
+      }
+    );
+    this.eventHandler = (event) => {
+      const params = event.params;
+      const eventContext = params.context;
+      if (eventContext && eventContext !== this.contextId) return;
+      if (event.method === "network.beforeRequestSent") {
+        this.handleBeforeRequestSent(params);
+      } else if (event.method === "network.responseCompleted") {
+        this.handleResponseCompleted(params);
+      } else if (event.method === "browsingContext.userPromptOpened") {
+        this.handleUserPromptOpened(params);
+      } else if (event.method === "browsingContext.downloadWillBegin") {
+        this.handleDownloadWillBegin(params);
+      } else if (event.method === "browsingContext.downloadEnd") {
+        this.handleDownloadCompleted(params);
+      } else if (event.method === "log.entryAdded") {
+        const source = params.source;
+        const logContext = source?.context;
+        if (logContext && logContext !== this.contextId) return;
+        this.handleLogEntryAdded(params);
+      } else if (event.method === "browsingContext.load") {
+        const url = params.url;
+        if (url) {
+          for (const cb of this.navigationCallbacks) {
+            cb(url);
+          }
+        }
+      } else if (event.method === "browsingContext.fragmentNavigated") {
+        const url = params.url;
+        if (url) {
+          for (const cb of this.navigationCallbacks) {
+            cb(url);
+          }
+        }
+      } else if (event.method === "vibium:ws.created") {
+        this.handleWsCreated(params);
+      } else if (event.method === "vibium:ws.message") {
+        this.handleWsMessage(params);
+      } else if (event.method === "vibium:ws.closed") {
+        this.handleWsClosed(params);
+      }
+    };
+    this.client.onEvent(this.eventHandler);
+  }
+  /** The browsing context ID for this page. */
+  get id() {
+    return this.contextId;
+  }
+  [customInspect2]() {
+    return `Page { contextId: '${this.contextId}' }`;
+  }
+  /** The parent BrowserContext that owns this page. */
+  get context() {
+    return this._context;
+  }
+  /** Navigate to a URL. */
+  async go(url) {
+    debug("page.go", { url, context: this.contextId });
+    await this.client.send("vibium:page.navigate", {
+      context: this.contextId,
+      url
+    });
+  }
+  /** Navigate back in history. */
+  async back() {
+    await this.client.send("vibium:page.back", { context: this.contextId });
+  }
+  /** Navigate forward in history. */
+  async forward() {
+    await this.client.send("vibium:page.forward", { context: this.contextId });
+  }
+  /** Reload the page. */
+  async reload() {
+    await this.client.send("vibium:page.reload", { context: this.contextId });
+  }
+  /** Get the current page URL. */
+  async url() {
+    const result = await this.client.send("vibium:page.url", {
+      context: this.contextId
+    });
+    return result.url;
+  }
+  /** Get the current page title. */
+  async title() {
+    const result = await this.client.send("vibium:page.title", {
+      context: this.contextId
+    });
+    return result.title;
+  }
+  /** Get the full HTML content of the page. */
+  async content() {
+    const result = await this.client.send("vibium:page.content", {
+      context: this.contextId
+    });
+    return result.content;
+  }
+  /** @internal Wait until the page URL matches a pattern. */
+  async _waitForURL(pattern, options) {
+    await this.client.send("vibium:page.waitForURL", {
+      context: this.contextId,
+      pattern,
+      timeout: options?.timeout
+    });
+  }
+  /** @internal Wait until the page reaches a load state. */
+  async _waitForLoad(state, options) {
+    await this.client.send("vibium:page.waitForLoad", {
+      context: this.contextId,
+      state,
+      timeout: options?.timeout
+    });
+  }
+  // --- Frames ---
+  /** Get all child frames of this page (recursive, flattened). */
+  async frames() {
+    const result = await this.client.send("vibium:page.frames", {
+      context: this.contextId
+    });
+    return result.frames.map((f) => new _Page(this.client, f.context));
+  }
+  /** Find a frame by name attribute or URL substring. Returns null if not found. */
+  async frame(nameOrUrl) {
+    const result = await this.client.send("vibium:page.frame", {
+      context: this.contextId,
+      nameOrUrl
+    });
+    if (!result || !result.context) return null;
+    return new _Page(this.client, result.context);
+  }
+  /** Returns this page — the page IS its own main frame. */
+  mainFrame() {
+    return this;
+  }
+  // --- Emulation ---
+  /** Set the viewport size. */
+  async setViewport(size) {
+    await this.client.send("vibium:page.setViewport", {
+      context: this.contextId,
+      width: size.width,
+      height: size.height
+    });
+  }
+  /** Get the current viewport size. */
+  async viewport() {
+    return await this.client.send("vibium:page.viewport", {
+      context: this.contextId
+    });
+  }
+  /** Override CSS media features (colorScheme, reducedMotion, forcedColors, contrast, media type). */
+  async emulateMedia(opts) {
+    await this.client.send("vibium:page.emulateMedia", {
+      context: this.contextId,
+      ...opts
+    });
+  }
+  /** Replace the page HTML content. */
+  async setContent(html) {
+    await this.client.send("vibium:page.setContent", {
+      context: this.contextId,
+      html
+    });
+  }
+  /** Override the browser's geolocation. */
+  async setGeolocation(coords) {
+    await this.client.send("vibium:page.setGeolocation", {
+      context: this.contextId,
+      ...coords
+    });
+  }
+  /** Set the OS browser window size, position, or state. */
+  async setWindow(options) {
+    await this.client.send("vibium:page.setWindow", {
+      ...options
+    });
+  }
+  /** Get the current OS browser window state and dimensions. */
+  async window() {
+    return await this.client.send("vibium:page.window", {});
+  }
+  // --- Accessibility ---
+  /** Get the accessibility tree for the page. */
+  async a11yTree(options) {
+    const result = await this.client.send("vibium:page.a11yTree", {
+      context: this.contextId,
+      ...options
+    });
+    return result.tree;
+  }
+  /** Bring this page/tab to the foreground. */
+  async bringToFront() {
+    await this.client.send("browsingContext.activate", { context: this.contextId });
+  }
+  /** Close this page/tab. */
+  async close() {
+    if (this.eventHandler) {
+      this.client.offEvent(this.eventHandler);
+    }
+    await this.client.send("browsingContext.close", { context: this.contextId });
+  }
+  /** Scroll the page in a direction. */
+  async scroll(direction, amount, selector) {
+    await this.client.send("vibium:page.scroll", {
+      context: this.contextId,
+      direction,
+      amount,
+      selector
+    });
+  }
+  // --- Screenshots & PDF ---
+  /** Take a screenshot of the page. Returns a PNG buffer. */
+  async screenshot(options) {
+    const result = await this.client.send("vibium:page.screenshot", {
+      context: this.contextId,
+      fullPage: options?.fullPage,
+      clip: options?.clip
+    });
+    return Buffer.from(result.data, "base64");
+  }
+  /** Print the page to PDF. Returns a PDF buffer. Only works in headless mode. */
+  async pdf() {
+    const result = await this.client.send("vibium:page.pdf", {
+      context: this.contextId
+    });
+    return Buffer.from(result.data, "base64");
+  }
+  // --- Evaluation ---
+  /** Evaluate a JS expression and return the deserialized value. */
+  async evaluate(expression) {
+    const result = await this.client.send("vibium:page.eval", {
+      context: this.contextId,
+      expression
+    });
+    return result.value;
+  }
+  /** Inject a script into the page. Pass a URL or inline JavaScript. */
+  async addScript(source) {
+    const isURL = source.startsWith("http://") || source.startsWith("https://") || source.startsWith("//");
+    await this.client.send("vibium:page.addScript", {
+      context: this.contextId,
+      ...isURL ? { url: source } : { content: source }
+    });
+  }
+  /** Inject a stylesheet into the page. Pass a URL or inline CSS. */
+  async addStyle(source) {
+    const isURL = source.startsWith("http://") || source.startsWith("https://") || source.startsWith("//");
+    await this.client.send("vibium:page.addStyle", {
+      context: this.contextId,
+      ...isURL ? { url: source } : { content: source }
+    });
+  }
+  /** Expose a function on window. The function body is injected as a string. */
+  async expose(name, fn) {
+    await this.client.send("vibium:page.expose", {
+      context: this.contextId,
+      name,
+      fn
+    });
+  }
+  /** Wait for a fixed amount of time (milliseconds). Discouraged but useful for debugging. */
+  async wait(ms) {
+    await this.client.send("vibium:page.wait", {
+      context: this.contextId,
+      ms
+    });
+  }
+  /** @internal Wait until a function returns a truthy value. */
+  async _waitForFunction(fn, options) {
+    const result = await this.client.send("vibium:page.waitForFunction", {
+      context: this.contextId,
+      fn,
+      timeout: options?.timeout
+    });
+    return result.value;
+  }
+  /** Find an element by CSS selector or semantic options. Waits for element to exist. */
+  find(selector, options) {
+    const promise = (async () => {
+      const params = {
+        context: this.contextId,
+        timeout: options?.timeout
+      };
+      if (typeof selector === "string") {
+        debug("page.find", { selector, timeout: options?.timeout });
+        params.selector = selector;
+      } else {
+        debug("page.find", { ...selector, timeout: options?.timeout });
+        Object.assign(params, selector);
+        if (selector.timeout && !options?.timeout) params.timeout = selector.timeout;
+      }
+      const result = await this.client.send("vibium:page.find", params);
+      const info2 = {
+        tag: result.tag,
+        text: result.text,
+        box: result.box
+      };
+      const selectorStr = typeof selector === "string" ? selector : "";
+      const selectorParams = typeof selector === "string" ? { selector } : { ...selector };
+      return new Element(this.client, this.contextId, selectorStr, info2, void 0, selectorParams);
+    })();
+    return fluent(promise);
+  }
+  /** Find all elements matching a CSS selector or semantic options. Waits for at least one. */
+  async findAll(selector, options) {
+    const params = {
+      context: this.contextId,
+      timeout: options?.timeout
+    };
+    if (typeof selector === "string") {
+      debug("page.findAll", { selector, timeout: options?.timeout });
+      params.selector = selector;
+    } else {
+      debug("page.findAll", { ...selector, timeout: options?.timeout });
+      Object.assign(params, selector);
+      if (selector.timeout && !options?.timeout) params.timeout = selector.timeout;
+    }
+    const result = await this.client.send("vibium:page.findAll", params);
+    const selectorStr = typeof selector === "string" ? selector : "";
+    const selectorParams = typeof selector === "string" ? { selector } : { ...selector };
+    return result.elements.map((el) => {
+      const info2 = { tag: el.tag, text: el.text, box: el.box };
+      return new Element(this.client, this.contextId, selectorStr, info2, el.index, selectorParams);
+    });
+  }
+  // --- Network Interception ---
+  /**
+   * Intercept network requests matching a URL pattern.
+   * The handler receives a Route object that can fulfill, continue, or abort the request.
+   */
+  async route(pattern, handler) {
+    if (this.interceptId === null) {
+      const result = await this.client.send("vibium:page.route", {
+        context: this.contextId
+      });
+      this.interceptId = result.intercept;
+    }
+    this.ensureDataCollector();
+    this.routes.push({ pattern, handler, interceptId: this.interceptId ?? void 0 });
+  }
+  /** Remove a previously registered route. If no handler given, removes all routes for the pattern. */
+  async unroute(pattern) {
+    this.routes = this.routes.filter((r) => r.pattern !== pattern);
+    if (this.routes.length === 0 && this.interceptId) {
+      await this.client.send("network.removeIntercept", {
+        intercept: this.interceptId
+      });
+      this.interceptId = null;
+    }
+  }
+  /** Register a callback for every outgoing request. */
+  onRequest(fn) {
+    this.ensureDataCollector();
+    this.requestCallbacks.push(fn);
+  }
+  /** Register a callback for every completed response. */
+  onResponse(fn) {
+    this.ensureDataCollector();
+    this.responseCallbacks.push(fn);
+  }
+  /**
+   * Remove all listeners for a given event, or all events if no event specified.
+   * Supported events: 'request', 'response', 'dialog', 'console', 'error', 'download', 'websocket'.
+   */
+  removeAllListeners(event) {
+    if (!event || event === "request") {
+      this.requestCallbacks = [];
+    }
+    if (!event || event === "response") {
+      this.responseCallbacks = [];
+    }
+    if (!event || event === "dialog") {
+      this.dialogCallbacks = [];
+    }
+    if (!event || event === "console") {
+      this.consoleCallbacks = [];
+      this._consoleBuffer = null;
+    }
+    if (!event || event === "error") {
+      this.errorCallbacks = [];
+      this._errorBuffer = null;
+    }
+    if (!event || event === "download") {
+      this.downloadCallbacks = [];
+    }
+    if (!event || event === "navigation") {
+      this.navigationCallbacks = [];
+    }
+    if (!event || event === "websocket") {
+      this.wsCallbacks = [];
+    }
+    if (this.requestCallbacks.length === 0 && this.responseCallbacks.length === 0 && this.routes.length === 0) {
+      this.teardownDataCollector();
+    }
+  }
+  /** @internal Capture a request matching a URL pattern. */
+  _captureRequest(pattern, options) {
+    const timeout = options?.timeout ?? 1e4;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.requestCallbacks = this.requestCallbacks.filter((cb) => cb !== handler);
+        reject(new Error(`Timeout waiting for request matching '${pattern}'`));
+      }, timeout);
+      const handler = (request) => {
+        if (matchPattern(pattern, request.url())) {
+          clearTimeout(timer);
+          this.requestCallbacks = this.requestCallbacks.filter((cb) => cb !== handler);
+          resolve(request);
+        }
+      };
+      this.requestCallbacks.push(handler);
+    });
+  }
+  /** @internal Capture a response matching a URL pattern. */
+  _captureResponse(pattern, options) {
+    this.ensureDataCollector();
+    const timeout = options?.timeout ?? 1e4;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.responseCallbacks = this.responseCallbacks.filter((cb) => cb !== handler);
+        reject(new Error(`Timeout waiting for response matching '${pattern}'`));
+      }, timeout);
+      const handler = (response) => {
+        if (matchPattern(pattern, response.url())) {
+          clearTimeout(timer);
+          this.responseCallbacks = this.responseCallbacks.filter((cb) => cb !== handler);
+          resolve(response);
+        }
+      };
+      this.responseCallbacks.push(handler);
+    });
+  }
+  /** @internal Capture a navigation event. Resolves with the URL. */
+  _captureNavigation(options) {
+    const timeout = options?.timeout ?? 1e4;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.navigationCallbacks = this.navigationCallbacks.filter((cb) => cb !== handler);
+        reject(new Error(`Timeout waiting for navigation`));
+      }, timeout);
+      const handler = (url) => {
+        clearTimeout(timer);
+        this.navigationCallbacks = this.navigationCallbacks.filter((cb) => cb !== handler);
+        resolve(url);
+      };
+      this.navigationCallbacks.push(handler);
+    });
+  }
+  /** @internal Capture a download event. */
+  _captureDownload(options) {
+    const timeout = options?.timeout ?? 1e4;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.downloadCallbacks = this.downloadCallbacks.filter((cb) => cb !== handler);
+        reject(new Error(`Timeout waiting for download`));
+      }, timeout);
+      const handler = (download) => {
+        clearTimeout(timer);
+        this.downloadCallbacks = this.downloadCallbacks.filter((cb) => cb !== handler);
+        resolve(download);
+      };
+      this.downloadCallbacks.push(handler);
+    });
+  }
+  /** @internal Capture a dialog event. The registered callback prevents auto-dismiss. */
+  _captureDialog(options) {
+    const timeout = options?.timeout ?? 1e4;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.dialogCallbacks = this.dialogCallbacks.filter((cb) => cb !== handler);
+        reject(new Error(`Timeout waiting for dialog`));
+      }, timeout);
+      const handler = (dialog) => {
+        clearTimeout(timer);
+        this.dialogCallbacks = this.dialogCallbacks.filter((cb) => cb !== handler);
+        resolve(dialog);
+      };
+      this.dialogCallbacks.push(handler);
+    });
+  }
+  /** @internal Capture a named event. Maps event name to the appropriate callback array. */
+  _captureEvent(name, options) {
+    const timeout = options?.timeout ?? 1e4;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        cleanup();
+        reject(new Error(`Timeout waiting for event '${name}'`));
+      }, timeout);
+      let cleanup;
+      switch (name) {
+        case "request": {
+          const handler = (req) => {
+            clearTimeout(timer);
+            cleanup();
+            resolve(req);
+          };
+          this.requestCallbacks.push(handler);
+          cleanup = () => {
+            this.requestCallbacks = this.requestCallbacks.filter((cb) => cb !== handler);
+          };
+          this.ensureDataCollector();
+          break;
+        }
+        case "response": {
+          const handler = (resp) => {
+            clearTimeout(timer);
+            cleanup();
+            resolve(resp);
+          };
+          this.responseCallbacks.push(handler);
+          cleanup = () => {
+            this.responseCallbacks = this.responseCallbacks.filter((cb) => cb !== handler);
+          };
+          this.ensureDataCollector();
+          break;
+        }
+        case "dialog": {
+          const handler = (dialog) => {
+            clearTimeout(timer);
+            cleanup();
+            resolve(dialog);
+          };
+          this.dialogCallbacks.push(handler);
+          cleanup = () => {
+            this.dialogCallbacks = this.dialogCallbacks.filter((cb) => cb !== handler);
+          };
+          break;
+        }
+        case "download": {
+          const handler = (download) => {
+            clearTimeout(timer);
+            cleanup();
+            resolve(download);
+          };
+          this.downloadCallbacks.push(handler);
+          cleanup = () => {
+            this.downloadCallbacks = this.downloadCallbacks.filter((cb) => cb !== handler);
+          };
+          break;
+        }
+        case "navigation": {
+          const handler = (url) => {
+            clearTimeout(timer);
+            cleanup();
+            resolve(url);
+          };
+          this.navigationCallbacks.push(handler);
+          cleanup = () => {
+            this.navigationCallbacks = this.navigationCallbacks.filter((cb) => cb !== handler);
+          };
+          break;
+        }
+        case "console": {
+          const handler = (msg) => {
+            clearTimeout(timer);
+            cleanup();
+            resolve(msg);
+          };
+          this.consoleCallbacks.push(handler);
+          cleanup = () => {
+            this.consoleCallbacks = this.consoleCallbacks.filter((cb) => cb !== handler);
+          };
+          break;
+        }
+        case "error": {
+          const handler = (err) => {
+            clearTimeout(timer);
+            cleanup();
+            resolve(err);
+          };
+          this.errorCallbacks.push(handler);
+          cleanup = () => {
+            this.errorCallbacks = this.errorCallbacks.filter((cb) => cb !== handler);
+          };
+          break;
+        }
+        default:
+          clearTimeout(timer);
+          reject(new Error(`Unknown event name: '${name}'`));
+      }
+    });
+  }
+  /** Set extra HTTP headers for all requests in this page. */
+  async setHeaders(headers) {
+    const result = await this.client.send("vibium:page.setHeaders", {
+      context: this.contextId,
+      headers
+    });
+    this.routes.push({
+      pattern: "**",
+      handler: (route) => {
+        const merged = { ...route.request.headers(), ...headers };
+        route.continue({ headers: merged });
+      },
+      interceptId: result.intercept
+    });
+  }
+  /** Intercept WebSocket connections. Not supported by BiDi. */
+  routeWebSocket(_pattern, _handler) {
+    throw new Error("Not implemented: BiDi does not support WebSocket interception");
+  }
+  /** Listen for WebSocket connections opened by the page. */
+  onWebSocket(fn) {
+    const isFirst = this.wsCallbacks.length === 0;
+    this.wsCallbacks.push(fn);
+    if (isFirst) {
+      this.client.send("vibium:page.onWebSocket", { context: this.contextId }).catch(() => {
+      });
+    }
+  }
+  // --- Dialog Handling ---
+  /**
+   * Register a handler for browser dialogs (alert, confirm, prompt).
+   * If no handler is registered, dialogs are automatically dismissed.
+   */
+  onDialog(handler) {
+    this.dialogCallbacks.push(handler);
+  }
+  /** Register a handler for console messages, or pass 'collect' to buffer them for consoleMessages(). */
+  onConsole(handler) {
+    if (handler === "collect") {
+      if (this._consoleBuffer === null) {
+        this._consoleBuffer = [];
+        this.consoleCallbacks.push((msg) => {
+          this._consoleBuffer?.push({ type: msg.type(), text: msg.text() });
+        });
+      }
+    } else {
+      this.consoleCallbacks.push(handler);
+    }
+  }
+  /** Return collected console messages and clear the buffer. Returns [] if not collecting. */
+  consoleMessages() {
+    const msgs = this._consoleBuffer || [];
+    if (this._consoleBuffer) this._consoleBuffer = [];
+    return msgs;
+  }
+  /** Register a handler for uncaught page errors, or pass 'collect' to buffer them for errors(). */
+  onError(handler) {
+    if (handler === "collect") {
+      if (this._errorBuffer === null) {
+        this._errorBuffer = [];
+        this.errorCallbacks.push((error) => {
+          this._errorBuffer?.push({ message: error.message });
+        });
+      }
+    } else {
+      this.errorCallbacks.push(handler);
+    }
+  }
+  /** Return collected errors and clear the buffer. Returns [] if not collecting. */
+  errors() {
+    const errs = this._errorBuffer || [];
+    if (this._errorBuffer) this._errorBuffer = [];
+    return errs;
+  }
+  /** Register a handler for file downloads. */
+  onDownload(handler) {
+    this.downloadCallbacks.push(handler);
+  }
+  // --- Event Handlers (internal) ---
+  ensureDataCollector() {
+    if (this.dataCollectorId !== null) return;
+    this.dataCollectorId = "pending";
+    this.client.send(
+      "network.addDataCollector",
+      { dataTypes: ["request", "response"], maxEncodedDataSize: 10 * 1024 * 1024 }
+    ).then((result) => {
+      this.dataCollectorId = result.collector;
+    }).catch(() => {
+      this.dataCollectorId = null;
+    });
+  }
+  teardownDataCollector() {
+    const id = this.dataCollectorId;
+    if (!id || id === "pending") {
+      this.dataCollectorId = null;
+      return;
+    }
+    this.dataCollectorId = null;
+    this.client.send("network.removeDataCollector", { collector: id }).catch(() => {
+    });
+  }
+  handleBeforeRequestSent(params) {
+    const isBlocked = params.isBlocked;
+    const request = params.request;
+    const requestId = request?.request;
+    if (isBlocked && requestId) {
+      const requestUrl = request?.url ?? "";
+      const req = new Request(params, this.client);
+      for (const routeEntry of this.routes) {
+        if (matchPattern(routeEntry.pattern, requestUrl)) {
+          const route = new Route(this.client, requestId, req);
+          try {
+            const result = routeEntry.handler(route);
+            if (result && typeof result.catch === "function") {
+              result.catch(() => {
+              });
+            }
+          } catch (_) {
+          }
+          return;
+        }
+      }
+      this.client.send("network.continueRequest", { request: requestId }).catch(() => {
+      });
+    } else {
+      const req = new Request(params, this.client);
+      for (const cb of this.requestCallbacks) {
+        cb(req);
+      }
+    }
+  }
+  handleResponseCompleted(params) {
+    const resp = new Response(params, this.client);
+    for (const cb of this.responseCallbacks) {
+      cb(resp);
+    }
+  }
+  handleUserPromptOpened(params) {
+    const dialog = new Dialog(this.client, this.contextId, params);
+    if (this.dialogCallbacks.length > 0) {
+      for (const cb of this.dialogCallbacks) {
+        try {
+          const result = cb(dialog);
+          if (result && typeof result.catch === "function") {
+            result.catch(() => {
+            });
+          }
+        } catch (_) {
+        }
+      }
+    } else {
+      dialog.dismiss().catch(() => {
+      });
+    }
+  }
+  handleLogEntryAdded(params) {
+    const entryType = params.type;
+    if (entryType === "console") {
+      const msg = new ConsoleMessage(params);
+      for (const cb of this.consoleCallbacks) {
+        cb(msg);
+      }
+    } else if (entryType === "javascript") {
+      const text = params.text ?? "Unknown error";
+      const error = new Error(text);
+      for (const cb of this.errorCallbacks) {
+        cb(error);
+      }
+    }
+  }
+  handleDownloadWillBegin(params) {
+    const url = params.url ?? "";
+    const suggestedFilename = params.suggestedFilename ?? "";
+    const navigation = params.navigation ?? "";
+    const download = new Download(this.client, url, suggestedFilename);
+    if (navigation) {
+      this.pendingDownloads.set(navigation, download);
+    }
+    for (const cb of this.downloadCallbacks) {
+      cb(download);
+    }
+  }
+  handleDownloadCompleted(params) {
+    const navigation = params.navigation ?? "";
+    const status = params.status ?? "complete";
+    const filepath = params.filepath ?? null;
+    const download = this.pendingDownloads.get(navigation);
+    if (download) {
+      download._complete(status, filepath);
+      this.pendingDownloads.delete(navigation);
+    }
+  }
+  handleWsCreated(params) {
+    const id = params.id;
+    const url = params.url;
+    const ws = new WebSocketInfo(url);
+    this.wsConnections.set(id, ws);
+    for (const cb of this.wsCallbacks) {
+      cb(ws);
+    }
+  }
+  handleWsMessage(params) {
+    const id = params.id;
+    const data = params.data;
+    const direction = params.direction;
+    const ws = this.wsConnections.get(id);
+    if (ws) {
+      ws._emitMessage(data, direction);
+    }
+  }
+  handleWsClosed(params) {
+    const id = params.id;
+    const code = params.code;
+    const reason = params.reason;
+    const ws = this.wsConnections.get(id);
+    if (ws) {
+      ws._emitClose(code, reason);
+      this.wsConnections.delete(id);
+    }
+  }
+};
+
+// src/browser.ts
+var customInspect3 = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var Browser = class {
+  constructor(client, process2) {
+    this.pageCallbacks = [];
+    this.popupCallbacks = [];
+    this.client = client;
+    this.process = process2;
+    this.client.onEvent((event) => {
+      if (event.method === "browsingContext.contextCreated") {
+        const params = event.params;
+        const callbacks = params.originalOpener ? this.popupCallbacks : this.pageCallbacks;
+        if (callbacks.length > 0) {
+          const page = new Page(this.client, params.context, params.userContext || "default");
+          for (const cb of callbacks) {
+            cb(page);
+          }
+        }
+      }
+    });
+  }
+  [customInspect3]() {
+    return "Browser { connected: true }";
+  }
+  /** Get the default page (first browsing context). */
+  async page() {
+    const result = await this.client.send("vibium:browser.page", {});
+    return new Page(this.client, result.context, result.userContext);
+  }
+  /** Create a new page (tab) in the default context. */
+  async newPage() {
+    const result = await this.client.send("vibium:browser.newPage", {});
+    return new Page(this.client, result.context, result.userContext);
+  }
+  /** Create a new browser context (isolated, incognito-like). */
+  async newContext() {
+    const result = await this.client.send("vibium:browser.newContext", {});
+    return new BrowserContext(this.client, result.userContext);
+  }
+  /** Get all open pages. */
+  async pages() {
+    const result = await this.client.send("vibium:browser.pages", {});
+    return result.pages.map((p) => new Page(this.client, p.context, p.userContext));
+  }
+  /** Register a callback for when a new page is created (e.g. new tab). */
+  onPage(callback) {
+    this.pageCallbacks.push(callback);
+  }
+  /** Register a callback for when a popup is opened (window.open or target=_blank). */
+  onPopup(callback) {
+    this.popupCallbacks.push(callback);
+  }
+  /**
+   * Remove all listeners for a given event, or all events if no event specified.
+   * Supported events: 'page', 'popup'.
+   */
+  removeAllListeners(event) {
+    if (!event || event === "page") {
+      this.pageCallbacks = [];
+    }
+    if (!event || event === "popup") {
+      this.popupCallbacks = [];
+    }
+  }
+  /** Stop the browser and clean up. */
+  async stop() {
+    try {
+      await this.client.send("vibium:browser.stop", {});
+    } catch {
+    }
+    await this.client.close();
+    if (this.process) {
+      await this.process.stop();
+    }
+  }
+};
+function envHeaders() {
+  const apiKey = process.env.VIBIUM_CONNECT_API_KEY;
+  return apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
+}
+var browser = {
+  async start(urlOrOptions, options = {}) {
+    let url;
+    if (typeof urlOrOptions === "object") {
+      options = urlOrOptions;
+      url = void 0;
+    } else {
+      url = urlOrOptions;
+    }
+    const connectURL = url || process.env.VIBIUM_CONNECT_URL;
+    if (connectURL) {
+      const headers = { ...envHeaders(), ...options.headers };
+      debug("connecting to remote browser", { url: connectURL });
+      const proc2 = await VibiumProcess.start({
+        connectURL,
+        connectHeaders: Object.keys(headers).length ? headers : void 0,
+        executablePath: options.executablePath
+      });
+      debug("vibium started (connect mode)");
+      const client2 = BiDiClient.fromStreams(
+        proc2.stdin,
+        proc2.stdout,
+        proc2.preReadyLines
+      );
+      info("browser connected (pipe \u2192 remote)");
+      return new Browser(client2, proc2);
+    }
+    const { headless = false, executablePath } = options;
+    if (process.platform === "openharmony" && !process.env.VIBIUM_CONNECT_URL) {
+      process.env.VIBIUM_SKIP_BROWSER_DOWNLOAD = "1";
+      const vibiumHome = process.env.HOME || "/storage/Users/currentUser";
+      const hdcPath = "/data/service/hnp/bin/hdc";
+      const bridgePath = require("path").join(__dirname, "bidi-bridge.js");
+      const cdpPort = options.cdpPort || 9333;
+      const bridgePort = options.bridgePort || 9517;
+      const browserPkg = options.harmonyBundleName || "com.haitai.htbrowser";
+      const browserAbility = options.harmonyAbility || "EntryAbility";
+      debug("HarmonyOS: auto-starting native browser + BiDi bridge");
+      try {
+        const { execFileSync, spawn } = require("child_process");
+        const fs = require("fs");
+        const http = require("http");
+        execFileSync(hdcPath, ["shell", "aa", "force-stop", browserPkg], { timeout: 1e4, stdio: "pipe" });
+        const cmdArgs = `--remote-debugging-port=${cdpPort} --remote-allow-origins=http://127.0.0.1:${cdpPort} --disable-extensions --no-first-run --no-default-browser-check --disable-popup-blocking --disable-dev-shm-usage --password-store=basic --use-mock-keychain --force-color-profile=srgb`;
+        execFileSync(hdcPath, ["shell", "aa", "start", "-b", browserPkg, "-a", browserAbility, "--ps", "cmdArgs", cmdArgs], { timeout: 1e4, stdio: "pipe" });
+        for (let i = 0; i < 15; i++) {
+          try {
+            await new Promise((resolve2, reject2) => {
+              const req2 = http.get(`http://127.0.0.1:${cdpPort}/json/version`, (res2) => {
+                let d = ""; res2.on("data", (c) => d += c); res2.on("end", () => { try { JSON.parse(d); resolve2(); } catch { reject2(new Error("not ready")); } });
+              });
+              req2.on("error", reject2); req2.setTimeout(2e3, () => { req2.destroy(); reject2(new Error("timeout")); });
+            });
+            break;
+          } catch { await new Promise((r) => setTimeout(r, 1e3)); }
+        }
+        debug("HarmonyOS: native browser CDP ready on port " + cdpPort);
+        const bridgeProc = spawn(process.execPath, [bridgePath, `--cdp-port=${cdpPort}`, `--listen-port=${bridgePort}`], { stdio: ["pipe", "pipe", "pipe"], detached: false, env: { ...process.env, NODE_PATH: require("path").dirname(require.resolve("ws/package.json")) } });
+        bridgeProc.unref();
+        process.env.VIBIUM_CONNECT_URL = `ws://127.0.0.1:${bridgePort}/session`;
+        for (let i = 0; i < 10; i++) {
+          try {
+            await new Promise((resolve3, reject3) => {
+              const WebSocket2 = require("ws");
+              const ws3 = new WebSocket2(`ws://127.0.0.1:${bridgePort}/session`);
+              ws3.on("open", () => { ws3.close(); resolve3(); });
+              ws3.on("error", reject3);
+              setTimeout(() => { ws3.close(); reject3(new Error("timeout")); }, 2e3);
+            });
+            break;
+          } catch { await new Promise((r) => setTimeout(r, 1e3)); }
+        }
+        debug("HarmonyOS: BiDi bridge ready, connecting vibium");
+        const proc2 = await VibiumProcess.start({ connectURL: process.env.VIBIUM_CONNECT_URL, executablePath: options.executablePath });
+        debug("vibium started (HarmonyOS native browser via bridge)");
+        const client2 = BiDiClient.fromStreams(proc2.stdin, proc2.stdout, proc2.preReadyLines);
+        info("browser launched (HarmonyOS native \u2192 bridge)");
+        return new Browser(client2, proc2);
+      } catch (harmonyErr) {
+        throw new BrowserCrashedError(1, "[HarmonyOS] Failed to auto-start native browser + bridge: " + (harmonyErr.message || harmonyErr) + "\nTo use a remote browser instead:\n  export VIBIUM_CONNECT_URL=ws://<remote-host>:9222/session");
+      }
+    }
+    debug("launching browser", { headless, executablePath });
+    let proc;
+    try {
+      proc = await VibiumProcess.start({
+        headless,
+        executablePath
+      });
+    } catch (err) {
+      if (process.platform === "openharmony" && err instanceof BrowserCrashedError) {
+        throw new BrowserCrashedError(err.exitCode, (err.output || "") + "\n\n[HarmonyOS] Browser launch failed. To use the native browser:\n  Ensure hdc is available and the browser is installed.\nTo use a remote browser:\n  export VIBIUM_CONNECT_URL=ws://<remote-host>:9222/session");
+      }
+      throw err;
+    }
+    debug("vibium started");
+    const client = BiDiClient.fromStreams(
+      proc.stdin,
+      proc.stdout,
+      proc.preReadyLines
+    );
+    info("browser launched (pipe)");
+    return new Browser(client, proc);
+  }
+};
+
+// src/sync/page.ts
+var fs2 = __toESM(require("fs"));
+var nodePath = __toESM(require("path"));
+
+// src/sync/element.ts
+var customInspect4 = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var ElementSync = class _ElementSync {
+  constructor(bridge, elementId, info2) {
+    this.bridge = bridge;
+    this.elementId = elementId;
+    this.info = info2;
+  }
+  [customInspect4]() {
+    const text = this.info.text.length > 50 ? this.info.text.slice(0, 50) + "..." : this.info.text;
+    return `Element { tag: '${this.info.tag}', text: '${text}' }`;
+  }
+  /**
+   * Click the element.
+   * Waits for element to be visible, stable, receive events, and enabled.
+   */
+  click(options) {
+    this.bridge.call("element.click", [this.elementId, options]);
+  }
+  /** Double-click the element. */
+  dblclick(options) {
+    this.bridge.call("element.dblclick", [this.elementId, options]);
+  }
+  /**
+   * Fill the element with text (clears existing content first).
+   * For inputs and textareas.
+   */
+  fill(value, options) {
+    this.bridge.call("element.fill", [this.elementId, value, options]);
+  }
+  /**
+   * Type text into the element.
+   * Waits for element to be visible, stable, receive events, enabled, and editable.
+   */
+  type(text, options) {
+    this.bridge.call("element.type", [this.elementId, text, options]);
+  }
+  /**
+   * Press a key while the element is focused.
+   * Supports key names ("Enter", "Tab") and combos ("Control+a").
+   */
+  press(key, options) {
+    this.bridge.call("element.press", [this.elementId, key, options]);
+  }
+  /** Clear the element's content (select all + delete). */
+  clear(options) {
+    this.bridge.call("element.clear", [this.elementId, options]);
+  }
+  /** Check a checkbox (no-op if already checked). */
+  check(options) {
+    this.bridge.call("element.check", [this.elementId, options]);
+  }
+  /** Uncheck a checkbox (no-op if already unchecked). */
+  uncheck(options) {
+    this.bridge.call("element.uncheck", [this.elementId, options]);
+  }
+  /** Select an option in a <select> element by value. */
+  selectOption(value, options) {
+    this.bridge.call("element.selectOption", [this.elementId, value, options]);
+  }
+  /** Hover over the element (move mouse to center, no click). */
+  hover(options) {
+    this.bridge.call("element.hover", [this.elementId, options]);
+  }
+  /** Focus the element. */
+  focus(options) {
+    this.bridge.call("element.focus", [this.elementId, options]);
+  }
+  /** Drag this element to a target element. */
+  dragTo(target, options) {
+    this.bridge.call("element.dragTo", [this.elementId, target.elementId, options]);
+  }
+  /** Tap the element (touch action). */
+  tap(options) {
+    this.bridge.call("element.tap", [this.elementId, options]);
+  }
+  /** Scroll the element into view. */
+  scrollIntoView(options) {
+    this.bridge.call("element.scrollIntoView", [this.elementId, options]);
+  }
+  /** Dispatch a DOM event on the element. */
+  dispatchEvent(eventType, eventInit, options) {
+    this.bridge.call("element.dispatchEvent", [this.elementId, eventType, eventInit, options]);
+  }
+  // --- State methods ---
+  text() {
+    const result = this.bridge.call("element.text", [this.elementId]);
+    return result.text;
+  }
+  innerText() {
+    const result = this.bridge.call("element.innerText", [this.elementId]);
+    return result.text;
+  }
+  html() {
+    const result = this.bridge.call("element.html", [this.elementId]);
+    return result.html;
+  }
+  value() {
+    const result = this.bridge.call("element.value", [this.elementId]);
+    return result.value;
+  }
+  attr(name) {
+    const result = this.bridge.call("element.attr", [this.elementId, name]);
+    return result.value;
+  }
+  getAttribute(name) {
+    return this.attr(name);
+  }
+  bounds() {
+    const result = this.bridge.call("element.bounds", [this.elementId]);
+    return result.box;
+  }
+  boundingBox() {
+    return this.bounds();
+  }
+  isVisible() {
+    const result = this.bridge.call("element.isVisible", [this.elementId]);
+    return result.visible;
+  }
+  isHidden() {
+    const result = this.bridge.call("element.isHidden", [this.elementId]);
+    return result.hidden;
+  }
+  isEnabled() {
+    const result = this.bridge.call("element.isEnabled", [this.elementId]);
+    return result.enabled;
+  }
+  isChecked() {
+    const result = this.bridge.call("element.isChecked", [this.elementId]);
+    return result.checked;
+  }
+  isEditable() {
+    const result = this.bridge.call("element.isEditable", [this.elementId]);
+    return result.editable;
+  }
+  screenshot() {
+    const result = this.bridge.call("element.screenshot", [this.elementId]);
+    return Buffer.from(result.data, "base64");
+  }
+  waitUntil(state, options) {
+    this.bridge.call("element.waitUntil", [this.elementId, state, options]);
+  }
+  setFiles(files, options) {
+    this.bridge.call("element.setFiles", [this.elementId, files, options]);
+  }
+  role() {
+    const result = this.bridge.call("element.role", [this.elementId]);
+    return result.role;
+  }
+  label() {
+    const result = this.bridge.call("element.label", [this.elementId]);
+    return result.label;
+  }
+  find(selector, options) {
+    const result = this.bridge.call("element.find", [this.elementId, selector, options]);
+    return new _ElementSync(this.bridge, result.elementId, result.info);
+  }
+  findAll(selector, options) {
+    const result = this.bridge.call("element.findAll", [this.elementId, selector, options]);
+    return result.elements.map((e) => new _ElementSync(this.bridge, e.elementId, e.info));
+  }
+};
+
+// src/sync/keyboard.ts
+var KeyboardSync = class {
+  constructor(bridge, pageId) {
+    this.bridge = bridge;
+    this.pageId = pageId;
+  }
+  press(key) {
+    this.bridge.call("keyboard.press", [this.pageId, key]);
+  }
+  down(key) {
+    this.bridge.call("keyboard.down", [this.pageId, key]);
+  }
+  up(key) {
+    this.bridge.call("keyboard.up", [this.pageId, key]);
+  }
+  type(text) {
+    this.bridge.call("keyboard.type", [this.pageId, text]);
+  }
+};
+var MouseSync = class {
+  constructor(bridge, pageId) {
+    this.bridge = bridge;
+    this.pageId = pageId;
+  }
+  click(x, y) {
+    this.bridge.call("mouse.click", [this.pageId, x, y]);
+  }
+  move(x, y) {
+    this.bridge.call("mouse.move", [this.pageId, x, y]);
+  }
+  down() {
+    this.bridge.call("mouse.down", [this.pageId]);
+  }
+  up() {
+    this.bridge.call("mouse.up", [this.pageId]);
+  }
+  wheel(deltaX, deltaY) {
+    this.bridge.call("mouse.wheel", [this.pageId, deltaX, deltaY]);
+  }
+};
+var TouchSync = class {
+  constructor(bridge, pageId) {
+    this.bridge = bridge;
+    this.pageId = pageId;
+  }
+  tap(x, y) {
+    this.bridge.call("touch.tap", [this.pageId, x, y]);
+  }
+};
+
+// src/sync/clock.ts
+var ClockSync = class {
+  constructor(bridge, pageId) {
+    this.bridge = bridge;
+    this.pageId = pageId;
+  }
+  install(options) {
+    const opts = options ? { ...options } : void 0;
+    if (opts?.time instanceof Date) {
+      opts.time = opts.time.getTime();
+    }
+    this.bridge.call("clock.install", [this.pageId, opts]);
+  }
+  fastForward(ticks) {
+    this.bridge.call("clock.fastForward", [this.pageId, ticks]);
+  }
+  runFor(ticks) {
+    this.bridge.call("clock.runFor", [this.pageId, ticks]);
+  }
+  pauseAt(time) {
+    const t = time instanceof Date ? time.getTime() : time;
+    this.bridge.call("clock.pauseAt", [this.pageId, t]);
+  }
+  resume() {
+    this.bridge.call("clock.resume", [this.pageId]);
+  }
+  setFixedTime(time) {
+    const t = time instanceof Date ? time.getTime() : time;
+    this.bridge.call("clock.setFixedTime", [this.pageId, t]);
+  }
+  setSystemTime(time) {
+    const t = time instanceof Date ? time.getTime() : time;
+    this.bridge.call("clock.setSystemTime", [this.pageId, t]);
+  }
+  setTimezone(timezone) {
+    this.bridge.call("clock.setTimezone", [this.pageId, timezone]);
+  }
+};
+
+// src/sync/recording.ts
+var RecordingSync = class {
+  constructor(bridge, contextId) {
+    this.bridge = bridge;
+    this.contextId = contextId;
+  }
+  start(options = {}) {
+    this.bridge.call("recording.start", [this.contextId, options]);
+  }
+  stop(options = {}) {
+    const result = this.bridge.call("recording.stop", [this.contextId, options]);
+    return Buffer.from(result.data, "base64");
+  }
+  startChunk(options = {}) {
+    this.bridge.call("recording.startChunk", [this.contextId, options]);
+  }
+  stopChunk(options = {}) {
+    const result = this.bridge.call("recording.stopChunk", [this.contextId, options]);
+    return Buffer.from(result.data, "base64");
+  }
+  startGroup(name, options = {}) {
+    this.bridge.call("recording.startGroup", [this.contextId, name, options]);
+  }
+  stopGroup() {
+    this.bridge.call("recording.stopGroup", [this.contextId]);
+  }
+};
+
+// src/sync/context.ts
+var BrowserContextSync = class {
+  constructor(bridge, contextId) {
+    this.bridge = bridge;
+    this.contextId = contextId;
+    this.recording = new RecordingSync(bridge, contextId);
+  }
+  newPage() {
+    const result = this.bridge.call("context.newPage", [this.contextId]);
+    return new PageSync(this.bridge, result.pageId);
+  }
+  close() {
+    this.bridge.call("context.close", [this.contextId]);
+  }
+  cookies(urls) {
+    const result = this.bridge.call("context.cookies", [this.contextId, urls]);
+    return result.cookies;
+  }
+  setCookies(cookies) {
+    this.bridge.call("context.setCookies", [this.contextId, cookies]);
+  }
+  clearCookies() {
+    this.bridge.call("context.clearCookies", [this.contextId]);
+  }
+  storage() {
+    return this.bridge.call("context.storage", [this.contextId]);
+  }
+  setStorage(state) {
+    this.bridge.call("context.setStorage", [this.contextId, state]);
+  }
+  clearStorage() {
+    this.bridge.call("context.clearStorage", [this.contextId]);
+  }
+  addInitScript(script) {
+    const result = this.bridge.call("context.addInitScript", [this.contextId, script]);
+    return result.script;
+  }
+};
+
+// src/sync/route.ts
+var RouteSync = class {
+  constructor(request) {
+    /** @internal */
+    this._decision = { action: "continue" };
+    this.request = request;
+  }
+  /** Fulfill the request with a custom response. */
+  fulfill(response = {}) {
+    this._decision = { action: "fulfill", ...response };
+  }
+  /** Continue the request, optionally with overrides. */
+  continue(overrides) {
+    this._decision = { action: "continue", ...overrides };
+  }
+  /** Abort the request. */
+  abort() {
+    this._decision = { action: "abort" };
+  }
+};
+
+// src/sync/dialog.ts
+var DialogSync = class {
+  constructor(data) {
+    /** @internal */
+    this._decision = { action: "dismiss" };
+    this.data = data;
+  }
+  /** The dialog type: 'alert', 'confirm', 'prompt', or 'beforeunload'. */
+  type() {
+    return this.data.type;
+  }
+  /** The dialog message text. */
+  message() {
+    return this.data.message;
+  }
+  /** The default value for prompt dialogs. */
+  defaultValue() {
+    return this.data.defaultValue;
+  }
+  /** Accept the dialog. For prompt dialogs, optionally provide text. */
+  accept(promptText) {
+    this._decision = { action: "accept" };
+    if (promptText !== void 0) this._decision.promptText = promptText;
+  }
+  /** Dismiss the dialog (cancel/close). */
+  dismiss() {
+    this._decision = { action: "dismiss" };
+  }
+};
+
+// src/sync/page.ts
+var customInspect5 = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var DownloadData = class {
+  constructor(data) {
+    this.url = data.url;
+    this.suggestedFilename = data.suggestedFilename;
+    this.path = data.path;
+  }
+  /** Save the downloaded file to a destination path. */
+  saveAs(destPath) {
+    if (!this.path) {
+      throw new Error("Download failed or path not available");
+    }
+    fs2.mkdirSync(nodePath.dirname(destPath), { recursive: true });
+    fs2.copyFileSync(this.path, destPath);
+  }
+};
+var WebSocketInfoSync = class {
+  constructor(url) {
+    this._isClosed = false;
+    this._messageHandlers = [];
+    this._closeHandlers = [];
+    this._url = url;
+  }
+  url() {
+    return this._url;
+  }
+  onMessage(fn) {
+    this._messageHandlers.push(fn);
+  }
+  onClose(fn) {
+    this._closeHandlers.push(fn);
+  }
+  isClosed() {
+    return this._isClosed;
+  }
+  /** @internal */
+  _emitMessage(data, direction) {
+    for (const fn of this._messageHandlers) fn(data, { direction });
+  }
+  /** @internal */
+  _emitClose(code, reason) {
+    this._isClosed = true;
+    for (const fn of this._closeHandlers) fn(code, reason);
+  }
+};
+var PageSync = class _PageSync {
+  constructor(bridge, pageId) {
+    this._nextHandlerId = 0;
+    this._routeHandlerIds = /* @__PURE__ */ new Map();
+    // pattern → handlerId
+    this._dialogHandlerId = null;
+    this._requestHandlerId = null;
+    this._responseHandlerId = null;
+    this._downloadHandlerId = null;
+    this._wsHandlerId = null;
+    this._wsInstances = /* @__PURE__ */ new Map();
+    this._cachedContext = null;
+    this._bridge = bridge;
+    this._pageId = pageId;
+    this.keyboard = new KeyboardSync(bridge, pageId);
+    this.mouse = new MouseSync(bridge, pageId);
+    this.touch = new TouchSync(bridge, pageId);
+    this.clock = new ClockSync(bridge, pageId);
+    this.waitUntil = Object.assign(
+      (fn, options) => {
+        const result = bridge.call("page.waitForFunction", [pageId, fn, options]);
+        return result.value;
+      },
+      {
+        url: (pattern, options) => {
+          bridge.call("page.waitForURL", [pageId, pattern, options]);
+        },
+        loaded: (state, options) => {
+          bridge.call("page.waitForLoad", [pageId, state, options]);
+        }
+      }
+    );
+  }
+  [customInspect5]() {
+    try {
+      const u = this.url();
+      const t = this.title();
+      return `Page { url: '${u}', title: '${t}' }`;
+    } catch {
+      return `Page { id: ${this._pageId} }`;
+    }
+  }
+  /** The parent BrowserContext that owns this page. */
+  get context() {
+    if (!this._cachedContext) {
+      const result = this._bridge.call("page.context", [this._pageId]);
+      this._cachedContext = new BrowserContextSync(this._bridge, result.contextId);
+    }
+    return this._cachedContext;
+  }
+  // --- Navigation ---
+  go(url) {
+    this._bridge.call("page.go", [this._pageId, url]);
+  }
+  back() {
+    this._bridge.call("page.back", [this._pageId]);
+  }
+  forward() {
+    this._bridge.call("page.forward", [this._pageId]);
+  }
+  reload() {
+    this._bridge.call("page.reload", [this._pageId]);
+  }
+  // --- Info ---
+  url() {
+    const result = this._bridge.call("page.url", [this._pageId]);
+    return result.url;
+  }
+  title() {
+    const result = this._bridge.call("page.title", [this._pageId]);
+    return result.title;
+  }
+  content() {
+    const result = this._bridge.call("page.content", [this._pageId]);
+    return result.content;
+  }
+  // --- Finding ---
+  find(selector, options) {
+    const result = this._bridge.call("page.find", [this._pageId, selector, options]);
+    return new ElementSync(this._bridge, result.elementId, result.info);
+  }
+  findAll(selector, options) {
+    const result = this._bridge.call("page.findAll", [this._pageId, selector, options]);
+    return result.elements.map((e) => new ElementSync(this._bridge, e.elementId, e.info));
+  }
+  // --- Waiting ---
+  /** Capture namespace — set up a listener before performing an action. */
+  get capture() {
+    const bridge = this._bridge;
+    const pageId = this._pageId;
+    return {
+      response(pattern, fn, options) {
+        if (fn) {
+          bridge.call("page.captureResponseStart", [pageId, pattern, options]);
+          fn();
+          return bridge.call("page.captureResponseFinish", [pageId]);
+        }
+        return bridge.call("page.waitForResponse", [pageId, pattern, options]);
+      },
+      request(pattern, fn, options) {
+        if (fn) {
+          bridge.call("page.captureRequestStart", [pageId, pattern, options]);
+          fn();
+          return bridge.call("page.captureRequestFinish", [pageId]);
+        }
+        return bridge.call("page.waitForRequest", [pageId, pattern, options]);
+      },
+      navigation(fn, options) {
+        bridge.call("page.captureNavigationStart", [pageId, options]);
+        if (fn) fn();
+        return bridge.call("page.captureNavigationFinish", [pageId]);
+      },
+      download(fn, options) {
+        bridge.call("page.captureDownloadStart", [pageId, options]);
+        if (fn) fn();
+        const raw = bridge.call("page.captureDownloadFinish", [pageId]);
+        return new DownloadData(raw);
+      },
+      dialog(fn, options) {
+        bridge.call("page.captureDialogStart", [pageId, options]);
+        if (fn) fn();
+        return bridge.call("page.captureDialogFinish", [pageId]);
+      },
+      event(name, fn, options) {
+        bridge.call("page.captureEventStart", [pageId, name, options]);
+        if (fn) fn();
+        return bridge.call("page.captureEventFinish", [pageId]);
+      }
+    };
+  }
+  wait(ms) {
+    this._bridge.call("page.wait", [this._pageId, ms]);
+  }
+  // --- Screenshots & PDF ---
+  screenshot(options) {
+    const result = this._bridge.call("page.screenshot", [this._pageId, options]);
+    return Buffer.from(result.data, "base64");
+  }
+  pdf() {
+    const result = this._bridge.call("page.pdf", [this._pageId]);
+    return Buffer.from(result.data, "base64");
+  }
+  // --- Evaluation ---
+  evaluate(expression) {
+    const result = this._bridge.call("page.eval", [this._pageId, expression]);
+    return result.value;
+  }
+  addScript(source) {
+    this._bridge.call("page.addScript", [this._pageId, source]);
+  }
+  addStyle(source) {
+    this._bridge.call("page.addStyle", [this._pageId, source]);
+  }
+  expose(name, fn) {
+    this._bridge.call("page.expose", [this._pageId, name, fn]);
+  }
+  // --- Lifecycle ---
+  bringToFront() {
+    this._bridge.call("page.bringToFront", [this._pageId]);
+  }
+  close() {
+    this._bridge.call("page.close", [this._pageId]);
+  }
+  scroll(direction, amount, selector) {
+    this._bridge.call("page.scroll", [this._pageId, direction, amount, selector]);
+  }
+  // --- Emulation ---
+  setViewport(size) {
+    this._bridge.call("page.setViewport", [this._pageId, size]);
+  }
+  viewport() {
+    return this._bridge.call("page.viewport", [this._pageId]);
+  }
+  emulateMedia(opts) {
+    this._bridge.call("page.emulateMedia", [this._pageId, opts]);
+  }
+  setContent(html) {
+    this._bridge.call("page.setContent", [this._pageId, html]);
+  }
+  setGeolocation(coords) {
+    this._bridge.call("page.setGeolocation", [this._pageId, coords]);
+  }
+  setWindow(options) {
+    this._bridge.call("page.setWindow", [this._pageId, options]);
+  }
+  window() {
+    return this._bridge.call("page.window", [this._pageId]);
+  }
+  // --- Frames ---
+  frames() {
+    const result = this._bridge.call("page.frames", [this._pageId]);
+    return result.frameIds.map((id) => new _PageSync(this._bridge, id));
+  }
+  frame(nameOrUrl) {
+    const result = this._bridge.call("page.frame", [this._pageId, nameOrUrl]);
+    if (result.frameId === null) return null;
+    return new _PageSync(this._bridge, result.frameId);
+  }
+  mainFrame() {
+    return this;
+  }
+  // --- Accessibility ---
+  a11yTree(options) {
+    const result = this._bridge.call("page.a11yTree", [this._pageId, options]);
+    return result.tree;
+  }
+  // --- Network ---
+  route(pattern, action) {
+    if (typeof action === "function") {
+      const handlerId = `route_${this._pageId}_${this._nextHandlerId++}`;
+      this._bridge.registerHandler(handlerId, (data) => {
+        const route = new RouteSync(data);
+        action(route);
+        return route._decision;
+      });
+      this._routeHandlerIds.set(pattern, handlerId);
+      this._bridge.call("page.routeWithCallback", [this._pageId, pattern, handlerId]);
+    } else {
+      this._bridge.call("page.route", [this._pageId, pattern, action]);
+    }
+  }
+  unroute(pattern) {
+    const handlerId = this._routeHandlerIds.get(pattern);
+    if (handlerId) {
+      this._bridge.unregisterHandler(handlerId);
+      this._routeHandlerIds.delete(pattern);
+    }
+    this._bridge.call("page.unroute", [this._pageId, pattern]);
+  }
+  setHeaders(headers) {
+    this._bridge.call("page.setHeaders", [this._pageId, headers]);
+  }
+  // --- Events ---
+  onDialog(action) {
+    if (typeof action === "function") {
+      const handlerId = `dialog_${this._pageId}_${this._nextHandlerId++}`;
+      this._bridge.registerHandler(handlerId, (data) => {
+        const dialog = new DialogSync(data);
+        action(dialog);
+        return dialog._decision;
+      });
+      if (this._dialogHandlerId) {
+        this._bridge.unregisterHandler(this._dialogHandlerId);
+      }
+      this._dialogHandlerId = handlerId;
+      this._bridge.call("page.onDialogWithCallback", [this._pageId, handlerId]);
+    } else {
+      this._bridge.call("page.onDialog", [this._pageId, action]);
+    }
+  }
+  onConsole(mode) {
+    this._bridge.call("page.onConsole", [this._pageId, mode]);
+  }
+  consoleMessages() {
+    const result = this._bridge.call("page.consoleMessages", [this._pageId]);
+    return result.messages;
+  }
+  onError(mode) {
+    this._bridge.call("page.onError", [this._pageId, mode]);
+  }
+  errors() {
+    const result = this._bridge.call("page.errors", [this._pageId]);
+    return result.errors;
+  }
+  onRequest(fn) {
+    const handlerId = `request_${this._pageId}_${this._nextHandlerId++}`;
+    this._bridge.registerHandler(handlerId, (data) => {
+      fn(data);
+      return null;
+    });
+    if (this._requestHandlerId) {
+      this._bridge.unregisterHandler(this._requestHandlerId);
+    }
+    this._requestHandlerId = handlerId;
+    this._bridge.call("page.onRequestWithCallback", [this._pageId, handlerId]);
+  }
+  onResponse(fn) {
+    const handlerId = `response_${this._pageId}_${this._nextHandlerId++}`;
+    this._bridge.registerHandler(handlerId, (data) => {
+      fn(data);
+      return null;
+    });
+    if (this._responseHandlerId) {
+      this._bridge.unregisterHandler(this._responseHandlerId);
+    }
+    this._responseHandlerId = handlerId;
+    this._bridge.call("page.onResponseWithCallback", [this._pageId, handlerId]);
+  }
+  onDownload(fn) {
+    const handlerId = `download_${this._pageId}_${this._nextHandlerId++}`;
+    this._bridge.registerHandler(handlerId, (data) => {
+      fn(new DownloadData(data));
+      return null;
+    });
+    if (this._downloadHandlerId) {
+      this._bridge.unregisterHandler(this._downloadHandlerId);
+    }
+    this._downloadHandlerId = handlerId;
+    this._bridge.call("page.onDownloadWithCallback", [this._pageId, handlerId]);
+  }
+  onWebSocket(fn) {
+    const handlerId = `ws_${this._pageId}_${this._nextHandlerId++}`;
+    this._bridge.registerHandler(handlerId, (data) => {
+      if (data.type === "created") {
+        const ws = new WebSocketInfoSync(data.url);
+        this._wsInstances.set(data.wsId, ws);
+        fn(ws);
+      } else if (data.type === "message") {
+        const ws = this._wsInstances.get(data.wsId);
+        if (ws) ws._emitMessage(data.data, data.direction);
+      } else if (data.type === "close") {
+        const ws = this._wsInstances.get(data.wsId);
+        if (ws) {
+          ws._emitClose(data.code, data.reason);
+          this._wsInstances.delete(data.wsId);
+        }
+      }
+      return null;
+    });
+    if (this._wsHandlerId) {
+      this._bridge.unregisterHandler(this._wsHandlerId);
+    }
+    this._wsHandlerId = handlerId;
+    this._bridge.call("page.onWebSocketWithCallback", [this._pageId, handlerId]);
+  }
+  removeAllListeners(event) {
+    if (!event || event === "dialog") {
+      if (this._dialogHandlerId) {
+        this._bridge.unregisterHandler(this._dialogHandlerId);
+        this._dialogHandlerId = null;
+      }
+    }
+    if (!event || event === "request") {
+      if (this._requestHandlerId) {
+        this._bridge.unregisterHandler(this._requestHandlerId);
+        this._requestHandlerId = null;
+      }
+      for (const [, handlerId] of this._routeHandlerIds) {
+        this._bridge.unregisterHandler(handlerId);
+      }
+      this._routeHandlerIds.clear();
+    }
+    if (!event || event === "response") {
+      if (this._responseHandlerId) {
+        this._bridge.unregisterHandler(this._responseHandlerId);
+        this._responseHandlerId = null;
+      }
+    }
+    if (!event || event === "download") {
+      if (this._downloadHandlerId) {
+        this._bridge.unregisterHandler(this._downloadHandlerId);
+        this._downloadHandlerId = null;
+      }
+    }
+    if (!event || event === "websocket") {
+      if (this._wsHandlerId) {
+        this._bridge.unregisterHandler(this._wsHandlerId);
+        this._wsHandlerId = null;
+      }
+      this._wsInstances.clear();
+    }
+    this._bridge.call("page.removeAllListeners", [this._pageId, event]);
+  }
+};
+
+// src/sync/browser.ts
+var customInspect6 = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var BrowserSync = class {
+  constructor(bridge) {
+    this._nextHandlerId = 0;
+    this._bridge = bridge;
+  }
+  [customInspect6]() {
+    return "Browser { connected: true }";
+  }
+  page() {
+    const result = this._bridge.call("browser.page");
+    return new PageSync(this._bridge, result.pageId);
+  }
+  newPage() {
+    const result = this._bridge.call("browser.newPage");
+    return new PageSync(this._bridge, result.pageId);
+  }
+  pages() {
+    const result = this._bridge.call("browser.pages");
+    return result.pageIds.map((id) => new PageSync(this._bridge, id));
+  }
+  newContext() {
+    const result = this._bridge.call("browser.newContext");
+    return new BrowserContextSync(this._bridge, result.contextId);
+  }
+  waitForPage(options) {
+    const result = this._bridge.call("browser.waitForPage", [options]);
+    return new PageSync(this._bridge, result.pageId);
+  }
+  waitForPopup(options) {
+    const result = this._bridge.call("browser.waitForPopup", [options]);
+    return new PageSync(this._bridge, result.pageId);
+  }
+  onPage(callback) {
+    if (this._pageHandlerId) {
+      this._bridge.unregisterHandler(this._pageHandlerId);
+    }
+    const handlerId = `page_${this._nextHandlerId++}`;
+    this._bridge.registerHandler(handlerId, (data) => {
+      callback(new PageSync(this._bridge, data.pageId));
+    });
+    this._pageHandlerId = handlerId;
+    this._bridge.call("browser.onPage", [handlerId]);
+  }
+  onPopup(callback) {
+    if (this._popupHandlerId) {
+      this._bridge.unregisterHandler(this._popupHandlerId);
+    }
+    const handlerId = `popup_${this._nextHandlerId++}`;
+    this._bridge.registerHandler(handlerId, (data) => {
+      callback(new PageSync(this._bridge, data.pageId));
+    });
+    this._popupHandlerId = handlerId;
+    this._bridge.call("browser.onPopup", [handlerId]);
+  }
+  removeAllListeners(event) {
+    if (!event || event === "page") {
+      if (this._pageHandlerId) {
+        this._bridge.unregisterHandler(this._pageHandlerId);
+        this._pageHandlerId = void 0;
+      }
+    }
+    if (!event || event === "popup") {
+      if (this._popupHandlerId) {
+        this._bridge.unregisterHandler(this._popupHandlerId);
+        this._popupHandlerId = void 0;
+      }
+    }
+    this._bridge.call("browser.removeAllListeners", [event]);
+  }
+  stop() {
+    this._bridge.tryQuit();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Browser,
+  BrowserContext,
+  BrowserContextSync,
+  BrowserCrashedError,
+  BrowserSync,
+  Clock,
+  ClockSync,
+  ConnectionError,
+  ConsoleMessage,
+  Dialog,
+  Download,
+  Element,
+  ElementNotFoundError,
+  ElementSync,
+  Keyboard,
+  KeyboardSync,
+  Mouse,
+  MouseSync,
+  Page,
+  PageSync,
+  Recording,
+  RecordingSync,
+  Request,
+  Response,
+  Route,
+  TimeoutError,
+  Touch,
+  TouchSync,
+  WebSocketInfo,
+  browser,
+  fluent
+});