@ohos-ports/vibium 26.5.31-beta.0

package/dist/sync.js

@@ -0,0 +1,1112 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/sync/index.ts
+var sync_exports = {};
+__export(sync_exports, {
+  BrowserContextSync: () => BrowserContextSync,
+  BrowserSync: () => BrowserSync,
+  ClockSync: () => ClockSync,
+  DialogSync: () => DialogSync,
+  DownloadData: () => DownloadData,
+  ElementSync: () => ElementSync,
+  KeyboardSync: () => KeyboardSync,
+  MouseSync: () => MouseSync,
+  PageSync: () => PageSync,
+  RecordingSync: () => RecordingSync,
+  RouteSync: () => RouteSync,
+  TouchSync: () => TouchSync,
+  WebSocketInfoSync: () => WebSocketInfoSync,
+  browser: () => browser
+});
+module.exports = __toCommonJS(sync_exports);
+
+// src/sync/bridge.ts
+var import_worker_threads = require("worker_threads");
+var path = __toESM(require("path"));
+var activeBridges = /* @__PURE__ */ new Set();
+function cleanup() {
+  for (const bridge of activeBridges) {
+    try {
+      bridge.tryQuit();
+    } catch {
+    }
+  }
+  activeBridges.clear();
+}
+var handlersRegistered = false;
+function registerCleanupHandlers() {
+  if (handlersRegistered) return;
+  handlersRegistered = true;
+  process.on("exit", cleanup);
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(143);
+  });
+}
+var SyncBridge = class _SyncBridge {
+  constructor(worker, signal, callbackPortMain, callbackPortWorker) {
+    this.commandId = 0;
+    this.terminated = false;
+    this.handlers = /* @__PURE__ */ new Map();
+    this.worker = worker;
+    this.signal = signal;
+    this.callbackPortMain = callbackPortMain;
+    this.callbackPortWorker = callbackPortWorker;
+  }
+  static create() {
+    registerCleanupHandlers();
+    const signal = new Int32Array(new SharedArrayBuffer(8));
+    const { port1: callbackPortMain, port2: callbackPortWorker } = new import_worker_threads.MessageChannel();
+    const workerPath = path.join(__dirname, "worker.js");
+    const worker = new import_worker_threads.Worker(workerPath, {
+      workerData: { signal, callbackPort: callbackPortWorker },
+      transferList: [callbackPortWorker]
+    });
+    const bridge = new _SyncBridge(worker, signal, callbackPortMain, callbackPortWorker);
+    activeBridges.add(bridge);
+    return bridge;
+  }
+  /** Register a callback handler that can be invoked from the worker thread. */
+  registerHandler(id, handler) {
+    this.handlers.set(id, handler);
+  }
+  /** Remove a previously registered callback handler. */
+  unregisterHandler(id) {
+    this.handlers.delete(id);
+  }
+  /** Process any pending callbacks that fired between bridge calls. */
+  processPendingCallbacks() {
+    while (Atomics.load(this.signal, 0) === 2) {
+      this.handleCallback();
+    }
+  }
+  /** Handle a single callback request from the worker. */
+  handleCallback() {
+    const maxSpinIterations = 6e4;
+    let cbMsg = (0, import_worker_threads.receiveMessageOnPort)(this.callbackPortMain);
+    let spinCount = 0;
+    while (!cbMsg) {
+      spinCount++;
+      if (spinCount >= maxSpinIterations) {
+        throw new Error("Timed out waiting for callback message from worker (60s)");
+      }
+      Atomics.wait(this.signal, 1, Atomics.load(this.signal, 1), 1);
+      cbMsg = (0, import_worker_threads.receiveMessageOnPort)(this.callbackPortMain);
+    }
+    let decision = null;
+    const req = cbMsg.message;
+    const handler = this.handlers.get(req.handlerId);
+    if (handler) {
+      try {
+        decision = handler(req.data);
+      } catch {
+      }
+    }
+    Atomics.store(this.signal, 0, 0);
+    this.callbackPortMain.postMessage({ decision });
+  }
+  call(method, args = []) {
+    this.processPendingCallbacks();
+    const cmd = { id: this.commandId++, method, args };
+    const { port1, port2 } = new import_worker_threads.MessageChannel();
+    Atomics.store(this.signal, 0, 0);
+    Atomics.store(this.signal, 1, 0);
+    this.worker.postMessage({ cmd, port: port2 }, [port2]);
+    const commandTimeoutMs = 6e4;
+    const waitSliceMs = 1e3;
+    const startTime = Date.now();
+    for (; ; ) {
+      const waitResult = Atomics.wait(this.signal, 0, 0, waitSliceMs);
+      if (waitResult === "timed-out") {
+        if (Date.now() - startTime >= commandTimeoutMs) {
+          port1.close();
+          throw new Error(`Bridge call '${method}' timed out after ${commandTimeoutMs / 1e3}s \u2014 worker may have died`);
+        }
+        continue;
+      }
+      const sig = Atomics.load(this.signal, 0);
+      if (sig === 1) {
+        const message = (0, import_worker_threads.receiveMessageOnPort)(port1);
+        port1.close();
+        if (!message) {
+          throw new Error("No response from worker");
+        }
+        const response = message.message;
+        if (response.error) {
+          throw new Error(response.error);
+        }
+        return response.result;
+      }
+      if (sig === 2) {
+        this.handleCallback();
+      }
+    }
+  }
+  tryQuit() {
+    if (this.terminated) return;
+    try {
+      const cmd = { id: this.commandId++, method: "quit", args: [] };
+      const { port1, port2 } = new import_worker_threads.MessageChannel();
+      Atomics.store(this.signal, 0, 0);
+      Atomics.store(this.signal, 1, 0);
+      this.worker.postMessage({ cmd, port: port2 }, [port2]);
+      for (; ; ) {
+        const waitResult = Atomics.wait(this.signal, 0, 0, 5e3);
+        if (waitResult === "timed-out") {
+          port1.close();
+          this.terminate();
+          return;
+        }
+        const sig = Atomics.load(this.signal, 0);
+        if (sig === 1) {
+          port1.close();
+          this.callbackPortMain.close();
+          this.terminated = true;
+          activeBridges.delete(this);
+          this.worker.terminate();
+          return;
+        }
+        if (sig === 2) {
+          this.handleCallback();
+        }
+      }
+    } catch {
+      this.terminate();
+    }
+  }
+  terminate() {
+    if (this.terminated) return;
+    this.terminated = true;
+    this.callbackPortMain.close();
+    activeBridges.delete(this);
+    this.worker.terminate();
+  }
+};
+
+// src/sync/page.ts
+var fs = __toESM(require("fs"));
+var nodePath = __toESM(require("path"));
+
+// src/sync/element.ts
+var customInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var ElementSync = class _ElementSync {
+  constructor(bridge, elementId, info) {
+    this.bridge = bridge;
+    this.elementId = elementId;
+    this.info = info;
+  }
+  [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}' }`;
+  }
+  /**
+   * Click the element.
+   * Waits for element to be visible, stable, receive events, and enabled.
+   */
+  click(options) {
+    this.bridge.call("element.click", [this.elementId, options]);
+  }
+  /** Double-click the element. */
+  dblclick(options) {
+    this.bridge.call("element.dblclick", [this.elementId, options]);
+  }
+  /**
+   * Fill the element with text (clears existing content first).
+   * For inputs and textareas.
+   */
+  fill(value, options) {
+    this.bridge.call("element.fill", [this.elementId, value, options]);
+  }
+  /**
+   * Type text into the element.
+   * Waits for element to be visible, stable, receive events, enabled, and editable.
+   */
+  type(text, options) {
+    this.bridge.call("element.type", [this.elementId, text, options]);
+  }
+  /**
+   * Press a key while the element is focused.
+   * Supports key names ("Enter", "Tab") and combos ("Control+a").
+   */
+  press(key, options) {
+    this.bridge.call("element.press", [this.elementId, key, options]);
+  }
+  /** Clear the element's content (select all + delete). */
+  clear(options) {
+    this.bridge.call("element.clear", [this.elementId, options]);
+  }
+  /** Check a checkbox (no-op if already checked). */
+  check(options) {
+    this.bridge.call("element.check", [this.elementId, options]);
+  }
+  /** Uncheck a checkbox (no-op if already unchecked). */
+  uncheck(options) {
+    this.bridge.call("element.uncheck", [this.elementId, options]);
+  }
+  /** Select an option in a <select> element by value. */
+  selectOption(value, options) {
+    this.bridge.call("element.selectOption", [this.elementId, value, options]);
+  }
+  /** Hover over the element (move mouse to center, no click). */
+  hover(options) {
+    this.bridge.call("element.hover", [this.elementId, options]);
+  }
+  /** Focus the element. */
+  focus(options) {
+    this.bridge.call("element.focus", [this.elementId, options]);
+  }
+  /** Drag this element to a target element. */
+  dragTo(target, options) {
+    this.bridge.call("element.dragTo", [this.elementId, target.elementId, options]);
+  }
+  /** Tap the element (touch action). */
+  tap(options) {
+    this.bridge.call("element.tap", [this.elementId, options]);
+  }
+  /** Scroll the element into view. */
+  scrollIntoView(options) {
+    this.bridge.call("element.scrollIntoView", [this.elementId, options]);
+  }
+  /** Dispatch a DOM event on the element. */
+  dispatchEvent(eventType, eventInit, options) {
+    this.bridge.call("element.dispatchEvent", [this.elementId, eventType, eventInit, options]);
+  }
+  // --- State methods ---
+  text() {
+    const result = this.bridge.call("element.text", [this.elementId]);
+    return result.text;
+  }
+  innerText() {
+    const result = this.bridge.call("element.innerText", [this.elementId]);
+    return result.text;
+  }
+  html() {
+    const result = this.bridge.call("element.html", [this.elementId]);
+    return result.html;
+  }
+  value() {
+    const result = this.bridge.call("element.value", [this.elementId]);
+    return result.value;
+  }
+  attr(name) {
+    const result = this.bridge.call("element.attr", [this.elementId, name]);
+    return result.value;
+  }
+  getAttribute(name) {
+    return this.attr(name);
+  }
+  bounds() {
+    const result = this.bridge.call("element.bounds", [this.elementId]);
+    return result.box;
+  }
+  boundingBox() {
+    return this.bounds();
+  }
+  isVisible() {
+    const result = this.bridge.call("element.isVisible", [this.elementId]);
+    return result.visible;
+  }
+  isHidden() {
+    const result = this.bridge.call("element.isHidden", [this.elementId]);
+    return result.hidden;
+  }
+  isEnabled() {
+    const result = this.bridge.call("element.isEnabled", [this.elementId]);
+    return result.enabled;
+  }
+  isChecked() {
+    const result = this.bridge.call("element.isChecked", [this.elementId]);
+    return result.checked;
+  }
+  isEditable() {
+    const result = this.bridge.call("element.isEditable", [this.elementId]);
+    return result.editable;
+  }
+  screenshot() {
+    const result = this.bridge.call("element.screenshot", [this.elementId]);
+    return Buffer.from(result.data, "base64");
+  }
+  waitUntil(state, options) {
+    this.bridge.call("element.waitUntil", [this.elementId, state, options]);
+  }
+  setFiles(files, options) {
+    this.bridge.call("element.setFiles", [this.elementId, files, options]);
+  }
+  role() {
+    const result = this.bridge.call("element.role", [this.elementId]);
+    return result.role;
+  }
+  label() {
+    const result = this.bridge.call("element.label", [this.elementId]);
+    return result.label;
+  }
+  find(selector, options) {
+    const result = this.bridge.call("element.find", [this.elementId, selector, options]);
+    return new _ElementSync(this.bridge, result.elementId, result.info);
+  }
+  findAll(selector, options) {
+    const result = this.bridge.call("element.findAll", [this.elementId, selector, options]);
+    return result.elements.map((e) => new _ElementSync(this.bridge, e.elementId, e.info));
+  }
+};
+
+// src/sync/keyboard.ts
+var KeyboardSync = class {
+  constructor(bridge, pageId) {
+    this.bridge = bridge;
+    this.pageId = pageId;
+  }
+  press(key) {
+    this.bridge.call("keyboard.press", [this.pageId, key]);
+  }
+  down(key) {
+    this.bridge.call("keyboard.down", [this.pageId, key]);
+  }
+  up(key) {
+    this.bridge.call("keyboard.up", [this.pageId, key]);
+  }
+  type(text) {
+    this.bridge.call("keyboard.type", [this.pageId, text]);
+  }
+};
+var MouseSync = class {
+  constructor(bridge, pageId) {
+    this.bridge = bridge;
+    this.pageId = pageId;
+  }
+  click(x, y) {
+    this.bridge.call("mouse.click", [this.pageId, x, y]);
+  }
+  move(x, y) {
+    this.bridge.call("mouse.move", [this.pageId, x, y]);
+  }
+  down() {
+    this.bridge.call("mouse.down", [this.pageId]);
+  }
+  up() {
+    this.bridge.call("mouse.up", [this.pageId]);
+  }
+  wheel(deltaX, deltaY) {
+    this.bridge.call("mouse.wheel", [this.pageId, deltaX, deltaY]);
+  }
+};
+var TouchSync = class {
+  constructor(bridge, pageId) {
+    this.bridge = bridge;
+    this.pageId = pageId;
+  }
+  tap(x, y) {
+    this.bridge.call("touch.tap", [this.pageId, x, y]);
+  }
+};
+
+// src/sync/clock.ts
+var ClockSync = class {
+  constructor(bridge, pageId) {
+    this.bridge = bridge;
+    this.pageId = pageId;
+  }
+  install(options) {
+    const opts = options ? { ...options } : void 0;
+    if (opts?.time instanceof Date) {
+      opts.time = opts.time.getTime();
+    }
+    this.bridge.call("clock.install", [this.pageId, opts]);
+  }
+  fastForward(ticks) {
+    this.bridge.call("clock.fastForward", [this.pageId, ticks]);
+  }
+  runFor(ticks) {
+    this.bridge.call("clock.runFor", [this.pageId, ticks]);
+  }
+  pauseAt(time) {
+    const t = time instanceof Date ? time.getTime() : time;
+    this.bridge.call("clock.pauseAt", [this.pageId, t]);
+  }
+  resume() {
+    this.bridge.call("clock.resume", [this.pageId]);
+  }
+  setFixedTime(time) {
+    const t = time instanceof Date ? time.getTime() : time;
+    this.bridge.call("clock.setFixedTime", [this.pageId, t]);
+  }
+  setSystemTime(time) {
+    const t = time instanceof Date ? time.getTime() : time;
+    this.bridge.call("clock.setSystemTime", [this.pageId, t]);
+  }
+  setTimezone(timezone) {
+    this.bridge.call("clock.setTimezone", [this.pageId, timezone]);
+  }
+};
+
+// src/sync/recording.ts
+var RecordingSync = class {
+  constructor(bridge, contextId) {
+    this.bridge = bridge;
+    this.contextId = contextId;
+  }
+  start(options = {}) {
+    this.bridge.call("recording.start", [this.contextId, options]);
+  }
+  stop(options = {}) {
+    const result = this.bridge.call("recording.stop", [this.contextId, options]);
+    return Buffer.from(result.data, "base64");
+  }
+  startChunk(options = {}) {
+    this.bridge.call("recording.startChunk", [this.contextId, options]);
+  }
+  stopChunk(options = {}) {
+    const result = this.bridge.call("recording.stopChunk", [this.contextId, options]);
+    return Buffer.from(result.data, "base64");
+  }
+  startGroup(name, options = {}) {
+    this.bridge.call("recording.startGroup", [this.contextId, name, options]);
+  }
+  stopGroup() {
+    this.bridge.call("recording.stopGroup", [this.contextId]);
+  }
+};
+
+// src/sync/context.ts
+var BrowserContextSync = class {
+  constructor(bridge, contextId) {
+    this.bridge = bridge;
+    this.contextId = contextId;
+    this.recording = new RecordingSync(bridge, contextId);
+  }
+  newPage() {
+    const result = this.bridge.call("context.newPage", [this.contextId]);
+    return new PageSync(this.bridge, result.pageId);
+  }
+  close() {
+    this.bridge.call("context.close", [this.contextId]);
+  }
+  cookies(urls) {
+    const result = this.bridge.call("context.cookies", [this.contextId, urls]);
+    return result.cookies;
+  }
+  setCookies(cookies) {
+    this.bridge.call("context.setCookies", [this.contextId, cookies]);
+  }
+  clearCookies() {
+    this.bridge.call("context.clearCookies", [this.contextId]);
+  }
+  storage() {
+    return this.bridge.call("context.storage", [this.contextId]);
+  }
+  setStorage(state) {
+    this.bridge.call("context.setStorage", [this.contextId, state]);
+  }
+  clearStorage() {
+    this.bridge.call("context.clearStorage", [this.contextId]);
+  }
+  addInitScript(script) {
+    const result = this.bridge.call("context.addInitScript", [this.contextId, script]);
+    return result.script;
+  }
+};
+
+// src/sync/route.ts
+var RouteSync = class {
+  constructor(request) {
+    /** @internal */
+    this._decision = { action: "continue" };
+    this.request = request;
+  }
+  /** Fulfill the request with a custom response. */
+  fulfill(response = {}) {
+    this._decision = { action: "fulfill", ...response };
+  }
+  /** Continue the request, optionally with overrides. */
+  continue(overrides) {
+    this._decision = { action: "continue", ...overrides };
+  }
+  /** Abort the request. */
+  abort() {
+    this._decision = { action: "abort" };
+  }
+};
+
+// src/sync/dialog.ts
+var DialogSync = class {
+  constructor(data) {
+    /** @internal */
+    this._decision = { action: "dismiss" };
+    this.data = data;
+  }
+  /** The dialog type: 'alert', 'confirm', 'prompt', or 'beforeunload'. */
+  type() {
+    return this.data.type;
+  }
+  /** The dialog message text. */
+  message() {
+    return this.data.message;
+  }
+  /** The default value for prompt dialogs. */
+  defaultValue() {
+    return this.data.defaultValue;
+  }
+  /** Accept the dialog. For prompt dialogs, optionally provide text. */
+  accept(promptText) {
+    this._decision = { action: "accept" };
+    if (promptText !== void 0) this._decision.promptText = promptText;
+  }
+  /** Dismiss the dialog (cancel/close). */
+  dismiss() {
+    this._decision = { action: "dismiss" };
+  }
+};
+
+// src/sync/page.ts
+var customInspect2 = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var DownloadData = class {
+  constructor(data) {
+    this.url = data.url;
+    this.suggestedFilename = data.suggestedFilename;
+    this.path = data.path;
+  }
+  /** Save the downloaded file to a destination path. */
+  saveAs(destPath) {
+    if (!this.path) {
+      throw new Error("Download failed or path not available");
+    }
+    fs.mkdirSync(nodePath.dirname(destPath), { recursive: true });
+    fs.copyFileSync(this.path, destPath);
+  }
+};
+var WebSocketInfoSync = class {
+  constructor(url) {
+    this._isClosed = false;
+    this._messageHandlers = [];
+    this._closeHandlers = [];
+    this._url = url;
+  }
+  url() {
+    return this._url;
+  }
+  onMessage(fn) {
+    this._messageHandlers.push(fn);
+  }
+  onClose(fn) {
+    this._closeHandlers.push(fn);
+  }
+  isClosed() {
+    return this._isClosed;
+  }
+  /** @internal */
+  _emitMessage(data, direction) {
+    for (const fn of this._messageHandlers) fn(data, { direction });
+  }
+  /** @internal */
+  _emitClose(code, reason) {
+    this._isClosed = true;
+    for (const fn of this._closeHandlers) fn(code, reason);
+  }
+};
+var PageSync = class _PageSync {
+  constructor(bridge, pageId) {
+    this._nextHandlerId = 0;
+    this._routeHandlerIds = /* @__PURE__ */ new Map();
+    // pattern → handlerId
+    this._dialogHandlerId = null;
+    this._requestHandlerId = null;
+    this._responseHandlerId = null;
+    this._downloadHandlerId = null;
+    this._wsHandlerId = null;
+    this._wsInstances = /* @__PURE__ */ new Map();
+    this._cachedContext = null;
+    this._bridge = bridge;
+    this._pageId = pageId;
+    this.keyboard = new KeyboardSync(bridge, pageId);
+    this.mouse = new MouseSync(bridge, pageId);
+    this.touch = new TouchSync(bridge, pageId);
+    this.clock = new ClockSync(bridge, pageId);
+    this.waitUntil = Object.assign(
+      (fn, options) => {
+        const result = bridge.call("page.waitForFunction", [pageId, fn, options]);
+        return result.value;
+      },
+      {
+        url: (pattern, options) => {
+          bridge.call("page.waitForURL", [pageId, pattern, options]);
+        },
+        loaded: (state, options) => {
+          bridge.call("page.waitForLoad", [pageId, state, options]);
+        }
+      }
+    );
+  }
+  [customInspect2]() {
+    try {
+      const u = this.url();
+      const t = this.title();
+      return `Page { url: '${u}', title: '${t}' }`;
+    } catch {
+      return `Page { id: ${this._pageId} }`;
+    }
+  }
+  /** The parent BrowserContext that owns this page. */
+  get context() {
+    if (!this._cachedContext) {
+      const result = this._bridge.call("page.context", [this._pageId]);
+      this._cachedContext = new BrowserContextSync(this._bridge, result.contextId);
+    }
+    return this._cachedContext;
+  }
+  // --- Navigation ---
+  go(url) {
+    this._bridge.call("page.go", [this._pageId, url]);
+  }
+  back() {
+    this._bridge.call("page.back", [this._pageId]);
+  }
+  forward() {
+    this._bridge.call("page.forward", [this._pageId]);
+  }
+  reload() {
+    this._bridge.call("page.reload", [this._pageId]);
+  }
+  // --- Info ---
+  url() {
+    const result = this._bridge.call("page.url", [this._pageId]);
+    return result.url;
+  }
+  title() {
+    const result = this._bridge.call("page.title", [this._pageId]);
+    return result.title;
+  }
+  content() {
+    const result = this._bridge.call("page.content", [this._pageId]);
+    return result.content;
+  }
+  // --- Finding ---
+  find(selector, options) {
+    const result = this._bridge.call("page.find", [this._pageId, selector, options]);
+    return new ElementSync(this._bridge, result.elementId, result.info);
+  }
+  findAll(selector, options) {
+    const result = this._bridge.call("page.findAll", [this._pageId, selector, options]);
+    return result.elements.map((e) => new ElementSync(this._bridge, e.elementId, e.info));
+  }
+  // --- Waiting ---
+  /** Capture namespace — set up a listener before performing an action. */
+  get capture() {
+    const bridge = this._bridge;
+    const pageId = this._pageId;
+    return {
+      response(pattern, fn, options) {
+        if (fn) {
+          bridge.call("page.captureResponseStart", [pageId, pattern, options]);
+          fn();
+          return bridge.call("page.captureResponseFinish", [pageId]);
+        }
+        return bridge.call("page.waitForResponse", [pageId, pattern, options]);
+      },
+      request(pattern, fn, options) {
+        if (fn) {
+          bridge.call("page.captureRequestStart", [pageId, pattern, options]);
+          fn();
+          return bridge.call("page.captureRequestFinish", [pageId]);
+        }
+        return bridge.call("page.waitForRequest", [pageId, pattern, options]);
+      },
+      navigation(fn, options) {
+        bridge.call("page.captureNavigationStart", [pageId, options]);
+        if (fn) fn();
+        return bridge.call("page.captureNavigationFinish", [pageId]);
+      },
+      download(fn, options) {
+        bridge.call("page.captureDownloadStart", [pageId, options]);
+        if (fn) fn();
+        const raw = bridge.call("page.captureDownloadFinish", [pageId]);
+        return new DownloadData(raw);
+      },
+      dialog(fn, options) {
+        bridge.call("page.captureDialogStart", [pageId, options]);
+        if (fn) fn();
+        return bridge.call("page.captureDialogFinish", [pageId]);
+      },
+      event(name, fn, options) {
+        bridge.call("page.captureEventStart", [pageId, name, options]);
+        if (fn) fn();
+        return bridge.call("page.captureEventFinish", [pageId]);
+      }
+    };
+  }
+  wait(ms) {
+    this._bridge.call("page.wait", [this._pageId, ms]);
+  }
+  // --- Screenshots & PDF ---
+  screenshot(options) {
+    const result = this._bridge.call("page.screenshot", [this._pageId, options]);
+    return Buffer.from(result.data, "base64");
+  }
+  pdf() {
+    const result = this._bridge.call("page.pdf", [this._pageId]);
+    return Buffer.from(result.data, "base64");
+  }
+  // --- Evaluation ---
+  evaluate(expression) {
+    const result = this._bridge.call("page.eval", [this._pageId, expression]);
+    return result.value;
+  }
+  addScript(source) {
+    this._bridge.call("page.addScript", [this._pageId, source]);
+  }
+  addStyle(source) {
+    this._bridge.call("page.addStyle", [this._pageId, source]);
+  }
+  expose(name, fn) {
+    this._bridge.call("page.expose", [this._pageId, name, fn]);
+  }
+  // --- Lifecycle ---
+  bringToFront() {
+    this._bridge.call("page.bringToFront", [this._pageId]);
+  }
+  close() {
+    this._bridge.call("page.close", [this._pageId]);
+  }
+  scroll(direction, amount, selector) {
+    this._bridge.call("page.scroll", [this._pageId, direction, amount, selector]);
+  }
+  // --- Emulation ---
+  setViewport(size) {
+    this._bridge.call("page.setViewport", [this._pageId, size]);
+  }
+  viewport() {
+    return this._bridge.call("page.viewport", [this._pageId]);
+  }
+  emulateMedia(opts) {
+    this._bridge.call("page.emulateMedia", [this._pageId, opts]);
+  }
+  setContent(html) {
+    this._bridge.call("page.setContent", [this._pageId, html]);
+  }
+  setGeolocation(coords) {
+    this._bridge.call("page.setGeolocation", [this._pageId, coords]);
+  }
+  setWindow(options) {
+    this._bridge.call("page.setWindow", [this._pageId, options]);
+  }
+  window() {
+    return this._bridge.call("page.window", [this._pageId]);
+  }
+  // --- Frames ---
+  frames() {
+    const result = this._bridge.call("page.frames", [this._pageId]);
+    return result.frameIds.map((id) => new _PageSync(this._bridge, id));
+  }
+  frame(nameOrUrl) {
+    const result = this._bridge.call("page.frame", [this._pageId, nameOrUrl]);
+    if (result.frameId === null) return null;
+    return new _PageSync(this._bridge, result.frameId);
+  }
+  mainFrame() {
+    return this;
+  }
+  // --- Accessibility ---
+  a11yTree(options) {
+    const result = this._bridge.call("page.a11yTree", [this._pageId, options]);
+    return result.tree;
+  }
+  // --- Network ---
+  route(pattern, action) {
+    if (typeof action === "function") {
+      const handlerId = `route_${this._pageId}_${this._nextHandlerId++}`;
+      this._bridge.registerHandler(handlerId, (data) => {
+        const route = new RouteSync(data);
+        action(route);
+        return route._decision;
+      });
+      this._routeHandlerIds.set(pattern, handlerId);
+      this._bridge.call("page.routeWithCallback", [this._pageId, pattern, handlerId]);
+    } else {
+      this._bridge.call("page.route", [this._pageId, pattern, action]);
+    }
+  }
+  unroute(pattern) {
+    const handlerId = this._routeHandlerIds.get(pattern);
+    if (handlerId) {
+      this._bridge.unregisterHandler(handlerId);
+      this._routeHandlerIds.delete(pattern);
+    }
+    this._bridge.call("page.unroute", [this._pageId, pattern]);
+  }
+  setHeaders(headers) {
+    this._bridge.call("page.setHeaders", [this._pageId, headers]);
+  }
+  // --- Events ---
+  onDialog(action) {
+    if (typeof action === "function") {
+      const handlerId = `dialog_${this._pageId}_${this._nextHandlerId++}`;
+      this._bridge.registerHandler(handlerId, (data) => {
+        const dialog = new DialogSync(data);
+        action(dialog);
+        return dialog._decision;
+      });
+      if (this._dialogHandlerId) {
+        this._bridge.unregisterHandler(this._dialogHandlerId);
+      }
+      this._dialogHandlerId = handlerId;
+      this._bridge.call("page.onDialogWithCallback", [this._pageId, handlerId]);
+    } else {
+      this._bridge.call("page.onDialog", [this._pageId, action]);
+    }
+  }
+  onConsole(mode) {
+    this._bridge.call("page.onConsole", [this._pageId, mode]);
+  }
+  consoleMessages() {
+    const result = this._bridge.call("page.consoleMessages", [this._pageId]);
+    return result.messages;
+  }
+  onError(mode) {
+    this._bridge.call("page.onError", [this._pageId, mode]);
+  }
+  errors() {
+    const result = this._bridge.call("page.errors", [this._pageId]);
+    return result.errors;
+  }
+  onRequest(fn) {
+    const handlerId = `request_${this._pageId}_${this._nextHandlerId++}`;
+    this._bridge.registerHandler(handlerId, (data) => {
+      fn(data);
+      return null;
+    });
+    if (this._requestHandlerId) {
+      this._bridge.unregisterHandler(this._requestHandlerId);
+    }
+    this._requestHandlerId = handlerId;
+    this._bridge.call("page.onRequestWithCallback", [this._pageId, handlerId]);
+  }
+  onResponse(fn) {
+    const handlerId = `response_${this._pageId}_${this._nextHandlerId++}`;
+    this._bridge.registerHandler(handlerId, (data) => {
+      fn(data);
+      return null;
+    });
+    if (this._responseHandlerId) {
+      this._bridge.unregisterHandler(this._responseHandlerId);
+    }
+    this._responseHandlerId = handlerId;
+    this._bridge.call("page.onResponseWithCallback", [this._pageId, handlerId]);
+  }
+  onDownload(fn) {
+    const handlerId = `download_${this._pageId}_${this._nextHandlerId++}`;
+    this._bridge.registerHandler(handlerId, (data) => {
+      fn(new DownloadData(data));
+      return null;
+    });
+    if (this._downloadHandlerId) {
+      this._bridge.unregisterHandler(this._downloadHandlerId);
+    }
+    this._downloadHandlerId = handlerId;
+    this._bridge.call("page.onDownloadWithCallback", [this._pageId, handlerId]);
+  }
+  onWebSocket(fn) {
+    const handlerId = `ws_${this._pageId}_${this._nextHandlerId++}`;
+    this._bridge.registerHandler(handlerId, (data) => {
+      if (data.type === "created") {
+        const ws = new WebSocketInfoSync(data.url);
+        this._wsInstances.set(data.wsId, ws);
+        fn(ws);
+      } else if (data.type === "message") {
+        const ws = this._wsInstances.get(data.wsId);
+        if (ws) ws._emitMessage(data.data, data.direction);
+      } else if (data.type === "close") {
+        const ws = this._wsInstances.get(data.wsId);
+        if (ws) {
+          ws._emitClose(data.code, data.reason);
+          this._wsInstances.delete(data.wsId);
+        }
+      }
+      return null;
+    });
+    if (this._wsHandlerId) {
+      this._bridge.unregisterHandler(this._wsHandlerId);
+    }
+    this._wsHandlerId = handlerId;
+    this._bridge.call("page.onWebSocketWithCallback", [this._pageId, handlerId]);
+  }
+  removeAllListeners(event) {
+    if (!event || event === "dialog") {
+      if (this._dialogHandlerId) {
+        this._bridge.unregisterHandler(this._dialogHandlerId);
+        this._dialogHandlerId = null;
+      }
+    }
+    if (!event || event === "request") {
+      if (this._requestHandlerId) {
+        this._bridge.unregisterHandler(this._requestHandlerId);
+        this._requestHandlerId = null;
+      }
+      for (const [, handlerId] of this._routeHandlerIds) {
+        this._bridge.unregisterHandler(handlerId);
+      }
+      this._routeHandlerIds.clear();
+    }
+    if (!event || event === "response") {
+      if (this._responseHandlerId) {
+        this._bridge.unregisterHandler(this._responseHandlerId);
+        this._responseHandlerId = null;
+      }
+    }
+    if (!event || event === "download") {
+      if (this._downloadHandlerId) {
+        this._bridge.unregisterHandler(this._downloadHandlerId);
+        this._downloadHandlerId = null;
+      }
+    }
+    if (!event || event === "websocket") {
+      if (this._wsHandlerId) {
+        this._bridge.unregisterHandler(this._wsHandlerId);
+        this._wsHandlerId = null;
+      }
+      this._wsInstances.clear();
+    }
+    this._bridge.call("page.removeAllListeners", [this._pageId, event]);
+  }
+};
+
+// src/sync/browser.ts
+var customInspect3 = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var BrowserSync = class {
+  constructor(bridge) {
+    this._nextHandlerId = 0;
+    this._bridge = bridge;
+  }
+  [customInspect3]() {
+    return "Browser { connected: true }";
+  }
+  page() {
+    const result = this._bridge.call("browser.page");
+    return new PageSync(this._bridge, result.pageId);
+  }
+  newPage() {
+    const result = this._bridge.call("browser.newPage");
+    return new PageSync(this._bridge, result.pageId);
+  }
+  pages() {
+    const result = this._bridge.call("browser.pages");
+    return result.pageIds.map((id) => new PageSync(this._bridge, id));
+  }
+  newContext() {
+    const result = this._bridge.call("browser.newContext");
+    return new BrowserContextSync(this._bridge, result.contextId);
+  }
+  waitForPage(options) {
+    const result = this._bridge.call("browser.waitForPage", [options]);
+    return new PageSync(this._bridge, result.pageId);
+  }
+  waitForPopup(options) {
+    const result = this._bridge.call("browser.waitForPopup", [options]);
+    return new PageSync(this._bridge, result.pageId);
+  }
+  onPage(callback) {
+    if (this._pageHandlerId) {
+      this._bridge.unregisterHandler(this._pageHandlerId);
+    }
+    const handlerId = `page_${this._nextHandlerId++}`;
+    this._bridge.registerHandler(handlerId, (data) => {
+      callback(new PageSync(this._bridge, data.pageId));
+    });
+    this._pageHandlerId = handlerId;
+    this._bridge.call("browser.onPage", [handlerId]);
+  }
+  onPopup(callback) {
+    if (this._popupHandlerId) {
+      this._bridge.unregisterHandler(this._popupHandlerId);
+    }
+    const handlerId = `popup_${this._nextHandlerId++}`;
+    this._bridge.registerHandler(handlerId, (data) => {
+      callback(new PageSync(this._bridge, data.pageId));
+    });
+    this._popupHandlerId = handlerId;
+    this._bridge.call("browser.onPopup", [handlerId]);
+  }
+  removeAllListeners(event) {
+    if (!event || event === "page") {
+      if (this._pageHandlerId) {
+        this._bridge.unregisterHandler(this._pageHandlerId);
+        this._pageHandlerId = void 0;
+      }
+    }
+    if (!event || event === "popup") {
+      if (this._popupHandlerId) {
+        this._bridge.unregisterHandler(this._popupHandlerId);
+        this._popupHandlerId = void 0;
+      }
+    }
+    this._bridge.call("browser.removeAllListeners", [event]);
+  }
+  stop() {
+    this._bridge.tryQuit();
+  }
+};
+var browser = {
+  start(urlOrOptions, options = {}) {
+    let url;
+    if (typeof urlOrOptions === "object") {
+      options = urlOrOptions;
+      url = void 0;
+    } else {
+      url = urlOrOptions;
+    }
+    const bridge = SyncBridge.create();
+    try {
+      bridge.call("browser.start", [url, options]);
+    } catch (e) {
+      bridge.terminate();
+      throw e;
+    }
+    return new BrowserSync(bridge);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserContextSync,
+  BrowserSync,
+  ClockSync,
+  DialogSync,
+  DownloadData,
+  ElementSync,
+  KeyboardSync,
+  MouseSync,
+  PageSync,
+  RecordingSync,
+  RouteSync,
+  TouchSync,
+  WebSocketInfoSync,
+  browser
+});