@workglow/browser-control 0.2.30 → 0.2.32

package/dist/task.js

@@ -1,11 +1,3 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
 // src/task/BrowserSessionRegistry.ts
 import { uuid4 } from "@workglow/util";
 var sessions = new Map;
@@ -41,9 +33,6 @@ var BrowserSessionRegistry = {
     sessions.clear();
   }
 };
-// src/task/BunWebViewBackend.ts
-import { sleep } from "@workglow/util";
-
 // src/task/CDPBrowserBackend.ts
 var IGNORED_ROLES = new Set(["none", "generic", "ignored", "InlineTextBox"]);
 function parseCDPAXTree(nodes, refCounter, refMap) {
@@ -556,236 +545,6 @@ class CDPBrowserBackend {
     });
   }
 }
-
-// src/task/BunWebViewBackend.ts
-class BunWebViewBackend extends CDPBrowserBackend {
-  defaultChromePath;
-  _wv = null;
-  _connected = false;
-  _dialogHandler = null;
-  backendName = "BunWebViewBackend";
-  constructor(defaultChromePath) {
-    super();
-    this.defaultChromePath = defaultChromePath;
-  }
-  async cdp(method, params = {}) {
-    return this.wv.cdp(method, params);
-  }
-  async evaluateInPage(script) {
-    return this.wv.evaluate(script);
-  }
-  async connect(options = {}) {
-    const BunWebView = globalThis.Bun?.WebView;
-    if (!BunWebView) {
-      throw new Error("BunWebViewBackend: Bun.WebView is not available — " + "this backend requires Bun with WebView support");
-    }
-    const { headless = true, chromePath = this.defaultChromePath } = options;
-    const webViewOptions = {
-      headless,
-      url: "about:blank",
-      backend: chromePath ? { type: "chrome", path: chromePath } : { type: "chrome" }
-    };
-    this._wv = new BunWebView(webViewOptions);
-    await new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error("BunWebViewBackend: initial navigation timed out"));
-      }, 30000);
-      this._wv.onNavigated = () => {
-        clearTimeout(timeout);
-        this._wv.onNavigated = null;
-        this._wv.onNavigationFailed = null;
-        resolve();
-      };
-      this._wv.onNavigationFailed = (error) => {
-        clearTimeout(timeout);
-        this._wv.onNavigated = null;
-        this._wv.onNavigationFailed = null;
-        reject(new Error(`BunWebViewBackend: initial navigation failed — ${error}`));
-      };
-    });
-    await this.cdp("Accessibility.enable");
-    this._connected = true;
-  }
-  async disconnect() {
-    this._connected = false;
-    try {
-      if (this._wv) {
-        this._wv.close();
-      }
-    } finally {
-      this._wv = null;
-      this._refMap.clear();
-      this._refCounter.count = 0;
-    }
-  }
-  isConnected() {
-    return this._connected && this._wv !== null;
-  }
-  get wv() {
-    if (!this._wv || !this._connected) {
-      throw new Error("BunWebViewBackend: not connected — call connect() first");
-    }
-    return this._wv;
-  }
-  async navigate(url, options = {}) {
-    const timeout = options.timeout ?? 30000;
-    await new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        reject(new Error("BunWebViewBackend: navigate timed out"));
-      }, timeout);
-      this.wv.onNavigated = () => {
-        clearTimeout(timer);
-        this.wv.onNavigated = null;
-        resolve();
-      };
-      this.wv.onNavigationFailed = (error) => {
-        clearTimeout(timer);
-        this.wv.onNavigationFailed = null;
-        this.wv.onNavigated = null;
-        reject(new Error(`BunWebViewBackend: navigation failed — ${error}`));
-      };
-      this.wv.navigate(url);
-    });
-  }
-  async goBack(_options = {}) {
-    this.wv.back();
-    await this.waitForNavigation();
-  }
-  async goForward(_options = {}) {
-    this.wv.forward();
-    await this.waitForNavigation();
-  }
-  async reload(_options = {}) {
-    this.wv.reload();
-    await this.waitForNavigation();
-  }
-  async currentUrl() {
-    return this.wv.url;
-  }
-  async title() {
-    return this.wv.title;
-  }
-  async content() {
-    return this.wv.evaluate("document.documentElement.outerHTML");
-  }
-  async evaluate(expression) {
-    return this.wv.evaluate(expression);
-  }
-  async screenshot(options = {}) {
-    const { format = "png", quality } = options;
-    return this.wv.screenshot({
-      encoding: "buffer",
-      format,
-      ...quality !== undefined && { quality }
-    });
-  }
-  async pressKey(key, _options = {}) {
-    await this.wv.press(key);
-  }
-  async type(text, _options = {}) {
-    await this.wv.type(text);
-  }
-  async download(_trigger, _options = {}) {
-    throw new Error("BunWebViewBackend: download is not supported");
-  }
-  onDialog(handler) {
-    this._dialogHandler = handler;
-    this.cdp("Page.enable").then(() => {
-      this.wv.addEventListener("Page.javascriptDialogOpening", async (params) => {
-        const info = {
-          type: params.type,
-          message: params.message,
-          defaultValue: params.defaultPrompt || undefined
-        };
-        if (this._dialogHandler) {
-          const action = await this._dialogHandler(info);
-          const accept = action.accept;
-          const promptText = accept && "promptText" in action ? action.promptText : undefined;
-          await this.cdp("Page.handleJavaScriptDialog", {
-            accept,
-            ...promptText !== undefined && { promptText }
-          });
-        } else {
-          await this.cdp("Page.handleJavaScriptDialog", { accept: false });
-        }
-      });
-    }).catch(() => {});
-  }
-  async tabs() {
-    const url = this.wv.url;
-    const title = this.wv.title;
-    return [{ tabId: "0", url, title }];
-  }
-  async switchTab(_tabId) {}
-  async newTab(url) {
-    if (url) {
-      await this.navigate(url);
-    }
-    return {
-      tabId: "0",
-      url: this.wv.url,
-      title: this.wv.title
-    };
-  }
-  async closeTab(_tabId) {
-    await this.disconnect();
-  }
-  async waitForNavigation(options = {}) {
-    const timeout = options.timeout ?? 30000;
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.wv.onNavigated = null;
-        this.wv.onNavigationFailed = null;
-        reject(new Error("BunWebViewBackend: waitForNavigation timed out"));
-      }, timeout);
-      this.wv.onNavigated = () => {
-        clearTimeout(timer);
-        this.wv.onNavigated = null;
-        this.wv.onNavigationFailed = null;
-        resolve();
-      };
-      this.wv.onNavigationFailed = (error) => {
-        clearTimeout(timer);
-        this.wv.onNavigated = null;
-        this.wv.onNavigationFailed = null;
-        reject(new Error(`BunWebViewBackend: navigation failed — ${error}`));
-      };
-    });
-  }
-  async waitForSelector(selector, options = {}) {
-    const timeout = options.timeout ?? 30000;
-    const interval = 100;
-    const deadline = Date.now() + timeout;
-    while (Date.now() < deadline) {
-      const found = await this.wv.evaluate(`!!document.querySelector(${JSON.stringify(selector)})`);
-      if (found) {
-        const ref = await this.querySelector(selector);
-        if (ref)
-          return ref;
-      }
-      await sleep(interval);
-    }
-    throw new Error(`BunWebViewBackend: waitForSelector timed out for "${selector}"`);
-  }
-  async waitForIdle(options = {}) {
-    const timeout = options.timeout ?? 30000;
-    const interval = 100;
-    const deadline = Date.now() + timeout;
-    while (Date.now() < deadline) {
-      const ready = await this.wv.evaluate(`document.readyState === "complete"`);
-      if (ready)
-        return;
-      await sleep(interval);
-    }
-    throw new Error("BunWebViewBackend: waitForIdle timed out");
-  }
-  networkRequests = (_filter) => {
-    return Promise.resolve([]);
-  };
-  consoleMessages = () => {
-    return Promise.resolve([]);
-  };
-}
 // src/task/tasks/BrowserSessionTask.ts
 import {
   Entitlements,
@@ -2683,725 +2442,10 @@ class BrowserLoginTask extends Task26 {
     return { sessionId: input.sessionId };
   }
 }
-// src/task/ElectronBackend.ts
-import { sleep as sleep2 } from "@workglow/util";
-var electronModule = null;
-async function getElectron() {
-  if (!electronModule) {
-    electronModule = await new Function("m", "return import(m)")("electron");
-  }
-  return electronModule;
-}
-
-class ElectronBackend extends CDPBrowserBackend {
-  _window = null;
-  _webContents = null;
-  _connected = false;
-  _dialogHandler = null;
-  backendName = "ElectronBackend";
-  async cdp(method, params = {}) {
-    if (!this._webContents) {
-      throw new Error("ElectronBackend: not connected — call connect() first");
-    }
-    return this._webContents.debugger.sendCommand(method, params);
-  }
-  async evaluateInPage(script) {
-    return this.wc.executeJavaScript(script);
-  }
-  async connect(options = {}) {
-    const electron = await getElectron();
-    const { BrowserWindow, session: electronSession } = electron;
-    const { projectId = "default", profileName = "default", headless = false } = options;
-    const partitionString = `persist:${projectId}:${profileName}`;
-    const sess = electronSession.fromPartition(partitionString);
-    this._window = new BrowserWindow({
-      width: 1280,
-      height: 800,
-      show: !headless,
-      webPreferences: {
-        session: sess,
-        nodeIntegration: false,
-        contextIsolation: true
-      }
-    });
-    this._webContents = this._window.webContents;
-    try {
-      this._webContents.debugger.attach("1.3");
-    } catch {}
-    await this.cdp("Accessibility.enable");
-    this._webContents.on("select-client-certificate", (_event, _url, _list, callback) => {
-      callback(undefined);
-    });
-    this._webContents.on("will-prevent-unload", (event) => {
-      event.preventDefault();
-    });
-    this._connected = true;
-  }
-  async disconnect() {
-    this._connected = false;
-    try {
-      if (this._webContents) {
-        try {
-          this._webContents.debugger.detach();
-        } catch {}
-      }
-      if (this._window && !this._window.isDestroyed()) {
-        this._window.close();
-      }
-    } finally {
-      this._window = null;
-      this._webContents = null;
-      this._refMap.clear();
-      this._refCounter.count = 0;
-    }
-  }
-  isConnected() {
-    return this._connected && this._window !== null && !this._window.isDestroyed();
-  }
-  get wc() {
-    if (!this._webContents || !this._connected) {
-      throw new Error("ElectronBackend: not connected — call connect() first");
-    }
-    return this._webContents;
-  }
-  async navigate(url, _options = {}) {
-    await this.wc.loadURL(url);
-  }
-  async goBack(_options = {}) {
-    this.wc.navigationHistory.goBack();
-    await this.waitForNavigation();
-  }
-  async goForward(_options = {}) {
-    this.wc.navigationHistory.goForward();
-    await this.waitForNavigation();
-  }
-  async reload(_options = {}) {
-    this.wc.reload();
-    await this.waitForNavigation();
-  }
-  async currentUrl() {
-    return this.wc.getURL();
-  }
-  async title() {
-    return this.wc.getTitle();
-  }
-  async content() {
-    return this.wc.executeJavaScript("document.documentElement.outerHTML");
-  }
-  async evaluate(expression) {
-    return this.wc.executeJavaScript(expression);
-  }
-  async screenshot(options = {}) {
-    const { format = "png", quality } = options;
-    const image = await this.wc.capturePage();
-    if (format === "jpeg") {
-      return image.toJPEG(quality ?? 90);
-    }
-    return image.toPNG();
-  }
-  async download(trigger, options = {}) {
-    const os = await import("node:os");
-    const downloadDir = os.tmpdir();
-    const timeout = options.timeout ?? 30000;
-    await this.cdp("Browser.setDownloadBehavior", {
-      behavior: "allow",
-      downloadPath: downloadDir
-    });
-    let downloadPath = "";
-    let suggestedFilename = "";
-    const downloadPromise = new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        reject(new Error("ElectronBackend: download timed out"));
-      }, timeout);
-      const handler = (_event, item, _webContents) => {
-        suggestedFilename = item.getFilename ? item.getFilename() : "download";
-        item.once?.("done", (_e, state) => {
-          clearTimeout(timer);
-          if (state === "completed") {
-            downloadPath = item.getSavePath ? item.getSavePath() : downloadDir + "/" + suggestedFilename;
-          }
-          resolve();
-        });
-      };
-      this.wc.session.once("will-download", handler);
-    });
-    await trigger();
-    await downloadPromise;
-    if (!downloadPath) {
-      throw new Error("ElectronBackend: download failed — no path received");
-    }
-    return { path: downloadPath, suggestedFilename };
-  }
-  onDialog(handler) {
-    this._dialogHandler = handler;
-    this.cdp("Page.enable").then(() => {
-      this.wc.debugger.on("message", async (_event, method, params) => {
-        if (method !== "Page.javascriptDialogOpening")
-          return;
-        const info = {
-          type: params.type,
-          message: params.message,
-          defaultValue: params.defaultPrompt || undefined
-        };
-        if (this._dialogHandler) {
-          const action = await this._dialogHandler(info);
-          const accept = action.accept;
-          const promptText = accept && "promptText" in action ? action.promptText : undefined;
-          await this.cdp("Page.handleJavaScriptDialog", {
-            accept,
-            ...promptText !== undefined && { promptText }
-          });
-        } else {
-          await this.cdp("Page.handleJavaScriptDialog", { accept: false });
-        }
-      });
-    });
-  }
-  async tabs() {
-    const url = this.wc.getURL();
-    const title = this.wc.getTitle();
-    return [{ tabId: "0", url, title }];
-  }
-  async switchTab(_tabId) {}
-  async newTab(url) {
-    if (url) {
-      await this.navigate(url);
-    }
-    return {
-      tabId: "0",
-      url: this.wc.getURL(),
-      title: this.wc.getTitle()
-    };
-  }
-  async closeTab(_tabId) {
-    await this.disconnect();
-  }
-  async waitForNavigation(options = {}) {
-    const timeout = options.timeout ?? 30000;
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        reject(new Error("ElectronBackend: waitForNavigation timed out"));
-      }, timeout);
-      this.wc.once("did-finish-load", () => {
-        clearTimeout(timer);
-        resolve();
-      });
-    });
-  }
-  async waitForSelector(selector, options = {}) {
-    const timeout = options.timeout ?? 30000;
-    const interval = 100;
-    const deadline = Date.now() + timeout;
-    while (Date.now() < deadline) {
-      const found = await this.wc.executeJavaScript(`!!document.querySelector(${JSON.stringify(selector)})`);
-      if (found) {
-        const ref = await this.querySelector(selector);
-        if (ref)
-          return ref;
-      }
-      await sleep2(interval);
-    }
-    throw new Error(`ElectronBackend: waitForSelector timed out for "${selector}"`);
-  }
-  async waitForIdle(options = {}) {
-    const timeout = options.timeout ?? 30000;
-    const interval = 100;
-    const deadline = Date.now() + timeout;
-    while (Date.now() < deadline) {
-      const ready = await this.wc.executeJavaScript(`document.readyState === "complete"`);
-      if (ready)
-        return;
-      await sleep2(interval);
-    }
-    throw new Error("ElectronBackend: waitForIdle timed out");
-  }
-  networkRequests = (_filter) => {
-    return Promise.resolve([]);
-  };
-  consoleMessages = () => {
-    return Promise.resolve([]);
-  };
-}
-// src/task/PlaywrightBackend.ts
-var playwrightModule;
-async function getPlaywright() {
-  if (!playwrightModule) {
-    playwrightModule = await import("playwright");
-  }
-  return playwrightModule;
-}
-function parseAriaLine(line) {
-  const match = line.match(/^(\s*)-\s+(.*)$/);
-  if (!match)
-    return null;
-  const indent = match[1].length;
-  let rest = match[2].trim();
-  const hasChildren = rest.endsWith(":");
-  if (hasChildren)
-    rest = rest.slice(0, -1).trim();
-  const attrs = {};
-  rest = rest.replace(/\[([^\]]+)\]/g, (_m, attr) => {
-    const eqIdx = attr.indexOf("=");
-    if (eqIdx !== -1) {
-      attrs[attr.slice(0, eqIdx).trim()] = attr.slice(eqIdx + 1).trim();
-    } else {
-      attrs[attr.trim()] = "true";
-    }
-    return "";
-  }).trim();
-  const roleNameMatch = rest.match(/^(\S+)(?:\s+"((?:[^"\\]|\\.)*)")?/);
-  if (!roleNameMatch)
-    return null;
-  const role = roleNameMatch[1];
-  const name = roleNameMatch[2] !== undefined ? roleNameMatch[2].replace(/\\"/g, '"') : "";
-  return { indent, role, name, attrs, hasChildren };
-}
-function parseAriaYaml(yaml, refCounter, refMap) {
-  const lines = yaml.split(`
-`);
-  const stack = [];
-  let root = null;
-  for (const line of lines) {
-    if (!line.trim())
-      continue;
-    const parsed = parseAriaLine(line);
-    if (!parsed)
-      continue;
-    const ref = `e${++refCounter.count}`;
-    const locatorStr = buildLocatorString(parsed.role, parsed.name);
-    refMap.set(ref, locatorStr);
-    const node = {
-      ref,
-      role: parsed.role,
-      name: parsed.name
-    };
-    if (parsed.attrs.level !== undefined) {
-      node.level = parseInt(parsed.attrs.level, 10);
-    }
-    if (parsed.attrs.checked !== undefined) {
-      node.checked = parsed.attrs.checked === "mixed" ? "mixed" : parsed.attrs.checked === "true";
-    }
-    if (parsed.attrs.disabled !== undefined) {
-      node.disabled = parsed.attrs.disabled === "true";
-    }
-    if (parsed.attrs.expanded !== undefined) {
-      node.expanded = parsed.attrs.expanded === "true";
-    }
-    if (parsed.attrs.pressed !== undefined) {
-      node.pressed = parsed.attrs.pressed === "mixed" ? "mixed" : parsed.attrs.pressed === "true";
-    }
-    if (parsed.attrs.selected !== undefined) {
-      node.selected = parsed.attrs.selected === "true";
-    }
-    if (parsed.attrs.value !== undefined) {
-      const numVal = Number(parsed.attrs.value);
-      node.value = isNaN(numVal) ? parsed.attrs.value : numVal;
-    }
-    if (parsed.hasChildren) {
-      node.children = [];
-    }
-    while (stack.length > 0 && stack[stack.length - 1].indent >= parsed.indent) {
-      stack.pop();
-    }
-    if (stack.length === 0) {
-      root = node;
-    } else {
-      const parent = stack[stack.length - 1].node;
-      if (!parent.children)
-        parent.children = [];
-      parent.children.push(node);
-    }
-    stack.push({ node, indent: parsed.indent });
-  }
-  if (!root) {
-    const ref = `e${++refCounter.count}`;
-    refMap.set(ref, 'locator("body")');
-    return { ref, role: "document", name: "" };
-  }
-  return root;
-}
-function buildLocatorString(role, name) {
-  if (role === "text" || role === "StaticText") {
-    return `getByText:${name}`;
-  }
-  if (name) {
-    return `getByRole:${role}:${name}`;
-  }
-  return `getByRole:${role}:`;
-}
-
-class PlaywrightBackend {
-  sharedLocalBrowser;
-  constructor(sharedLocalBrowser) {
-    this.sharedLocalBrowser = sharedLocalBrowser;
-  }
-  _browser = null;
-  _context = null;
-  _page = null;
-  _connected = false;
-  _launchedLocalChromium = false;
-  _refMap = new Map;
-  _refCounter = { count: 0 };
-  _dialogHandler = null;
-  async connect(options = {}) {
-    const pw = await getPlaywright();
-    const { headless = true, cdpUrl, backend = "local" } = options;
-    if (backend === "cloud" || cdpUrl) {
-      if (this.sharedLocalBrowser) {
-        throw new Error("PlaywrightBackend: sharedLocalBrowser is only supported for local backend");
-      }
-      this._launchedLocalChromium = false;
-      if (!cdpUrl) {
-        throw new Error("PlaywrightBackend: cdpUrl is required for cloud backend");
-      }
-      this._browser = await pw.chromium.connectOverCDP(cdpUrl);
-      const contexts = this._browser.contexts();
-      this._context = contexts.length > 0 ? contexts[0] : await this._browser.newContext();
-      const pages = this._context.pages();
-      this._page = pages.length > 0 ? pages[0] : await this._context.newPage();
-    } else {
-      if (this.sharedLocalBrowser) {
-        this._browser = this.sharedLocalBrowser;
-        this._launchedLocalChromium = false;
-      } else {
-        this._launchedLocalChromium = true;
-        this._browser = await pw.chromium.launch({
-          headless,
-          args: ["--disable-dev-shm-usage"]
-        });
-      }
-      this._context = await this._browser.newContext();
-      this._page = await this._context.newPage();
-    }
-    this._page.on("dialog", async (dialog) => {
-      const info = {
-        type: dialog.type(),
-        message: dialog.message(),
-        defaultValue: dialog.defaultValue() ?? undefined
-      };
-      if (this._dialogHandler) {
-        const action = await this._dialogHandler(info);
-        if (action.accept) {
-          await dialog.accept("promptText" in action ? action.promptText : undefined);
-        } else {
-          await dialog.dismiss();
-        }
-      } else {
-        await dialog.dismiss();
-      }
-    });
-    this._connected = true;
-  }
-  async disconnect() {
-    this._connected = false;
-    const page = this._page;
-    const context = this._context;
-    const browser = this._browser;
-    const launchedLocal = this._launchedLocalChromium;
-    const sharedLocal = this.sharedLocalBrowser !== undefined;
-    this._page = null;
-    this._context = null;
-    this._browser = null;
-    this._launchedLocalChromium = false;
-    try {
-      if (launchedLocal || sharedLocal) {
-        if (page) {
-          try {
-            await page.close({ runBeforeUnload: false });
-          } catch {}
-        }
-        if (context) {
-          try {
-            await context.close();
-          } catch {}
-        }
-      }
-      if (browser && !sharedLocal) {
-        await browser.close();
-      }
-    } finally {
-      this._refMap.clear();
-      this._refCounter.count = 0;
-    }
-  }
-  isConnected() {
-    return this._connected;
-  }
-  get page() {
-    if (!this._page)
-      throw new Error("PlaywrightBackend: not connected — call connect() first");
-    return this._page;
-  }
-  get context() {
-    if (!this._context)
-      throw new Error("PlaywrightBackend: not connected — call connect() first");
-    return this._context;
-  }
-  resolveRef(ref) {
-    const descriptor = this._refMap.get(ref);
-    if (!descriptor) {
-      throw new Error(`PlaywrightBackend: unknown ref "${ref}"`);
-    }
-    return this.descriptorToLocator(descriptor);
-  }
-  descriptorToLocator(descriptor) {
-    const page = this.page;
-    if (descriptor.startsWith("getByRole:")) {
-      const rest = descriptor.slice("getByRole:".length);
-      const colonIdx = rest.indexOf(":");
-      const role = rest.slice(0, colonIdx);
-      const name = rest.slice(colonIdx + 1);
-      if (name) {
-        return page.getByRole(role, { name });
-      }
-      return page.getByRole(role);
-    }
-    if (descriptor.startsWith("getByText:")) {
-      const text = descriptor.slice("getByText:".length);
-      return page.getByText(text);
-    }
-    if (descriptor.startsWith("css:")) {
-      const selector = descriptor.slice("css:".length);
-      return page.locator(selector);
-    }
-    if (descriptor.startsWith("nth:")) {
-      const withoutPrefix = descriptor.slice("nth:".length);
-      const lastColon = withoutPrefix.lastIndexOf(":");
-      const inner = withoutPrefix.slice(0, lastColon);
-      const idx = parseInt(withoutPrefix.slice(lastColon + 1), 10);
-      return this.descriptorToLocator(inner).nth(idx);
-    }
-    return page.locator(descriptor);
-  }
-  async navigate(url, options = {}) {
-    const { waitUntil = "load", timeout = 30000 } = options;
-    await this.page.goto(url, { waitUntil, timeout });
-  }
-  async goBack(options = {}) {
-    const { waitUntil = "load", timeout = 30000 } = options;
-    await this.page.goBack({ waitUntil, timeout });
-  }
-  async goForward(options = {}) {
-    const { waitUntil = "load", timeout = 30000 } = options;
-    await this.page.goForward({ waitUntil, timeout });
-  }
-  async reload(options = {}) {
-    const { waitUntil = "load", timeout = 30000 } = options;
-    await this.page.reload({ waitUntil, timeout });
-  }
-  async currentUrl() {
-    return this.page.url();
-  }
-  async title() {
-    return this.page.title();
-  }
-  async snapshot(options = {}) {
-    let locator;
-    if (options.ref) {
-      locator = this.resolveRef(options.ref);
-    } else {
-      locator = this.page.locator("body");
-    }
-    const yaml = await locator.ariaSnapshot();
-    const root = parseAriaYaml(yaml, this._refCounter, this._refMap);
-    return { root, yaml };
-  }
-  async click(ref, options = {}) {
-    const locator = this.resolveRef(ref);
-    const { modifiers, button, clickCount, timeout } = options;
-    await locator.click({
-      ...modifiers !== undefined ? { modifiers } : {},
-      ...button !== undefined ? { button } : {},
-      ...clickCount !== undefined ? { clickCount } : {},
-      ...timeout !== undefined ? { timeout } : {}
-    });
-  }
-  async fill(ref, value, options = {}) {
-    const locator = this.resolveRef(ref);
-    const { timeout } = options;
-    await locator.fill(value, ...timeout !== undefined ? [{ timeout }] : []);
-  }
-  async selectOption(ref, values, options = {}) {
-    const locator = this.resolveRef(ref);
-    const { timeout } = options;
-    await locator.selectOption(values, ...timeout !== undefined ? [{ timeout }] : []);
-  }
-  async hover(ref, options = {}) {
-    const locator = this.resolveRef(ref);
-    const { timeout } = options;
-    await locator.hover(...timeout !== undefined ? [{ timeout }] : []);
-  }
-  async clickByRole(role, name, options = {}) {
-    const { modifiers, button, clickCount, timeout } = options;
-    await this.page.getByRole(role, { name }).click({
-      ...modifiers !== undefined ? { modifiers } : {},
-      ...button !== undefined ? { button } : {},
-      ...clickCount !== undefined ? { clickCount } : {},
-      ...timeout !== undefined ? { timeout } : {}
-    });
-  }
-  async fillByLabel(label, value, options = {}) {
-    const { timeout } = options;
-    await this.page.getByLabel(label).fill(value, ...timeout !== undefined ? [{ timeout }] : []);
-  }
-  async content() {
-    return this.page.content();
-  }
-  async innerHTML(ref) {
-    const locator = this.resolveRef(ref);
-    return locator.innerHTML();
-  }
-  async textContent(ref) {
-    const locator = this.resolveRef(ref);
-    return locator.textContent();
-  }
-  async attribute(ref, name) {
-    const locator = this.resolveRef(ref);
-    return locator.getAttribute(name);
-  }
-  async querySelector(selector) {
-    const locator = this.page.locator(selector);
-    const count = await locator.count();
-    if (count === 0)
-      return null;
-    const ref = `e${++this._refCounter.count}`;
-    this._refMap.set(ref, `css:${selector}`);
-    return ref;
-  }
-  async querySelectorAll(selector) {
-    const locator = this.page.locator(selector);
-    const count = await locator.count();
-    const refs = [];
-    for (let i = 0;i < count; i++) {
-      const ref = `e${++this._refCounter.count}`;
-      this._refMap.set(ref, `nth:css:${selector}:${i}`);
-      refs.push(ref);
-    }
-    return refs;
-  }
-  async evaluate(expression) {
-    return this.page.evaluate(expression);
-  }
-  async screenshot(options = {}) {
-    const { format = "png", quality, fullPage = false } = options;
-    const screenshotOptions = {
-      type: format,
-      fullPage
-    };
-    if (format === "jpeg" && quality !== undefined) {
-      screenshotOptions.quality = quality;
-    }
-    return this.page.screenshot(screenshotOptions);
-  }
-  async pressKey(key, _options = {}) {
-    await this.page.keyboard.press(key);
-  }
-  async type(text, _options = {}) {
-    await this.page.keyboard.type(text);
-  }
-  async scroll(x, y, ref) {
-    if (ref) {
-      const locator = this.resolveRef(ref);
-      await locator.evaluate((el, args) => {
-        el.scrollBy(args.x, args.y);
-      }, { x, y });
-    } else {
-      await this.page.mouse.wheel(x, y);
-    }
-  }
-  async uploadFile(ref, paths) {
-    const locator = this.resolveRef(ref);
-    await locator.setInputFiles(paths);
-  }
-  async download(trigger, options = {}) {
-    const { timeout } = options;
-    const [download] = await Promise.all([
-      this.page.waitForEvent("download", ...timeout !== undefined ? [{ timeout }] : []),
-      trigger()
-    ]);
-    const path = await download.path();
-    const suggestedFilename = download.suggestedFilename();
-    if (!path) {
-      throw new Error("PlaywrightBackend: download failed — path is null");
-    }
-    return { path, suggestedFilename };
-  }
-  onDialog(handler) {
-    this._dialogHandler = handler;
-  }
-  async tabs() {
-    const pages = this.context.pages();
-    return Promise.all(pages.map(async (p, idx) => ({
-      tabId: String(idx),
-      url: p.url(),
-      title: await p.title()
-    })));
-  }
-  async switchTab(tabId) {
-    const pages = this.context.pages();
-    const idx = parseInt(tabId, 10);
-    if (isNaN(idx) || idx < 0 || idx >= pages.length) {
-      throw new Error(`PlaywrightBackend: no tab with id "${tabId}"`);
-    }
-    this._page = pages[idx];
-    await this._page.bringToFront();
-  }
-  async newTab(url) {
-    const newPage = await this.context.newPage();
-    if (url) {
-      await newPage.goto(url, { waitUntil: "load" });
-    }
-    const pages = this.context.pages();
-    const idx = pages.indexOf(newPage);
-    const tabId = String(idx >= 0 ? idx : pages.length - 1);
-    return {
-      tabId,
-      url: newPage.url(),
-      title: await newPage.title()
-    };
-  }
-  async closeTab(tabId) {
-    const pages = this.context.pages();
-    const idx = parseInt(tabId, 10);
-    if (isNaN(idx) || idx < 0 || idx >= pages.length) {
-      throw new Error(`PlaywrightBackend: no tab with id "${tabId}"`);
-    }
-    const target = pages[idx];
-    await target.close();
-    if (this._page === target) {
-      const remaining = this.context.pages();
-      this._page = remaining.length > 0 ? remaining[remaining.length - 1] : null;
-    }
-  }
-  async waitForNavigation(options = {}) {
-    const { timeout } = options;
-    await this.page.waitForLoadState("load", ...timeout !== undefined ? [{ timeout }] : []);
-  }
-  async waitForSelector(selector, options = {}) {
-    const { timeout } = options;
-    await this.page.waitForSelector(selector, ...timeout !== undefined ? [{ timeout }] : []);
-    const ref = `e${++this._refCounter.count}`;
-    this._refMap.set(ref, `css:${selector}`);
-    return ref;
-  }
-  async waitForIdle(options = {}) {
-    const { timeout } = options;
-    await this.page.waitForLoadState("networkidle", ...timeout !== undefined ? [{ timeout }] : []);
-  }
-  networkRequests = (_filter) => {
-    return Promise.resolve([]);
-  };
-  consoleMessages = () => {
-    return Promise.resolve([]);
-  };
-}
 export {
   registerBrowserDeps,
   getBrowserDeps,
-  PlaywrightBackend,
-  ElectronBackend,
   CDPBrowserBackend,
-  BunWebViewBackend,
   BrowserWaitTask,
   BrowserUploadTask,
   BrowserTypeTask,
@@ -3432,4 +2476,4 @@ export {
   BROWSER_CONTROL_TASK_DEPS
 };
 
-//# debugId=30B3D27A74834FEE64756E2164756E21
+//# debugId=BB75C3F860F618D964756E2164756E21