@ohos-ports/vibium 26.5.31-beta.0

package/dist/worker.js

@@ -0,0 +1,3639 @@
+"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 __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
+));
+
+// src/sync/worker.ts
+var import_worker_threads = require("worker_threads");
+
+// 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(e) {
+  }
+  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 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 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(e) {
+      }
+    };
+    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(e) {
+            }
+            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(e) {
+      }
+      if (process.platform === "win32") {
+        try {
+          (0, import_child_process.execFileSync)("taskkill", ["/T", "/F", "/PID", this._process.pid.toString()], { stdio: "ignore" });
+        } catch(e) {
+        }
+        done();
+      } else {
+        setTimeout(() => {
+          if (!resolved) {
+            try {
+              this._process.kill("SIGTERM");
+            } catch(e) {
+            }
+          }
+        }, 1e3);
+        setTimeout(() => {
+          if (!resolved) {
+            try {
+              this._process.kill("SIGKILL");
+            } catch(e) {
+            }
+          }
+        }, 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(e) {
+      }
+    }
+    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(e) {
+    }
+  }
+};
+
+// 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 fs2 = await import("fs");
+      return fs2.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 fs2 = await import("fs");
+      return fs2.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(e) {
+      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(e) {
+      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(e) {
+    }
+    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/worker.ts
+var { signal, callbackPort } = import_worker_threads.workerData;
+var callbackChain = Promise.resolve(void 0);
+function invokeMainThread(handlerId, data) {
+  const call = callbackChain.then(async () => {
+    const decisionPromise = new Promise((resolve) => {
+      callbackPort.once("message", (msg) => {
+        resolve(msg.decision);
+      });
+    });
+    callbackPort.postMessage({ handlerId, data });
+    Atomics.store(signal, 0, 2);
+    Atomics.notify(signal, 0);
+    return await decisionPromise;
+  });
+  callbackChain = call.then(() => {
+  }, () => {
+  });
+  return call;
+}
+var browserInstance = null;
+var nextId = 1;
+var pages = /* @__PURE__ */ new Map();
+var contexts = /* @__PURE__ */ new Map();
+var elements = /* @__PURE__ */ new Map();
+var pageContextMap = /* @__PURE__ */ new Map();
+var defaultPageId = 0;
+function allocId() {
+  return nextId++;
+}
+function getPage(id) {
+  const p = pages.get(id);
+  if (!p) throw new Error(`Page ${id} not found`);
+  return p;
+}
+function getContext(id) {
+  const c = contexts.get(id);
+  if (!c) throw new Error(`Context ${id} not found`);
+  return c;
+}
+function getElement(id) {
+  const el = elements.get(id);
+  if (!el) throw new Error(`Element ${id} not found`);
+  return el;
+}
+function storePage(page) {
+  const id = allocId();
+  pages.set(id, page);
+  const pageContext = page.context;
+  let contextSyncId;
+  for (const [cid, ctx] of contexts) {
+    if (ctx.id === pageContext.id) {
+      contextSyncId = cid;
+      break;
+    }
+  }
+  if (contextSyncId === void 0) {
+    contextSyncId = storeContext(pageContext);
+  }
+  pageContextMap.set(id, contextSyncId);
+  return id;
+}
+function storeContext(ctx) {
+  const id = allocId();
+  contexts.set(id, ctx);
+  return id;
+}
+function storeElement(el) {
+  const id = allocId();
+  elements.set(id, el);
+  return id;
+}
+var pageEventBuffer = [];
+var onPageHandlerId = null;
+var onPopupHandlerId = null;
+var networkEventBuffer = [];
+var onRequestHandlerIds = /* @__PURE__ */ new Map();
+var onResponseHandlerIds = /* @__PURE__ */ new Map();
+var onDownloadHandlerIds = /* @__PURE__ */ new Map();
+var onWebSocketHandlerIds = /* @__PURE__ */ new Map();
+var handlers = {
+  // ========================
+  // Browser commands
+  // ========================
+  "browser.start": async (args) => {
+    const [url, options] = args;
+    browserInstance = await browser.start(url, options);
+    const page = await browserInstance.page();
+    defaultPageId = storePage(page);
+    return { pageId: defaultPageId };
+  },
+  "browser.stop": async () => {
+    if (!browserInstance) throw new Error("Browser not launched");
+    await browserInstance.stop();
+    browserInstance = null;
+    pages.clear();
+    contexts.clear();
+    elements.clear();
+    return { success: true };
+  },
+  "browser.page": async () => {
+    if (!browserInstance) throw new Error("Browser not launched");
+    if (defaultPageId && pages.has(defaultPageId)) {
+      return { pageId: defaultPageId };
+    }
+    const page = await browserInstance.page();
+    defaultPageId = storePage(page);
+    return { pageId: defaultPageId };
+  },
+  "browser.newPage": async () => {
+    if (!browserInstance) throw new Error("Browser not launched");
+    const page = await browserInstance.newPage();
+    const id = storePage(page);
+    return { pageId: id };
+  },
+  "browser.newContext": async () => {
+    if (!browserInstance) throw new Error("Browser not launched");
+    const ctx = await browserInstance.newContext();
+    const id = storeContext(ctx);
+    return { contextId: id };
+  },
+  "browser.pages": async () => {
+    if (!browserInstance) throw new Error("Browser not launched");
+    const allPages = await browserInstance.pages();
+    const ids = [];
+    for (const p of allPages) {
+      let found = false;
+      for (const [id, stored] of pages) {
+        if (stored.id === p.id) {
+          ids.push(id);
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        ids.push(storePage(p));
+      }
+    }
+    return { pageIds: ids };
+  },
+  "browser.onPage": async (args) => {
+    if (!browserInstance) throw new Error("Browser not launched");
+    const [handlerId] = args;
+    onPageHandlerId = handlerId;
+    const existingPages = await browserInstance.pages();
+    const knownContextIds = new Set(existingPages.map((p) => p.id));
+    browserInstance.removeAllListeners("page");
+    await new Promise((r) => setImmediate(r));
+    browserInstance.onPage((page) => {
+      if (knownContextIds.has(page.id)) return;
+      knownContextIds.add(page.id);
+      const id = storePage(page);
+      pageEventBuffer.push({ type: "page", pageId: id });
+    });
+    return { success: true };
+  },
+  "browser.onPopup": async (args) => {
+    if (!browserInstance) throw new Error("Browser not launched");
+    const [handlerId] = args;
+    onPopupHandlerId = handlerId;
+    const existingPages = await browserInstance.pages();
+    const knownContextIds = new Set(existingPages.map((p) => p.id));
+    browserInstance.removeAllListeners("popup");
+    await new Promise((r) => setImmediate(r));
+    browserInstance.onPopup((page) => {
+      if (knownContextIds.has(page.id)) return;
+      knownContextIds.add(page.id);
+      const id = storePage(page);
+      pageEventBuffer.push({ type: "popup", pageId: id });
+    });
+    return { success: true };
+  },
+  "browser.removeAllListeners": async (args) => {
+    if (!browserInstance) throw new Error("Browser not launched");
+    const [event] = args;
+    browserInstance.removeAllListeners(event);
+    if (!event || event === "page") onPageHandlerId = null;
+    if (!event || event === "popup") onPopupHandlerId = null;
+    return { success: true };
+  },
+  "browser.waitForPage": async (args) => {
+    if (!browserInstance) throw new Error("Browser not launched");
+    const [options] = args;
+    const timeout = options?.timeout ?? 1e4;
+    const page = await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        browserInstance?.removeAllListeners("page");
+        reject(new Error("Timeout waiting for new page"));
+      }, timeout);
+      browserInstance.onPage((p) => {
+        clearTimeout(timer);
+        resolve(p);
+      });
+    });
+    const id = storePage(page);
+    return { pageId: id };
+  },
+  "browser.waitForPopup": async (args) => {
+    if (!browserInstance) throw new Error("Browser not launched");
+    const [options] = args;
+    const timeout = options?.timeout ?? 1e4;
+    const page = await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        browserInstance?.removeAllListeners("popup");
+        reject(new Error("Timeout waiting for popup"));
+      }, timeout);
+      browserInstance.onPopup((p) => {
+        clearTimeout(timer);
+        resolve(p);
+      });
+    });
+    const id = storePage(page);
+    return { pageId: id };
+  },
+  // ========================
+  // Page commands
+  // ========================
+  "page.go": async (args) => {
+    const [pageId, url] = args;
+    await getPage(pageId).go(url);
+    return { success: true };
+  },
+  "page.back": async (args) => {
+    const [pageId] = args;
+    await getPage(pageId).back();
+    return { success: true };
+  },
+  "page.forward": async (args) => {
+    const [pageId] = args;
+    await getPage(pageId).forward();
+    return { success: true };
+  },
+  "page.reload": async (args) => {
+    const [pageId] = args;
+    await getPage(pageId).reload();
+    return { success: true };
+  },
+  "page.url": async (args) => {
+    const [pageId] = args;
+    const url = await getPage(pageId).url();
+    return { url };
+  },
+  "page.title": async (args) => {
+    const [pageId] = args;
+    const title = await getPage(pageId).title();
+    return { title };
+  },
+  "page.content": async (args) => {
+    const [pageId] = args;
+    const content = await getPage(pageId).content();
+    return { content };
+  },
+  "page.screenshot": async (args) => {
+    const [pageId, options] = args;
+    const buffer = await getPage(pageId).screenshot(options);
+    return { data: buffer.toString("base64") };
+  },
+  "page.pdf": async (args) => {
+    const [pageId] = args;
+    const buffer = await getPage(pageId).pdf();
+    return { data: buffer.toString("base64") };
+  },
+  "page.eval": async (args) => {
+    const [pageId, expression] = args;
+    const value = await getPage(pageId).evaluate(expression);
+    return { value };
+  },
+  "page.addScript": async (args) => {
+    const [pageId, source] = args;
+    await getPage(pageId).addScript(source);
+    return { success: true };
+  },
+  "page.addStyle": async (args) => {
+    const [pageId, source] = args;
+    await getPage(pageId).addStyle(source);
+    return { success: true };
+  },
+  "page.expose": async (args) => {
+    const [pageId, name, fn] = args;
+    await getPage(pageId).expose(name, fn);
+    return { success: true };
+  },
+  "page.find": async (args) => {
+    const [pageId, selector, options] = args;
+    const element = await getPage(pageId).find(selector, options);
+    const elementId = storeElement(element);
+    return { elementId, info: element.info };
+  },
+  "page.findAll": async (args) => {
+    const [pageId, selector, options] = args;
+    const arr = await getPage(pageId).findAll(selector, options);
+    const elements2 = [];
+    for (const el of arr) {
+      elements2.push({ elementId: storeElement(el), info: el.info });
+    }
+    return { elements: elements2 };
+  },
+  "page.wait": async (args) => {
+    const [pageId, ms] = args;
+    await getPage(pageId).wait(ms);
+    return { success: true };
+  },
+  "page.waitForURL": async (args) => {
+    const [pageId, pattern, options] = args;
+    await getPage(pageId).waitUntil.url(pattern, options);
+    return { success: true };
+  },
+  "page.waitForLoad": async (args) => {
+    const [pageId, state, options] = args;
+    await getPage(pageId).waitUntil.loaded(state, options);
+    return { success: true };
+  },
+  "page.waitForFunction": async (args) => {
+    const [pageId, fn, options] = args;
+    const value = await getPage(pageId).waitUntil(fn, options);
+    return { value };
+  },
+  "page.bringToFront": async (args) => {
+    const [pageId] = args;
+    await getPage(pageId).bringToFront();
+    return { success: true };
+  },
+  "page.close": async (args) => {
+    const [pageId] = args;
+    await getPage(pageId).close();
+    pages.delete(pageId);
+    return { success: true };
+  },
+  "page.scroll": async (args) => {
+    const [pageId, direction, amount, selector] = args;
+    await getPage(pageId).scroll(direction, amount, selector);
+    return { success: true };
+  },
+  // --- Page emulation ---
+  "page.setViewport": async (args) => {
+    const [pageId, size] = args;
+    await getPage(pageId).setViewport(size);
+    return { success: true };
+  },
+  "page.viewport": async (args) => {
+    const [pageId] = args;
+    return await getPage(pageId).viewport();
+  },
+  "page.emulateMedia": async (args) => {
+    const [pageId, opts] = args;
+    await getPage(pageId).emulateMedia(opts);
+    return { success: true };
+  },
+  "page.setContent": async (args) => {
+    const [pageId, html] = args;
+    await getPage(pageId).setContent(html);
+    return { success: true };
+  },
+  "page.setGeolocation": async (args) => {
+    const [pageId, coords] = args;
+    await getPage(pageId).setGeolocation(coords);
+    return { success: true };
+  },
+  "page.setWindow": async (args) => {
+    const [pageId, options] = args;
+    await getPage(pageId).setWindow(options);
+    return { success: true };
+  },
+  "page.window": async (args) => {
+    const [pageId] = args;
+    return await getPage(pageId).window();
+  },
+  // --- Page frames ---
+  "page.frames": async (args) => {
+    const [pageId] = args;
+    const frames = await getPage(pageId).frames();
+    const frameIds = frames.map((f) => storePage(f));
+    return { frameIds };
+  },
+  "page.frame": async (args) => {
+    const [pageId, nameOrUrl] = args;
+    const frame = await getPage(pageId).frame(nameOrUrl);
+    if (!frame) return { frameId: null };
+    const id = storePage(frame);
+    return { frameId: id };
+  },
+  "page.mainFrame": async (args) => {
+    const [pageId] = args;
+    return { frameId: pageId };
+  },
+  // --- Page accessibility ---
+  "page.a11yTree": async (args) => {
+    const [pageId, options] = args;
+    const tree = await getPage(pageId).a11yTree(options);
+    return { tree };
+  },
+  "page.context": async (args) => {
+    const [pageId] = args;
+    const contextId = pageContextMap.get(pageId);
+    if (contextId === void 0) throw new Error(`No context found for page ${pageId}`);
+    return { contextId };
+  },
+  // --- Page network ---
+  "page.route": async (args) => {
+    const [pageId, pattern, action] = args;
+    const page = getPage(pageId);
+    await page.route(pattern, (route) => {
+      if (action === "continue") {
+        route.continue();
+      } else if (action === "abort") {
+        route.abort();
+      } else if (typeof action === "object") {
+        route.fulfill(action);
+      }
+    });
+    return { success: true };
+  },
+  "page.routeWithCallback": async (args) => {
+    const [pageId, pattern, handlerId] = args;
+    const page = getPage(pageId);
+    await page.route(pattern, async (route) => {
+      let postData = null;
+      try {
+        postData = await Promise.race([
+          route.request.postData(),
+          new Promise((resolve) => setTimeout(() => resolve(null), 500))
+        ]);
+      } catch(e) {
+      }
+      const requestData = {
+        url: route.request.url(),
+        method: route.request.method(),
+        headers: route.request.headers(),
+        postData
+      };
+      const decision = await invokeMainThread(handlerId, requestData);
+      if (!decision || decision.action === "continue") {
+        const overrides = {};
+        if (decision?.url) overrides.url = decision.url;
+        if (decision?.method) overrides.method = decision.method;
+        if (decision?.headers) overrides.headers = decision.headers;
+        if (decision?.postData) overrides.postData = decision.postData;
+        await route.continue(Object.keys(overrides).length > 0 ? overrides : void 0);
+      } else if (decision.action === "fulfill") {
+        await route.fulfill({
+          status: decision.status,
+          headers: decision.headers,
+          contentType: decision.contentType,
+          body: decision.body
+        });
+      } else if (decision.action === "abort") {
+        await route.abort();
+      }
+    });
+    return { success: true };
+  },
+  "page.unroute": async (args) => {
+    const [pageId, pattern] = args;
+    await getPage(pageId).unroute(pattern);
+    return { success: true };
+  },
+  "page.setHeaders": async (args) => {
+    const [pageId, headers] = args;
+    await getPage(pageId).setHeaders(headers);
+    return { success: true };
+  },
+  "page.waitForRequest": async (args) => {
+    const [pageId, pattern, options] = args;
+    const page = getPage(pageId);
+    const request = await page.capture.request(pattern, void 0, options);
+    return {
+      url: request.url(),
+      method: request.method(),
+      headers: request.headers(),
+      postData: await request.postData()
+    };
+  },
+  "page.waitForResponse": async (args) => {
+    const [pageId, pattern, options] = args;
+    const page = getPage(pageId);
+    const response = await page.capture.response(pattern, void 0, options);
+    return {
+      url: response.url(),
+      status: response.status(),
+      headers: response.headers(),
+      body: await response.body()
+    };
+  },
+  "page.captureResponseStart": async (args) => {
+    const [pageId, pattern, options] = args;
+    const page = getPage(pageId);
+    page._pendingCaptureResponse = page.capture.response(pattern, void 0, options);
+    return { success: true };
+  },
+  "page.captureResponseFinish": async (args) => {
+    const [pageId] = args;
+    const page = getPage(pageId);
+    const response = await page._pendingCaptureResponse;
+    delete page._pendingCaptureResponse;
+    return {
+      url: response.url(),
+      status: response.status(),
+      headers: response.headers(),
+      body: await response.body()
+    };
+  },
+  "page.captureRequestStart": async (args) => {
+    const [pageId, pattern, options] = args;
+    const page = getPage(pageId);
+    page._pendingCaptureRequest = page.capture.request(pattern, void 0, options);
+    return { success: true };
+  },
+  "page.captureRequestFinish": async (args) => {
+    const [pageId] = args;
+    const page = getPage(pageId);
+    const request = await page._pendingCaptureRequest;
+    delete page._pendingCaptureRequest;
+    return {
+      url: request.url(),
+      method: request.method(),
+      headers: request.headers(),
+      postData: await request.postData()
+    };
+  },
+  "page.captureNavigationStart": async (args) => {
+    const [pageId, options] = args;
+    const page = getPage(pageId);
+    page._pendingCaptureNavigation = page.capture.navigation(void 0, options);
+    return { success: true };
+  },
+  "page.captureNavigationFinish": async (args) => {
+    const [pageId] = args;
+    const page = getPage(pageId);
+    const url = await page._pendingCaptureNavigation;
+    delete page._pendingCaptureNavigation;
+    return { url };
+  },
+  "page.captureDownloadStart": async (args) => {
+    const [pageId, options] = args;
+    const page = getPage(pageId);
+    page._pendingCaptureDownload = page.capture.download(void 0, options);
+    return { success: true };
+  },
+  "page.captureDownloadFinish": async (args) => {
+    const [pageId] = args;
+    const page = getPage(pageId);
+    const download = await page._pendingCaptureDownload;
+    delete page._pendingCaptureDownload;
+    const filePath = await download.path();
+    return {
+      url: download.url(),
+      suggestedFilename: download.suggestedFilename(),
+      path: filePath
+    };
+  },
+  "page.captureDialogStart": async (args) => {
+    const [pageId, options] = args;
+    const page = getPage(pageId);
+    page._pendingCaptureDialog = page.capture.dialog(void 0, options);
+    return { success: true };
+  },
+  "page.captureDialogFinish": async (args) => {
+    const [pageId] = args;
+    const page = getPage(pageId);
+    const dialog = await page._pendingCaptureDialog;
+    delete page._pendingCaptureDialog;
+    return {
+      type: dialog.type(),
+      message: dialog.message(),
+      defaultValue: dialog.defaultValue()
+    };
+  },
+  "page.captureEventStart": async (args) => {
+    const [pageId, name, options] = args;
+    const page = getPage(pageId);
+    page._pendingCaptureEvent = page.capture.event(name, void 0, options);
+    return { success: true };
+  },
+  "page.captureEventFinish": async (args) => {
+    const [pageId] = args;
+    const page = getPage(pageId);
+    const data = await page._pendingCaptureEvent;
+    delete page._pendingCaptureEvent;
+    if (data && typeof data === "object") {
+      if ("url" in data && "status" in data) {
+        return { url: data.url(), status: data.status(), headers: data.headers() };
+      }
+      if ("url" in data && "method" in data) {
+        return { url: data.url(), method: data.method(), headers: data.headers() };
+      }
+      if ("type" in data && "message" in data) {
+        return { type: data.type(), message: data.message(), defaultValue: data.defaultValue() };
+      }
+    }
+    return { data };
+  },
+  // --- Page events (simplified for sync) ---
+  "page.onDialog": async (args) => {
+    const [pageId, action] = args;
+    const page = getPage(pageId);
+    page.onDialog((dialog) => {
+      if (action === "accept") {
+        dialog.accept().catch(() => {
+        });
+      } else {
+        dialog.dismiss().catch(() => {
+        });
+      }
+    });
+    return { success: true };
+  },
+  "page.onDialogWithCallback": async (args) => {
+    const [pageId, handlerId] = args;
+    const page = getPage(pageId);
+    page.onDialog(async (dialog) => {
+      const dialogData = {
+        type: dialog.type(),
+        message: dialog.message(),
+        defaultValue: dialog.defaultValue()
+      };
+      const decision = await invokeMainThread(handlerId, dialogData);
+      if (!decision || decision.action === "dismiss") {
+        await dialog.dismiss();
+      } else if (decision.action === "accept") {
+        await dialog.accept(decision.promptText);
+      }
+    });
+    return { success: true };
+  },
+  "page.onConsole": async (args) => {
+    const [pageId, mode] = args;
+    if (mode !== "collect") throw new Error('Only "collect" mode supported');
+    const page = getPage(pageId);
+    if (!page._syncConsoleBuffer) {
+      page._syncConsoleBuffer = [];
+      page.onConsole((msg) => {
+        page._syncConsoleBuffer.push({
+          type: msg.type(),
+          text: msg.text()
+        });
+      });
+    }
+    return { success: true };
+  },
+  "page.consoleMessages": async (args) => {
+    const [pageId] = args;
+    const page = getPage(pageId);
+    const buffer = page._syncConsoleBuffer || [];
+    page._syncConsoleBuffer = [];
+    return { messages: buffer };
+  },
+  "page.onError": async (args) => {
+    const [pageId, mode] = args;
+    if (mode !== "collect") throw new Error('Only "collect" mode supported');
+    const page = getPage(pageId);
+    if (!page._syncErrorBuffer) {
+      page._syncErrorBuffer = [];
+      page.onError((error) => {
+        page._syncErrorBuffer.push({
+          message: error.message
+        });
+      });
+    }
+    return { success: true };
+  },
+  "page.errors": async (args) => {
+    const [pageId] = args;
+    const page = getPage(pageId);
+    const buffer = page._syncErrorBuffer || [];
+    page._syncErrorBuffer = [];
+    return { errors: buffer };
+  },
+  "page.onRequestWithCallback": async (args) => {
+    const [pageId, handlerId] = args;
+    const page = getPage(pageId);
+    onRequestHandlerIds.set(pageId, handlerId);
+    page.onRequest(async (req) => {
+      const hid = onRequestHandlerIds.get(pageId);
+      if (!hid) return;
+      networkEventBuffer.push({
+        handlerId: hid,
+        data: { url: req.url(), method: req.method(), headers: req.headers(), postData: await req.postData() }
+      });
+    });
+    return { success: true };
+  },
+  "page.onResponseWithCallback": async (args) => {
+    const [pageId, handlerId] = args;
+    const page = getPage(pageId);
+    onResponseHandlerIds.set(pageId, handlerId);
+    page.onResponse(async (resp) => {
+      const hid = onResponseHandlerIds.get(pageId);
+      if (!hid) return;
+      networkEventBuffer.push({
+        handlerId: hid,
+        data: { url: resp.url(), status: resp.status(), headers: resp.headers(), body: await resp.body() }
+      });
+    });
+    return { success: true };
+  },
+  "page.onDownloadWithCallback": async (args) => {
+    const [pageId, handlerId] = args;
+    const page = getPage(pageId);
+    onDownloadHandlerIds.set(pageId, handlerId);
+    page.onDownload(async (dl) => {
+      const hid = onDownloadHandlerIds.get(pageId);
+      if (!hid) return;
+      const filePath = await dl.path();
+      networkEventBuffer.push({
+        handlerId: hid,
+        data: { url: dl.url(), suggestedFilename: dl.suggestedFilename(), path: filePath }
+      });
+    });
+    return { success: true };
+  },
+  "page.onWebSocketWithCallback": async (args) => {
+    const [pageId, handlerId] = args;
+    const page = getPage(pageId);
+    onWebSocketHandlerIds.set(pageId, handlerId);
+    let nextWsId = 0;
+    page.onWebSocket((ws) => {
+      const hid = onWebSocketHandlerIds.get(pageId);
+      if (!hid) return;
+      const wsId = nextWsId++;
+      networkEventBuffer.push({
+        handlerId: hid,
+        data: { type: "created", wsId, url: ws.url() }
+      });
+      ws.onMessage((data, info2) => {
+        const hid2 = onWebSocketHandlerIds.get(pageId);
+        if (!hid2) return;
+        networkEventBuffer.push({
+          handlerId: hid2,
+          data: { type: "message", wsId, data, direction: info2.direction }
+        });
+      });
+      ws.onClose((code, reason) => {
+        const hid2 = onWebSocketHandlerIds.get(pageId);
+        if (!hid2) return;
+        networkEventBuffer.push({
+          handlerId: hid2,
+          data: { type: "close", wsId, code, reason }
+        });
+      });
+    });
+    return { success: true };
+  },
+  "page.removeAllListeners": async (args) => {
+    const [pageId, event] = args;
+    getPage(pageId).removeAllListeners(event);
+    if (!event || event === "request") onRequestHandlerIds.delete(pageId);
+    if (!event || event === "response") onResponseHandlerIds.delete(pageId);
+    if (!event || event === "download") onDownloadHandlerIds.delete(pageId);
+    if (!event || event === "websocket") onWebSocketHandlerIds.delete(pageId);
+    return { success: true };
+  },
+  // ========================
+  // Context commands
+  // ========================
+  "context.newPage": async (args) => {
+    const [contextId] = args;
+    const ctx = getContext(contextId);
+    const page = await ctx.newPage();
+    const id = storePage(page);
+    return { pageId: id };
+  },
+  "context.close": async (args) => {
+    const [contextId] = args;
+    await getContext(contextId).close();
+    contexts.delete(contextId);
+    return { success: true };
+  },
+  "context.cookies": async (args) => {
+    const [contextId, urls] = args;
+    const cookies = await getContext(contextId).cookies(urls);
+    return { cookies };
+  },
+  "context.setCookies": async (args) => {
+    const [contextId, cookies] = args;
+    await getContext(contextId).setCookies(cookies);
+    return { success: true };
+  },
+  "context.clearCookies": async (args) => {
+    const [contextId] = args;
+    await getContext(contextId).clearCookies();
+    return { success: true };
+  },
+  "context.storage": async (args) => {
+    const [contextId] = args;
+    return await getContext(contextId).storage();
+  },
+  "context.setStorage": async (args) => {
+    const [contextId, state] = args;
+    await getContext(contextId).setStorage(state);
+    return { success: true };
+  },
+  "context.clearStorage": async (args) => {
+    const [contextId] = args;
+    await getContext(contextId).clearStorage();
+    return { success: true };
+  },
+  "context.addInitScript": async (args) => {
+    const [contextId, script] = args;
+    const result = await getContext(contextId).addInitScript(script);
+    return { script: result };
+  },
+  // ========================
+  // Recording commands (context-scoped)
+  // ========================
+  "recording.start": async (args) => {
+    const [contextId, options] = args;
+    await getContext(contextId).recording.start(options);
+    return { success: true };
+  },
+  "recording.stop": async (args) => {
+    const [contextId, options] = args;
+    const buffer = await getContext(contextId).recording.stop(options);
+    return { data: buffer.toString("base64") };
+  },
+  "recording.startChunk": async (args) => {
+    const [contextId, options] = args;
+    await getContext(contextId).recording.startChunk(options);
+    return { success: true };
+  },
+  "recording.stopChunk": async (args) => {
+    const [contextId, options] = args;
+    const buffer = await getContext(contextId).recording.stopChunk(options);
+    return { data: buffer.toString("base64") };
+  },
+  "recording.startGroup": async (args) => {
+    const [contextId, name, options] = args;
+    await getContext(contextId).recording.startGroup(name, options);
+    return { success: true };
+  },
+  "recording.stopGroup": async (args) => {
+    const [contextId] = args;
+    await getContext(contextId).recording.stopGroup();
+    return { success: true };
+  },
+  // ========================
+  // Clock commands (page-scoped)
+  // ========================
+  "clock.install": async (args) => {
+    const [pageId, options] = args;
+    await getPage(pageId).clock.install(options);
+    return { success: true };
+  },
+  "clock.fastForward": async (args) => {
+    const [pageId, ticks] = args;
+    await getPage(pageId).clock.fastForward(ticks);
+    return { success: true };
+  },
+  "clock.runFor": async (args) => {
+    const [pageId, ticks] = args;
+    await getPage(pageId).clock.runFor(ticks);
+    return { success: true };
+  },
+  "clock.pauseAt": async (args) => {
+    const [pageId, time] = args;
+    await getPage(pageId).clock.pauseAt(time);
+    return { success: true };
+  },
+  "clock.resume": async (args) => {
+    const [pageId] = args;
+    await getPage(pageId).clock.resume();
+    return { success: true };
+  },
+  "clock.setFixedTime": async (args) => {
+    const [pageId, time] = args;
+    await getPage(pageId).clock.setFixedTime(time);
+    return { success: true };
+  },
+  "clock.setSystemTime": async (args) => {
+    const [pageId, time] = args;
+    await getPage(pageId).clock.setSystemTime(time);
+    return { success: true };
+  },
+  "clock.setTimezone": async (args) => {
+    const [pageId, timezone] = args;
+    await getPage(pageId).clock.setTimezone(timezone);
+    return { success: true };
+  },
+  // ========================
+  // Keyboard commands (page-scoped)
+  // ========================
+  "keyboard.press": async (args) => {
+    const [pageId, key] = args;
+    await getPage(pageId).keyboard.press(key);
+    return { success: true };
+  },
+  "keyboard.down": async (args) => {
+    const [pageId, key] = args;
+    await getPage(pageId).keyboard.down(key);
+    return { success: true };
+  },
+  "keyboard.up": async (args) => {
+    const [pageId, key] = args;
+    await getPage(pageId).keyboard.up(key);
+    return { success: true };
+  },
+  "keyboard.type": async (args) => {
+    const [pageId, text] = args;
+    await getPage(pageId).keyboard.type(text);
+    return { success: true };
+  },
+  // ========================
+  // Mouse commands (page-scoped)
+  // ========================
+  "mouse.click": async (args) => {
+    const [pageId, x, y] = args;
+    await getPage(pageId).mouse.click(x, y);
+    return { success: true };
+  },
+  "mouse.move": async (args) => {
+    const [pageId, x, y] = args;
+    await getPage(pageId).mouse.move(x, y);
+    return { success: true };
+  },
+  "mouse.down": async (args) => {
+    const [pageId] = args;
+    await getPage(pageId).mouse.down();
+    return { success: true };
+  },
+  "mouse.up": async (args) => {
+    const [pageId] = args;
+    await getPage(pageId).mouse.up();
+    return { success: true };
+  },
+  "mouse.wheel": async (args) => {
+    const [pageId, deltaX, deltaY] = args;
+    await getPage(pageId).mouse.wheel(deltaX, deltaY);
+    return { success: true };
+  },
+  // ========================
+  // Touch commands (page-scoped)
+  // ========================
+  "touch.tap": async (args) => {
+    const [pageId, x, y] = args;
+    await getPage(pageId).touch.tap(x, y);
+    return { success: true };
+  },
+  // ========================
+  // Element commands
+  // ========================
+  "element.click": async (args) => {
+    const [elementId, options] = args;
+    await getElement(elementId).click(options);
+    return { success: true };
+  },
+  "element.dblclick": async (args) => {
+    const [elementId, options] = args;
+    await getElement(elementId).dblclick(options);
+    return { success: true };
+  },
+  "element.fill": async (args) => {
+    const [elementId, value, options] = args;
+    await getElement(elementId).fill(value, options);
+    return { success: true };
+  },
+  "element.type": async (args) => {
+    const [elementId, text, options] = args;
+    await getElement(elementId).type(text, options);
+    return { success: true };
+  },
+  "element.press": async (args) => {
+    const [elementId, key, options] = args;
+    await getElement(elementId).press(key, options);
+    return { success: true };
+  },
+  "element.clear": async (args) => {
+    const [elementId, options] = args;
+    await getElement(elementId).clear(options);
+    return { success: true };
+  },
+  "element.check": async (args) => {
+    const [elementId, options] = args;
+    await getElement(elementId).check(options);
+    return { success: true };
+  },
+  "element.uncheck": async (args) => {
+    const [elementId, options] = args;
+    await getElement(elementId).uncheck(options);
+    return { success: true };
+  },
+  "element.selectOption": async (args) => {
+    const [elementId, value, options] = args;
+    await getElement(elementId).selectOption(value, options);
+    return { success: true };
+  },
+  "element.hover": async (args) => {
+    const [elementId, options] = args;
+    await getElement(elementId).hover(options);
+    return { success: true };
+  },
+  "element.focus": async (args) => {
+    const [elementId, options] = args;
+    await getElement(elementId).focus(options);
+    return { success: true };
+  },
+  "element.dragTo": async (args) => {
+    const [elementId, targetId, options] = args;
+    const target = getElement(targetId);
+    await getElement(elementId).dragTo(target, options);
+    return { success: true };
+  },
+  "element.tap": async (args) => {
+    const [elementId, options] = args;
+    await getElement(elementId).tap(options);
+    return { success: true };
+  },
+  "element.scrollIntoView": async (args) => {
+    const [elementId, options] = args;
+    await getElement(elementId).scrollIntoView(options);
+    return { success: true };
+  },
+  "element.dispatchEvent": async (args) => {
+    const [elementId, eventType, eventInit, options] = args;
+    await getElement(elementId).dispatchEvent(eventType, eventInit, options);
+    return { success: true };
+  },
+  "element.setFiles": async (args) => {
+    const [elementId, files, options] = args;
+    await getElement(elementId).setFiles(files, options);
+    return { success: true };
+  },
+  "element.text": async (args) => {
+    const [elementId] = args;
+    const text = await getElement(elementId).text();
+    return { text };
+  },
+  "element.innerText": async (args) => {
+    const [elementId] = args;
+    const text = await getElement(elementId).innerText();
+    return { text };
+  },
+  "element.html": async (args) => {
+    const [elementId] = args;
+    const html = await getElement(elementId).html();
+    return { html };
+  },
+  "element.value": async (args) => {
+    const [elementId] = args;
+    const value = await getElement(elementId).value();
+    return { value };
+  },
+  "element.attr": async (args) => {
+    const [elementId, name] = args;
+    const value = await getElement(elementId).attr(name);
+    return { value };
+  },
+  "element.getAttribute": async (args) => {
+    const [elementId, name] = args;
+    const value = await getElement(elementId).getAttribute(name);
+    return { value };
+  },
+  "element.bounds": async (args) => {
+    const [elementId] = args;
+    const box = await getElement(elementId).bounds();
+    return { box };
+  },
+  "element.boundingBox": async (args) => {
+    const [elementId] = args;
+    const box = await getElement(elementId).boundingBox();
+    return { box };
+  },
+  "element.isVisible": async (args) => {
+    const [elementId] = args;
+    const visible = await getElement(elementId).isVisible();
+    return { visible };
+  },
+  "element.isHidden": async (args) => {
+    const [elementId] = args;
+    const hidden = await getElement(elementId).isHidden();
+    return { hidden };
+  },
+  "element.isEnabled": async (args) => {
+    const [elementId] = args;
+    const enabled = await getElement(elementId).isEnabled();
+    return { enabled };
+  },
+  "element.isChecked": async (args) => {
+    const [elementId] = args;
+    const checked = await getElement(elementId).isChecked();
+    return { checked };
+  },
+  "element.isEditable": async (args) => {
+    const [elementId] = args;
+    const editable = await getElement(elementId).isEditable();
+    return { editable };
+  },
+  "element.role": async (args) => {
+    const [elementId] = args;
+    const role = await getElement(elementId).role();
+    return { role };
+  },
+  "element.label": async (args) => {
+    const [elementId] = args;
+    const label = await getElement(elementId).label();
+    return { label };
+  },
+  "element.screenshot": async (args) => {
+    const [elementId] = args;
+    const buffer = await getElement(elementId).screenshot();
+    return { data: buffer.toString("base64") };
+  },
+  "element.waitUntil": async (args) => {
+    const [elementId, state, options] = args;
+    await getElement(elementId).waitUntil(state, options);
+    return { success: true };
+  },
+  "element.find": async (args) => {
+    const [elementId, selector, options] = args;
+    const child = await getElement(elementId).find(selector, options);
+    const childId = storeElement(child);
+    return { elementId: childId, info: child.info };
+  },
+  "element.findAll": async (args) => {
+    const [elementId, selector, options] = args;
+    const arr = await getElement(elementId).findAll(selector, options);
+    const elements2 = [];
+    for (const el of arr) {
+      elements2.push({ elementId: storeElement(el), info: el.info });
+    }
+    return { elements: elements2 };
+  },
+  // ========================
+  // Quit
+  // ========================
+  "quit": async () => {
+    if (!browserInstance) throw new Error("Browser not launched");
+    await browserInstance.stop();
+    browserInstance = null;
+    pages.clear();
+    contexts.clear();
+    elements.clear();
+    return { success: true };
+  }
+};
+async function handleCommand(cmd) {
+  const handler = handlers[cmd.method];
+  if (!handler) {
+    throw new Error(`Unknown method: ${cmd.method}`);
+  }
+  return handler(cmd.args);
+}
+import_worker_threads.parentPort.on("message", async ({ cmd, port }) => {
+  let result;
+  let error = null;
+  try {
+    result = await handleCommand(cmd);
+  } catch (err) {
+    error = err instanceof Error ? err.message : String(err);
+  }
+  if (onPageHandlerId || onPopupHandlerId || networkEventBuffer.length > 0) {
+    await new Promise((r) => setImmediate(r));
+  }
+  while (pageEventBuffer.length > 0) {
+    const event = pageEventBuffer.shift();
+    const handlerId = event.type === "page" ? onPageHandlerId : onPopupHandlerId;
+    if (handlerId) {
+      await invokeMainThread(handlerId, { pageId: event.pageId });
+    }
+  }
+  while (networkEventBuffer.length > 0) {
+    const event = networkEventBuffer.shift();
+    await invokeMainThread(event.handlerId, event.data);
+  }
+  port.postMessage({ result, error });
+  Atomics.store(signal, 0, 1);
+  Atomics.notify(signal, 0);
+});
+import_worker_threads.parentPort.on("message", async ({ cmd, port }) => {
+  let result;
+  let error = null;
+  try {
+    result = await handleCommand(cmd);
+  } catch (err) {
+    error = err instanceof Error ? err.message : String(err);
+  }
+  if (onPageHandlerId || onPopupHandlerId || networkEventBuffer.length > 0) {
+    await new Promise((r) => setImmediate(r));
+  }
+  while (pageEventBuffer.length > 0) {
+    const event = pageEventBuffer.shift();
+    const handlerId = event.type === "page" ? onPageHandlerId : onPopupHandlerId;
+    if (handlerId) {
+      await invokeMainThread(handlerId, { pageId: event.pageId });
+    }
+  }
+  while (networkEventBuffer.length > 0) {
+    const event = networkEventBuffer.shift();
+    await invokeMainThread(event.handlerId, event.data);
+  }
+  port.postMessage({ result, error });
+  Atomics.store(signal, 0, 1);
+  Atomics.notify(signal, 0);
+});