@workglow/browser-control 0.2.30 → 0.2.32

package/dist/task-server.js

@@ -1,3468 +0,0 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/task/register.server.ts
-import path from "node:path";
-
-// 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([]);
-  };
-}
-
-// src/task/BrowserTaskDeps.ts
-import { createServiceToken, globalServiceRegistry } from "@workglow/util";
-var BROWSER_CONTROL_TASK_DEPS = createServiceToken("@workglow/browser-control");
-function registerBrowserDeps(deps) {
-  globalServiceRegistry.registerInstance(BROWSER_CONTROL_TASK_DEPS, deps);
-}
-function getBrowserDeps() {
-  if (!globalServiceRegistry.has(BROWSER_CONTROL_TASK_DEPS)) {
-    throw new Error("Browser task dependencies not registered. Import @workglow/browser-control/task-server (Node/Bun) or @workglow/browser-control/task-electron before using browser-control tasks.");
-  }
-  return globalServiceRegistry.get(BROWSER_CONTROL_TASK_DEPS);
-}
-
-// src/task/register.server.ts
-var SAFE_NAME_RE = /^[a-zA-Z0-9_-]+$/;
-function safeName(value, label) {
-  if (!SAFE_NAME_RE.test(value)) {
-    throw new Error(`Invalid ${label}: must contain only alphanumeric characters, hyphens, and underscores`);
-  }
-  return value;
-}
-registerBrowserDeps({
-  createContext: (_options) => new PlaywrightBackend,
-  availableBackends: ["local", "cloud"],
-  defaultBackend: "local",
-  profileStorage: {
-    async save(projectId, profileName, state) {
-      const fs = await import("node:fs/promises");
-      const dir = path.join(process.cwd(), ".workglow", "browser-profiles", safeName(projectId, "projectId"));
-      await fs.mkdir(dir, { recursive: true });
-      await fs.writeFile(path.join(dir, `${safeName(profileName, "profileName")}.json`), state, "utf-8");
-    },
-    async load(projectId, profileName) {
-      const fs = await import("node:fs/promises");
-      try {
-        return await fs.readFile(path.join(process.cwd(), ".workglow", "browser-profiles", safeName(projectId, "projectId"), `${safeName(profileName, "profileName")}.json`), "utf-8");
-      } catch {
-        return null;
-      }
-    },
-    async delete(projectId, profileName) {
-      const fs = await import("node:fs/promises");
-      try {
-        await fs.unlink(path.join(process.cwd(), ".workglow", "browser-profiles", safeName(projectId, "projectId"), `${safeName(profileName, "profileName")}.json`));
-      } catch {}
-    }
-  }
-});
-
-// src/task/BrowserSessionRegistry.ts
-import { uuid4 } from "@workglow/util";
-var sessions = new Map;
-var BrowserSessionRegistry = {
-  register(context) {
-    const id = uuid4();
-    sessions.set(id, context);
-    return id;
-  },
-  get(sessionId) {
-    const context = sessions.get(sessionId);
-    if (!context) {
-      throw new Error(`BrowserSessionRegistry: no session found for id "${sessionId}"`);
-    }
-    if (!context.isConnected()) {
-      sessions.delete(sessionId);
-      throw new Error(`BrowserSessionRegistry: session "${sessionId}" is no longer connected`);
-    }
-    return context;
-  },
-  unregister(sessionId) {
-    sessions.delete(sessionId);
-  },
-  has(sessionId) {
-    return sessions.has(sessionId);
-  },
-  async disconnectAll() {
-    const disconnects = Array.from(sessions.values()).map((ctx) => ctx.disconnect());
-    await Promise.allSettled(disconnects);
-    sessions.clear();
-  },
-  clear() {
-    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) {
-  const nodeMap = new Map;
-  let rootNode;
-  for (const node of nodes) {
-    nodeMap.set(node.nodeId, node);
-    if (!rootNode) {
-      rootNode = node;
-    }
-  }
-  const childIds = new Set;
-  for (const node of nodes) {
-    for (const childId of node.childIds ?? []) {
-      childIds.add(childId);
-    }
-  }
-  rootNode = nodes.find((n) => !childIds.has(n.nodeId)) ?? nodes[0];
-  function buildNode(cdpNode) {
-    const role = cdpNode.role?.value ?? "";
-    if (cdpNode.ignored || IGNORED_ROLES.has(role)) {
-      return null;
-    }
-    const ref = `e${++refCounter.count}`;
-    refMap.set(ref, cdpNode.backendDOMNodeId ?? null);
-    const name = typeof cdpNode.name?.value === "string" ? cdpNode.name.value : "";
-    const node = {
-      ref,
-      role,
-      name
-    };
-    for (const prop of cdpNode.properties ?? []) {
-      switch (prop.name) {
-        case "level":
-          if (typeof prop.value.value === "number") {
-            node.level = prop.value.value;
-          }
-          break;
-        case "checked":
-          if (prop.value.value === "mixed") {
-            node.checked = "mixed";
-          } else if (typeof prop.value.value === "boolean") {
-            node.checked = prop.value.value;
-          }
-          break;
-        case "disabled":
-          node.disabled = prop.value.value === true;
-          break;
-        case "expanded":
-          node.expanded = prop.value.value === true;
-          break;
-        case "pressed":
-          if (prop.value.value === "mixed") {
-            node.pressed = "mixed";
-          } else if (typeof prop.value.value === "boolean") {
-            node.pressed = prop.value.value;
-          }
-          break;
-        case "selected":
-          node.selected = prop.value.value === true;
-          break;
-        case "valuetext":
-        case "value":
-          if (typeof prop.value.value === "string" || typeof prop.value.value === "number") {
-            node.value = prop.value.value;
-          }
-          break;
-      }
-    }
-    const childNodes = [];
-    for (const childId of cdpNode.childIds ?? []) {
-      const childCdp = nodeMap.get(childId);
-      if (childCdp) {
-        const child = buildNode(childCdp);
-        if (child)
-          childNodes.push(child);
-      }
-    }
-    if (childNodes.length > 0) {
-      node.children = childNodes;
-    }
-    return node;
-  }
-  if (!rootNode) {
-    const ref = `e${++refCounter.count}`;
-    refMap.set(ref, null);
-    return { ref, role: "document", name: "" };
-  }
-  const built = buildNode(rootNode);
-  if (!built) {
-    const ref = `e${++refCounter.count}`;
-    refMap.set(ref, null);
-    return { ref, role: "document", name: "" };
-  }
-  return built;
-}
-function serializeAXTree(node, indent = 0) {
-  const spaces = "  ".repeat(indent);
-  let line = `${spaces}- ${node.role}`;
-  if (node.name) {
-    line += ` "${node.name.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
-  }
-  if (node.level !== undefined)
-    line += ` [level=${node.level}]`;
-  if (node.checked !== undefined)
-    line += ` [checked=${node.checked}]`;
-  if (node.disabled)
-    line += ` [disabled=true]`;
-  if (node.expanded !== undefined)
-    line += ` [expanded=${node.expanded}]`;
-  if (node.pressed !== undefined)
-    line += ` [pressed=${node.pressed}]`;
-  if (node.selected)
-    line += ` [selected=true]`;
-  if (node.value !== undefined)
-    line += ` [value=${node.value}]`;
-  const lines = [line];
-  for (const child of node.children ?? []) {
-    lines.push(serializeAXTree(child, indent + 1));
-  }
-  return lines.join(`
-`);
-}
-function buildModifiersMask(modifiers) {
-  if (!modifiers)
-    return 0;
-  let mask = 0;
-  for (const mod of modifiers) {
-    if (mod === "Alt")
-      mask |= 1;
-    else if (mod === "Control")
-      mask |= 2;
-    else if (mod === "Meta")
-      mask |= 4;
-    else if (mod === "Shift")
-      mask |= 8;
-  }
-  return mask;
-}
-var KEY_CODE_MAP = {
-  Enter: "Enter",
-  Tab: "Tab",
-  Escape: "Escape",
-  Backspace: "Backspace",
-  Delete: "Delete",
-  ArrowUp: "ArrowUp",
-  ArrowDown: "ArrowDown",
-  ArrowLeft: "ArrowLeft",
-  ArrowRight: "ArrowRight",
-  Home: "Home",
-  End: "End",
-  PageUp: "PageUp",
-  PageDown: "PageDown",
-  Space: " ",
-  F1: "F1",
-  F2: "F2",
-  F3: "F3",
-  F4: "F4",
-  F5: "F5",
-  F6: "F6",
-  F7: "F7",
-  F8: "F8",
-  F9: "F9",
-  F10: "F10",
-  F11: "F11",
-  F12: "F12"
-};
-function keyToCode(key) {
-  if (key.length === 1) {
-    const upper = key.toUpperCase();
-    return `Key${upper}`;
-  }
-  const codeMap = {
-    Enter: "Enter",
-    Tab: "Tab",
-    Escape: "Escape",
-    Backspace: "Backspace",
-    Delete: "Delete",
-    ArrowUp: "ArrowUp",
-    ArrowDown: "ArrowDown",
-    ArrowLeft: "ArrowLeft",
-    ArrowRight: "ArrowRight",
-    Home: "Home",
-    End: "End",
-    PageUp: "PageUp",
-    PageDown: "PageDown",
-    Space: "Space"
-  };
-  return codeMap[key] ?? key;
-}
-
-class CDPBrowserBackend {
-  _refMap = new Map;
-  _refCounter = { count: 0 };
-  resolveRefToNodeId(ref) {
-    if (!this._refMap.has(ref)) {
-      throw new Error(`${this.backendName}: unknown ref "${ref}"`);
-    }
-    const nodeId = this._refMap.get(ref);
-    if (nodeId == null) {
-      throw new Error(`${this.backendName}: ref "${ref}" has no associated DOM node`);
-    }
-    return nodeId;
-  }
-  async getBoundingBox(backendNodeId) {
-    const result = await this.cdp("DOM.getBoxModel", { backendNodeId });
-    const content = result.model.content;
-    const x = content[0];
-    const y = content[1];
-    const width = content[2] - content[0];
-    const height = content[5] - content[1];
-    return { x, y, width, height };
-  }
-  async getDocumentRootNodeId() {
-    const doc = await this.cdp("DOM.getDocument", { depth: 0 });
-    return doc.root.nodeId;
-  }
-  async snapshot(_options = {}) {
-    this._refMap.clear();
-    const result = await this.cdp("Accessibility.getFullAXTree");
-    const nodes = result.nodes ?? [];
-    const root = parseCDPAXTree(nodes, this._refCounter, this._refMap);
-    const yaml = serializeAXTree(root);
-    return { root, yaml };
-  }
-  async click(ref, options = {}) {
-    const backendNodeId = this.resolveRefToNodeId(ref);
-    const { x, y, width, height } = await this.getBoundingBox(backendNodeId);
-    const cx = x + width / 2;
-    const cy = y + height / 2;
-    const button = options.button ?? "left";
-    const clickCount = options.clickCount ?? 1;
-    const modifiers = buildModifiersMask(options.modifiers);
-    for (let i = 0;i < clickCount; i++) {
-      await this.cdp("Input.dispatchMouseEvent", {
-        type: "mousePressed",
-        x: cx,
-        y: cy,
-        button,
-        clickCount: 1,
-        modifiers
-      });
-      await this.cdp("Input.dispatchMouseEvent", {
-        type: "mouseReleased",
-        x: cx,
-        y: cy,
-        button,
-        clickCount: 1,
-        modifiers
-      });
-    }
-  }
-  async fill(ref, value, _options = {}) {
-    const backendNodeId = this.resolveRefToNodeId(ref);
-    await this.cdp("DOM.focus", { backendNodeId });
-    await this.cdp("Input.dispatchKeyEvent", {
-      type: "keyDown",
-      key: "a",
-      code: "KeyA",
-      modifiers: 2
-    });
-    await this.cdp("Input.dispatchKeyEvent", {
-      type: "keyUp",
-      key: "a",
-      code: "KeyA",
-      modifiers: 2
-    });
-    await this.cdp("Input.insertText", { text: value });
-  }
-  async selectOption(ref, values, _options = {}) {
-    const backendNodeId = this.resolveRefToNodeId(ref);
-    const valuesArray = Array.isArray(values) ? values : [values];
-    const result = await this.cdp("DOM.resolveNode", { backendNodeId });
-    const objectId = result.object.objectId;
-    await this.cdp("Runtime.callFunctionOn", {
-      objectId,
-      functionDeclaration: `function(vals) {
-        const opts = Array.from(this.options);
-        for (const opt of opts) {
-          opt.selected = vals.includes(opt.value);
-        }
-        this.dispatchEvent(new Event('change', { bubbles: true }));
-      }`,
-      arguments: [{ value: valuesArray }]
-    });
-  }
-  async hover(ref, _options = {}) {
-    const backendNodeId = this.resolveRefToNodeId(ref);
-    const { x, y, width, height } = await this.getBoundingBox(backendNodeId);
-    const cx = x + width / 2;
-    const cy = y + height / 2;
-    await this.cdp("Input.dispatchMouseEvent", {
-      type: "mouseMoved",
-      x: cx,
-      y: cy
-    });
-  }
-  async clickByRole(role, name, options = {}) {
-    const result = await this.cdp("Accessibility.queryAXTree", {
-      role,
-      name
-    });
-    const axNode = result.nodes?.[0];
-    if (!axNode) {
-      throw new Error(`${this.backendName}: no element with role "${role}" and name "${name}"`);
-    }
-    if (axNode.backendDOMNodeId == null) {
-      throw new Error(`${this.backendName}: element with role "${role}" and name "${name}" has no DOM node`);
-    }
-    const { x, y, width, height } = await this.getBoundingBox(axNode.backendDOMNodeId);
-    const cx = x + width / 2;
-    const cy = y + height / 2;
-    const button = options.button ?? "left";
-    const clickCount = options.clickCount ?? 1;
-    const modifiers = buildModifiersMask(options.modifiers);
-    for (let i = 0;i < clickCount; i++) {
-      await this.cdp("Input.dispatchMouseEvent", {
-        type: "mousePressed",
-        x: cx,
-        y: cy,
-        button,
-        clickCount: 1,
-        modifiers
-      });
-      await this.cdp("Input.dispatchMouseEvent", {
-        type: "mouseReleased",
-        x: cx,
-        y: cy,
-        button,
-        clickCount: 1,
-        modifiers
-      });
-    }
-  }
-  async fillByLabel(label, value, _options = {}) {
-    const labelResult = await this.cdp("Accessibility.queryAXTree", {
-      role: "label",
-      name: label
-    });
-    if (labelResult.nodes?.[0]?.backendDOMNodeId != null) {
-      const labelNodeId = labelResult.nodes[0].backendDOMNodeId;
-      const resolveResult = await this.cdp("DOM.resolveNode", {
-        backendNodeId: labelNodeId
-      });
-      const inputResult = await this.cdp("Runtime.callFunctionOn", {
-        objectId: resolveResult.object.objectId,
-        functionDeclaration: `function() {
-          const forAttr = this.htmlFor || this.getAttribute('for');
-          if (forAttr) {
-            return document.getElementById(forAttr);
-          }
-          return this.querySelector('input, textarea, select');
-        }`,
-        returnByValue: false
-      });
-      if (inputResult.result.objectId && inputResult.result.subtype !== "null") {
-        const inputNodeResult = await this.cdp("DOM.requestNode", {
-          objectId: inputResult.result.objectId
-        });
-        const describeResult = await this.cdp("DOM.describeNode", {
-          nodeId: inputNodeResult.nodeId
-        });
-        await this.cdp("DOM.focus", { backendNodeId: describeResult.node.backendNodeId });
-        await this.cdp("Input.dispatchKeyEvent", {
-          type: "keyDown",
-          key: "a",
-          code: "KeyA",
-          modifiers: 2
-        });
-        await this.cdp("Input.dispatchKeyEvent", {
-          type: "keyUp",
-          key: "a",
-          code: "KeyA",
-          modifiers: 2
-        });
-        await this.cdp("Input.insertText", { text: value });
-        return;
-      }
-    }
-    const script = `(function() {
-      const labels = Array.from(document.querySelectorAll('label'));
-      const label = labels.find(l => l.textContent.trim() === ${JSON.stringify(label)});
-      if (!label) return false;
-      const forAttr = label.htmlFor;
-      let input = forAttr ? document.getElementById(forAttr) : label.querySelector('input, textarea, select');
-      if (!input) return false;
-      input.focus();
-      const nativeInputValueSetter = Object.getOwnPropertyDescriptor(
-        Object.getPrototypeOf(input), 'value'
-      )?.set;
-      if (nativeInputValueSetter) {
-        nativeInputValueSetter.call(input, ${JSON.stringify(value)});
-      } else {
-        input.value = ${JSON.stringify(value)};
-      }
-      input.dispatchEvent(new Event('input', { bubbles: true }));
-      input.dispatchEvent(new Event('change', { bubbles: true }));
-      return true;
-    })()`;
-    const filled = await this.evaluateInPage(script);
-    if (!filled) {
-      throw new Error(`${this.backendName}: no input found for label "${label}"`);
-    }
-  }
-  async innerHTML(ref) {
-    const backendNodeId = this.resolveRefToNodeId(ref);
-    const result = await this.cdp("DOM.getOuterHTML", { backendNodeId });
-    const outer = result.outerHTML;
-    const startTagEnd = outer.indexOf(">");
-    const endTagStart = outer.lastIndexOf("<");
-    if (startTagEnd === -1 || endTagStart <= startTagEnd) {
-      return outer;
-    }
-    return outer.slice(startTagEnd + 1, endTagStart);
-  }
-  async textContent(ref) {
-    const backendNodeId = this.resolveRefToNodeId(ref);
-    const resolveResult = await this.cdp("DOM.resolveNode", { backendNodeId });
-    const objectId = resolveResult.object.objectId;
-    const result = await this.cdp("Runtime.callFunctionOn", {
-      objectId,
-      functionDeclaration: "function() { return this.textContent; }",
-      returnByValue: true
-    });
-    return result.result.value;
-  }
-  async attribute(ref, name) {
-    const backendNodeId = this.resolveRefToNodeId(ref);
-    const resolveResult = await this.cdp("DOM.resolveNode", { backendNodeId });
-    const objectId = resolveResult.object.objectId;
-    const result = await this.cdp("Runtime.callFunctionOn", {
-      objectId,
-      functionDeclaration: "function(attrName) { return this.getAttribute(attrName); }",
-      arguments: [{ value: name }],
-      returnByValue: true
-    });
-    return result.result.value;
-  }
-  async querySelector(selector) {
-    const rootNodeId = await this.getDocumentRootNodeId();
-    const result = await this.cdp("DOM.querySelector", {
-      nodeId: rootNodeId,
-      selector
-    });
-    if (!result.nodeId || result.nodeId === 0)
-      return null;
-    const describeResult = await this.cdp("DOM.describeNode", { nodeId: result.nodeId });
-    const ref = `e${++this._refCounter.count}`;
-    this._refMap.set(ref, describeResult.node.backendNodeId);
-    return ref;
-  }
-  async querySelectorAll(selector) {
-    const rootNodeId = await this.getDocumentRootNodeId();
-    const result = await this.cdp("DOM.querySelectorAll", {
-      nodeId: rootNodeId,
-      selector
-    });
-    const nodeIds = result.nodeIds ?? [];
-    const refs = [];
-    for (const nodeId of nodeIds) {
-      const describeResult = await this.cdp("DOM.describeNode", { nodeId });
-      const ref = `e${++this._refCounter.count}`;
-      this._refMap.set(ref, describeResult.node.backendNodeId);
-      refs.push(ref);
-    }
-    return refs;
-  }
-  async pressKey(key, _options = {}) {
-    const keyCode = KEY_CODE_MAP[key] ?? key;
-    await this.cdp("Input.dispatchKeyEvent", {
-      type: "keyDown",
-      key: keyCode,
-      code: keyToCode(key)
-    });
-    await this.cdp("Input.dispatchKeyEvent", {
-      type: "keyUp",
-      key: keyCode,
-      code: keyToCode(key)
-    });
-  }
-  async type(text, _options = {}) {
-    await this.cdp("Input.insertText", { text });
-  }
-  async scroll(x, y, ref) {
-    if (ref) {
-      const backendNodeId = this.resolveRefToNodeId(ref);
-      const resolveResult = await this.cdp("DOM.resolveNode", { backendNodeId });
-      const objectId = resolveResult.object.objectId;
-      await this.cdp("Runtime.callFunctionOn", {
-        objectId,
-        functionDeclaration: `function(dx, dy) { this.scrollBy(dx, dy); }`,
-        arguments: [{ value: x }, { value: y }]
-      });
-    } else {
-      await this.cdp("Input.dispatchMouseEvent", {
-        type: "mouseWheel",
-        x: 0,
-        y: 0,
-        deltaX: x,
-        deltaY: y
-      });
-    }
-  }
-  async uploadFile(ref, paths) {
-    const backendNodeId = this.resolveRefToNodeId(ref);
-    const files = Array.isArray(paths) ? paths : [paths];
-    await this.cdp("DOM.setFileInputFiles", {
-      backendNodeId,
-      files
-    });
-  }
-}
-
-// 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,
-  mergeEntitlements,
-  Task,
-  TaskConfigSchema
-} from "@workglow/task-graph";
-var browserSessionTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema["properties"],
-    backend: {
-      type: "string",
-      enum: ["local", "cloud", "electron-native"],
-      title: "Backend",
-      description: "The browser backend to use"
-    },
-    projectId: {
-      type: "string",
-      title: "Project ID",
-      description: "Project identifier for profile storage"
-    },
-    profileName: {
-      type: "string",
-      title: "Profile Name",
-      description: "Named browser profile to use"
-    },
-    headless: {
-      type: "boolean",
-      title: "Headless",
-      description: "Run the browser in headless mode",
-      default: true
-    }
-  },
-  additionalProperties: false
-};
-var inputSchema = {
-  type: "object",
-  properties: {},
-  additionalProperties: false
-};
-var outputSchema = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The unique identifier for the created browser session"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-
-class BrowserSessionTask extends Task {
-  static type = "BrowserSessionTask";
-  static category = "Browser";
-  static title = "Browser Session";
-  static description = "Creates a new browser session and returns its session ID";
-  static cacheable = false;
-  static hasDynamicEntitlements = true;
-  static configSchema() {
-    return browserSessionTaskConfigSchema;
-  }
-  static inputSchema() {
-    return inputSchema;
-  }
-  static outputSchema() {
-    return outputSchema;
-  }
-  static entitlements() {
-    return {
-      entitlements: [
-        { id: Entitlements.BROWSER_CONTROL, reason: "Creates and manages a browser session" }
-      ]
-    };
-  }
-  entitlements() {
-    const base = BrowserSessionTask.entitlements();
-    const backend = this.config.backend;
-    if (backend === "local" || backend === "electron-native") {
-      return mergeEntitlements(base, {
-        entitlements: [
-          { id: Entitlements.BROWSER_CONTROL_LOCAL, reason: "Launches a local browser process" }
-        ]
-      });
-    }
-    if (backend === "cloud") {
-      return mergeEntitlements(base, {
-        entitlements: [
-          {
-            id: Entitlements.BROWSER_CONTROL_CLOUD,
-            reason: "Connects to a remote cloud browser service"
-          }
-        ]
-      });
-    }
-    return mergeEntitlements(base, mergeEntitlements({
-      entitlements: [
-        { id: Entitlements.BROWSER_CONTROL_LOCAL, reason: "Launches a local browser process" }
-      ]
-    }, {
-      entitlements: [
-        {
-          id: Entitlements.BROWSER_CONTROL_CLOUD,
-          reason: "Connects to a remote cloud browser service"
-        }
-      ]
-    }));
-  }
-  async execute(_input, executeContext) {
-    const deps = getBrowserDeps();
-    const backend = this.config.backend ?? deps.defaultBackend;
-    if (!deps.availableBackends.includes(backend)) {
-      throw new Error(`BrowserSessionTask: backend "${backend}" is not available. Available backends: ${deps.availableBackends.join(", ")}`);
-    }
-    const options = {
-      backend,
-      projectId: this.config.projectId,
-      profileName: this.config.profileName,
-      headless: this.config.headless ?? true
-    };
-    const ctx = deps.createContext(options);
-    await ctx.connect(options);
-    const sessionId = BrowserSessionRegistry.register(ctx);
-    executeContext.resourceScope?.register(`browser:${sessionId}`, async () => {
-      await ctx.disconnect();
-      BrowserSessionRegistry.unregister(sessionId);
-    });
-    return { sessionId };
-  }
-}
-// src/task/tasks/BrowserCloseTask.ts
-import { Task as Task2, TaskConfigSchema as TaskConfigSchema2 } from "@workglow/task-graph";
-var inputSchema2 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The session ID of the browser session to close"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-var outputSchema2 = {
-  type: "object",
-  properties: {},
-  additionalProperties: false
-};
-
-class BrowserCloseTask extends Task2 {
-  static type = "BrowserCloseTask";
-  static category = "Browser";
-  static title = "Browser Close";
-  static description = "Disconnects and closes an existing browser session";
-  static cacheable = false;
-  static configSchema() {
-    return TaskConfigSchema2;
-  }
-  static inputSchema() {
-    return inputSchema2;
-  }
-  static outputSchema() {
-    return outputSchema2;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    await ctx.disconnect();
-    BrowserSessionRegistry.unregister(input.sessionId);
-    return {};
-  }
-}
-// src/task/tasks/BrowserNavigateTask.ts
-import {
-  Entitlements as Entitlements2,
-  Task as Task3,
-  TaskConfigSchema as TaskConfigSchema3
-} from "@workglow/task-graph";
-var browserNavigateTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema3["properties"],
-    waitUntil: {
-      type: "string",
-      enum: ["load", "domcontentloaded", "networkidle"],
-      title: "Wait Until",
-      description: "When to consider navigation complete",
-      default: "load"
-    }
-  },
-  additionalProperties: false
-};
-var inputSchema3 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    },
-    url: {
-      type: "string",
-      format: "uri",
-      title: "URL",
-      description: "The URL to navigate to"
-    }
-  },
-  required: ["sessionId", "url"],
-  additionalProperties: false
-};
-var outputSchema3 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    },
-    title: {
-      type: "string",
-      title: "Page Title",
-      description: "The title of the navigated page"
-    },
-    url: {
-      type: "string",
-      title: "URL",
-      description: "The current URL after navigation"
-    }
-  },
-  required: ["sessionId", "title", "url"],
-  additionalProperties: false
-};
-
-class BrowserNavigateTask extends Task3 {
-  static type = "BrowserNavigateTask";
-  static category = "Browser";
-  static title = "Browser Navigate";
-  static description = "Navigates the browser to a URL and returns the page title and URL";
-  static cacheable = false;
-  static configSchema() {
-    return browserNavigateTaskConfigSchema;
-  }
-  static inputSchema() {
-    return inputSchema3;
-  }
-  static outputSchema() {
-    return outputSchema3;
-  }
-  static entitlements() {
-    return {
-      entitlements: [
-        { id: Entitlements2.BROWSER_CONTROL_NAVIGATE, reason: "Navigates to a URL in the browser" }
-      ]
-    };
-  }
-  async execute(input, _executeContext) {
-    const parsed = new URL(input.url, "https://placeholder");
-    if (parsed.protocol === "javascript:") {
-      throw new Error("BrowserNavigateTask: javascript: URLs are not allowed");
-    }
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    const waitUntil = this.config.waitUntil ?? "load";
-    await ctx.navigate(input.url, { waitUntil });
-    const title = await ctx.title();
-    const url = await ctx.currentUrl();
-    return { sessionId: input.sessionId, title, url };
-  }
-}
-// src/task/tasks/BrowserBackTask.ts
-import { Task as Task4, TaskConfigSchema as TaskConfigSchema4 } from "@workglow/task-graph";
-var inputSchema4 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-var outputSchema4 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    },
-    url: {
-      type: "string",
-      title: "URL",
-      description: "The current URL after navigating back"
-    }
-  },
-  required: ["sessionId", "url"],
-  additionalProperties: false
-};
-
-class BrowserBackTask extends Task4 {
-  static type = "BrowserBackTask";
-  static category = "Browser";
-  static title = "Browser Back";
-  static description = "Navigates back in the browser history and returns the current URL";
-  static cacheable = false;
-  static configSchema() {
-    return TaskConfigSchema4;
-  }
-  static inputSchema() {
-    return inputSchema4;
-  }
-  static outputSchema() {
-    return outputSchema4;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    await ctx.goBack();
-    const url = await ctx.currentUrl();
-    return { sessionId: input.sessionId, url };
-  }
-}
-// src/task/tasks/BrowserForwardTask.ts
-import { Task as Task5, TaskConfigSchema as TaskConfigSchema5 } from "@workglow/task-graph";
-var inputSchema5 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-var outputSchema5 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    },
-    url: {
-      type: "string",
-      title: "URL",
-      description: "The current URL after navigating forward"
-    }
-  },
-  required: ["sessionId", "url"],
-  additionalProperties: false
-};
-
-class BrowserForwardTask extends Task5 {
-  static type = "BrowserForwardTask";
-  static category = "Browser";
-  static title = "Browser Forward";
-  static description = "Navigates forward in the browser history and returns the current URL";
-  static cacheable = false;
-  static configSchema() {
-    return TaskConfigSchema5;
-  }
-  static inputSchema() {
-    return inputSchema5;
-  }
-  static outputSchema() {
-    return outputSchema5;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    await ctx.goForward();
-    const url = await ctx.currentUrl();
-    return { sessionId: input.sessionId, url };
-  }
-}
-// src/task/tasks/BrowserReloadTask.ts
-import { Task as Task6, TaskConfigSchema as TaskConfigSchema6 } from "@workglow/task-graph";
-var inputSchema6 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-var outputSchema6 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-
-class BrowserReloadTask extends Task6 {
-  static type = "BrowserReloadTask";
-  static category = "Browser";
-  static title = "Browser Reload";
-  static description = "Reloads the current page in the browser";
-  static cacheable = false;
-  static configSchema() {
-    return TaskConfigSchema6;
-  }
-  static inputSchema() {
-    return inputSchema6;
-  }
-  static outputSchema() {
-    return outputSchema6;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    await ctx.reload();
-    return { sessionId: input.sessionId };
-  }
-}
-// src/task/tasks/BrowserSnapshotTask.ts
-import { Task as Task7, TaskConfigSchema as TaskConfigSchema7 } from "@workglow/task-graph";
-var inputSchema7 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-var outputSchema7 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    },
-    tree: {
-      type: "object",
-      title: "Accessibility Tree",
-      description: "The accessibility tree of the current page",
-      additionalProperties: true
-    }
-  },
-  required: ["sessionId", "tree"],
-  additionalProperties: false
-};
-
-class BrowserSnapshotTask extends Task7 {
-  static type = "BrowserSnapshotTask";
-  static category = "Browser";
-  static title = "Browser Snapshot";
-  static description = "Returns the accessibility tree of the current browser page";
-  static cacheable = false;
-  static configSchema() {
-    return TaskConfigSchema7;
-  }
-  static inputSchema() {
-    return inputSchema7;
-  }
-  static outputSchema() {
-    return outputSchema7;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    const tree = await ctx.snapshot();
-    return { sessionId: input.sessionId, tree };
-  }
-}
-// src/task/tasks/BrowserScreenshotTask.ts
-import { Task as Task8, TaskConfigSchema as TaskConfigSchema8 } from "@workglow/task-graph";
-var browserScreenshotTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema8["properties"],
-    format: {
-      type: "string",
-      enum: ["png", "jpeg"],
-      title: "Format",
-      description: "The image format for the screenshot",
-      default: "png"
-    },
-    fullPage: {
-      type: "boolean",
-      title: "Full Page",
-      description: "Whether to capture the full scrollable page",
-      default: false
-    }
-  },
-  additionalProperties: false
-};
-var inputSchema8 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-var outputSchema8 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    },
-    image: {
-      type: "string",
-      format: "binary",
-      title: "Image",
-      description: "The screenshot image data"
-    }
-  },
-  required: ["sessionId", "image"],
-  additionalProperties: false
-};
-
-class BrowserScreenshotTask extends Task8 {
-  static type = "BrowserScreenshotTask";
-  static category = "Browser";
-  static title = "Browser Screenshot";
-  static description = "Takes a screenshot of the current browser page";
-  static cacheable = false;
-  static configSchema() {
-    return browserScreenshotTaskConfigSchema;
-  }
-  static inputSchema() {
-    return inputSchema8;
-  }
-  static outputSchema() {
-    return outputSchema8;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    const format = this.config.format ?? "png";
-    const fullPage = this.config.fullPage ?? false;
-    const image = await ctx.screenshot({ format, fullPage });
-    return { sessionId: input.sessionId, image };
-  }
-}
-// src/task/tasks/BrowserClickTask.ts
-import { Task as Task9, TaskConfigSchema as TaskConfigSchema9 } from "@workglow/task-graph";
-var browserClickTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema9["properties"],
-    modifiers: {
-      type: "array",
-      items: {
-        type: "string",
-        enum: ["Alt", "Control", "Meta", "Shift"]
-      },
-      title: "Modifiers",
-      description: "Keyboard modifiers to hold during the click"
-    }
-  },
-  additionalProperties: false
-};
-var inputSchema9 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    },
-    ref: {
-      type: "string",
-      title: "Element Ref",
-      description: "The element reference to click"
-    },
-    role: {
-      type: "string",
-      title: "ARIA Role",
-      description: "The ARIA role of the element to click"
-    },
-    name: {
-      type: "string",
-      title: "Accessible Name",
-      description: "The accessible name of the element to click"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-var outputSchema9 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-
-class BrowserClickTask extends Task9 {
-  static type = "BrowserClickTask";
-  static category = "Browser";
-  static title = "Browser Click";
-  static description = "Clicks an element in the browser by ref or by ARIA role and name";
-  static cacheable = false;
-  static configSchema() {
-    return browserClickTaskConfigSchema;
-  }
-  static inputSchema() {
-    return inputSchema9;
-  }
-  static outputSchema() {
-    return outputSchema9;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    const opts = this.config.modifiers ? { modifiers: this.config.modifiers } : undefined;
-    if (input.ref) {
-      await ctx.click(input.ref, opts);
-    } else if (input.role && input.name) {
-      await ctx.clickByRole(input.role, input.name, opts);
-    } else {
-      throw new Error("BrowserClickTask: either ref or role+name must be provided");
-    }
-    return { sessionId: input.sessionId };
-  }
-}
-// src/task/tasks/BrowserFillTask.ts
-import { Task as Task10, TaskConfigSchema as TaskConfigSchema10 } from "@workglow/task-graph";
-var browserFillTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema10["properties"],
-    clearFirst: {
-      type: "boolean",
-      title: "Clear First",
-      description: "Whether to clear the field before filling",
-      default: true
-    }
-  },
-  additionalProperties: false
-};
-var inputSchema10 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    },
-    ref: {
-      type: "string",
-      title: "Element Ref",
-      description: "The element reference to fill"
-    },
-    label: {
-      type: "string",
-      title: "Label",
-      description: "The label text of the input to fill"
-    },
-    value: {
-      type: "string",
-      title: "Value",
-      description: "The value to fill into the input"
-    }
-  },
-  required: ["sessionId", "value"],
-  additionalProperties: false
-};
-var outputSchema10 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-
-class BrowserFillTask extends Task10 {
-  static type = "BrowserFillTask";
-  static category = "Browser";
-  static title = "Browser Fill";
-  static description = "Fills a text input in the browser by ref or by label";
-  static cacheable = false;
-  static configSchema() {
-    return browserFillTaskConfigSchema;
-  }
-  static inputSchema() {
-    return inputSchema10;
-  }
-  static outputSchema() {
-    return outputSchema10;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    if (input.ref) {
-      await ctx.fill(input.ref, input.value);
-    } else if (input.label) {
-      await ctx.fillByLabel(input.label, input.value);
-    } else {
-      throw new Error("BrowserFillTask: either ref or label must be provided");
-    }
-    return { sessionId: input.sessionId };
-  }
-}
-// src/task/tasks/BrowserSelectTask.ts
-import { Task as Task11, TaskConfigSchema as TaskConfigSchema11 } from "@workglow/task-graph";
-var inputSchema11 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    },
-    ref: {
-      type: "string",
-      title: "Element Ref",
-      description: "The element reference of the select element"
-    },
-    label: {
-      type: "string",
-      title: "Label",
-      description: "The label text of the select element (not yet supported, use ref)"
-    },
-    value: {
-      type: "string",
-      title: "Value",
-      description: "The option value to select"
-    }
-  },
-  required: ["sessionId", "value"],
-  additionalProperties: false
-};
-var outputSchema11 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-
-class BrowserSelectTask extends Task11 {
-  static type = "BrowserSelectTask";
-  static category = "Browser";
-  static title = "Browser Select";
-  static description = "Selects an option in a select element identified by ref";
-  static cacheable = false;
-  static configSchema() {
-    return TaskConfigSchema11;
-  }
-  static inputSchema() {
-    return inputSchema11;
-  }
-  static outputSchema() {
-    return outputSchema11;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    if (input.ref) {
-      await ctx.selectOption(input.ref, input.value);
-    } else {
-      throw new Error("BrowserSelectTask: ref must be provided");
-    }
-    return { sessionId: input.sessionId };
-  }
-}
-// src/task/tasks/BrowserHoverTask.ts
-import { Task as Task12, TaskConfigSchema as TaskConfigSchema12 } from "@workglow/task-graph";
-var inputSchema12 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    },
-    ref: {
-      type: "string",
-      title: "Element Ref",
-      description: "The element reference to hover over"
-    },
-    role: {
-      type: "string",
-      title: "ARIA Role",
-      description: "The ARIA role of the element to hover (not yet supported, use ref)"
-    },
-    name: {
-      type: "string",
-      title: "Accessible Name",
-      description: "The accessible name of the element to hover (not yet supported, use ref)"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-var outputSchema12 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-
-class BrowserHoverTask extends Task12 {
-  static type = "BrowserHoverTask";
-  static category = "Browser";
-  static title = "Browser Hover";
-  static description = "Hovers over an element in the browser identified by ref";
-  static cacheable = false;
-  static configSchema() {
-    return TaskConfigSchema12;
-  }
-  static inputSchema() {
-    return inputSchema12;
-  }
-  static outputSchema() {
-    return outputSchema12;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    if (input.ref) {
-      await ctx.hover(input.ref);
-    } else {
-      throw new Error("BrowserHoverTask: ref must be provided");
-    }
-    return { sessionId: input.sessionId };
-  }
-}
-// src/task/tasks/BrowserExtractTextTask.ts
-import { Task as Task13, TaskConfigSchema as TaskConfigSchema13 } from "@workglow/task-graph";
-var browserExtractTextTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema13["properties"],
-    ref: {
-      type: "string",
-      title: "Element Ref",
-      description: "The element reference to extract text from (extracts from full page if not provided)"
-    }
-  },
-  additionalProperties: false
-};
-var inputSchema13 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-var outputSchema13 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    },
-    text: {
-      type: "string",
-      title: "Text",
-      description: "The extracted text content"
-    }
-  },
-  required: ["sessionId", "text"],
-  additionalProperties: false
-};
-
-class BrowserExtractTextTask extends Task13 {
-  static type = "BrowserExtractTextTask";
-  static category = "Browser";
-  static title = "Browser Extract Text";
-  static description = "Extracts text content from a specific element or the full page";
-  static cacheable = false;
-  static configSchema() {
-    return browserExtractTextTaskConfigSchema;
-  }
-  static inputSchema() {
-    return inputSchema13;
-  }
-  static outputSchema() {
-    return outputSchema13;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    let ref = this.config.ref;
-    if (!ref) {
-      const bodyRef = await ctx.querySelector("body");
-      if (!bodyRef) {
-        throw new Error("BrowserExtractTextTask: could not find body element");
-      }
-      ref = bodyRef;
-    }
-    const text = await ctx.textContent(ref);
-    return { sessionId: input.sessionId, text: text ?? "" };
-  }
-}
-// src/task/tasks/BrowserExtractHtmlTask.ts
-import { Task as Task14, TaskConfigSchema as TaskConfigSchema14 } from "@workglow/task-graph";
-var browserExtractHtmlTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema14["properties"],
-    ref: {
-      type: "string",
-      title: "Element Ref",
-      description: "The element reference to extract HTML from"
-    },
-    selector: {
-      type: "string",
-      title: "CSS Selector",
-      description: "CSS selector to find element when no ref is provided"
-    }
-  },
-  additionalProperties: false
-};
-var inputSchema14 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-var outputSchema14 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    },
-    html: {
-      type: "string",
-      title: "HTML",
-      description: "The extracted HTML content"
-    }
-  },
-  required: ["sessionId", "html"],
-  additionalProperties: false
-};
-
-class BrowserExtractHtmlTask extends Task14 {
-  static type = "BrowserExtractHtmlTask";
-  static category = "Browser";
-  static title = "Browser Extract HTML";
-  static description = "Extracts HTML content from a specific element by ref or CSS selector";
-  static cacheable = false;
-  static configSchema() {
-    return browserExtractHtmlTaskConfigSchema;
-  }
-  static inputSchema() {
-    return inputSchema14;
-  }
-  static outputSchema() {
-    return outputSchema14;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    let ref = this.config.ref;
-    if (!ref) {
-      if (!this.config.selector) {
-        throw new Error("BrowserExtractHtmlTask requires either config.ref or config.selector");
-      }
-      const found = await ctx.querySelector(this.config.selector);
-      if (!found) {
-        throw new Error(`BrowserExtractHtmlTask could not find an element matching selector: ${this.config.selector}`);
-      }
-      ref = found;
-    }
-    const html = await ctx.innerHTML(ref);
-    return { sessionId: input.sessionId, html };
-  }
-}
-// src/task/tasks/BrowserAttributeTask.ts
-import { Task as Task15, TaskConfigSchema as TaskConfigSchema15 } from "@workglow/task-graph";
-var inputSchema15 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    },
-    ref: {
-      type: "string",
-      title: "Element Ref",
-      description: "The element reference to get the attribute from"
-    },
-    attribute: {
-      type: "string",
-      title: "Attribute Name",
-      description: "The name of the attribute to retrieve"
-    }
-  },
-  required: ["sessionId", "ref", "attribute"],
-  additionalProperties: false
-};
-var outputSchema15 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    },
-    value: {
-      type: ["string", "null"],
-      title: "Value",
-      description: "The attribute value, or null if not present"
-    }
-  },
-  required: ["sessionId", "value"],
-  additionalProperties: false
-};
-
-class BrowserAttributeTask extends Task15 {
-  static type = "BrowserAttributeTask";
-  static category = "Browser";
-  static title = "Browser Attribute";
-  static description = "Retrieves the value of an attribute from a browser element";
-  static cacheable = false;
-  static configSchema() {
-    return TaskConfigSchema15;
-  }
-  static inputSchema() {
-    return inputSchema15;
-  }
-  static outputSchema() {
-    return outputSchema15;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    const value = await ctx.attribute(input.ref, input.attribute);
-    return { sessionId: input.sessionId, value };
-  }
-}
-// src/task/tasks/BrowserQuerySelectorTask.ts
-import { Task as Task16, TaskConfigSchema as TaskConfigSchema16 } from "@workglow/task-graph";
-var inputSchema16 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    },
-    selector: {
-      type: "string",
-      title: "CSS Selector",
-      description: "The CSS selector to query for"
-    }
-  },
-  required: ["sessionId", "selector"],
-  additionalProperties: false
-};
-var outputSchema16 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    },
-    refs: {
-      type: "array",
-      items: { type: "string" },
-      title: "Element Refs",
-      description: "The element references matching the selector"
-    }
-  },
-  required: ["sessionId", "refs"],
-  additionalProperties: false
-};
-
-class BrowserQuerySelectorTask extends Task16 {
-  static type = "BrowserQuerySelectorTask";
-  static category = "Browser";
-  static title = "Browser Query Selector";
-  static description = "Queries all elements matching a CSS selector and returns their refs";
-  static cacheable = false;
-  static configSchema() {
-    return TaskConfigSchema16;
-  }
-  static inputSchema() {
-    return inputSchema16;
-  }
-  static outputSchema() {
-    return outputSchema16;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    const refs = await ctx.querySelectorAll(input.selector);
-    return { sessionId: input.sessionId, refs };
-  }
-}
-// src/task/tasks/BrowserEvaluateTask.ts
-import {
-  Entitlements as Entitlements3,
-  Task as Task17,
-  TaskConfigSchema as TaskConfigSchema17
-} from "@workglow/task-graph";
-var inputSchema17 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    },
-    expression: {
-      type: "string",
-      title: "Expression",
-      description: "The JavaScript expression to evaluate in the page context"
-    }
-  },
-  required: ["sessionId", "expression"],
-  additionalProperties: false
-};
-var outputSchema17 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    },
-    result: {
-      title: "Result",
-      description: "The result of the evaluated expression"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-
-class BrowserEvaluateTask extends Task17 {
-  static type = "BrowserEvaluateTask";
-  static category = "Browser";
-  static title = "Browser Evaluate";
-  static description = "Evaluates a JavaScript expression in the browser page context";
-  static cacheable = false;
-  static configSchema() {
-    return TaskConfigSchema17;
-  }
-  static inputSchema() {
-    return inputSchema17;
-  }
-  static outputSchema() {
-    return outputSchema17;
-  }
-  static entitlements() {
-    return {
-      entitlements: [
-        {
-          id: Entitlements3.BROWSER_CONTROL_EVALUATE,
-          reason: "Evaluates arbitrary JavaScript in the browser context"
-        }
-      ]
-    };
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    const result = await ctx.evaluate(input.expression);
-    return { sessionId: input.sessionId, result };
-  }
-}
-// src/task/tasks/BrowserPressKeyTask.ts
-import { Task as Task18, TaskConfigSchema as TaskConfigSchema18 } from "@workglow/task-graph";
-var browserPressKeyTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema18["properties"],
-    modifiers: {
-      type: "array",
-      items: {
-        type: "string",
-        enum: ["Alt", "Control", "Meta", "Shift"]
-      },
-      title: "Modifiers",
-      description: "Keyboard modifiers to hold during the key press"
-    }
-  },
-  additionalProperties: false
-};
-var inputSchema18 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    },
-    key: {
-      type: "string",
-      title: "Key",
-      description: "The key to press (e.g. Enter, Tab, ArrowDown)"
-    }
-  },
-  required: ["sessionId", "key"],
-  additionalProperties: false
-};
-var outputSchema18 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-
-class BrowserPressKeyTask extends Task18 {
-  static type = "BrowserPressKeyTask";
-  static category = "Browser";
-  static title = "Browser Press Key";
-  static description = "Presses a keyboard key in the browser, optionally with modifiers";
-  static cacheable = false;
-  static configSchema() {
-    return browserPressKeyTaskConfigSchema;
-  }
-  static inputSchema() {
-    return inputSchema18;
-  }
-  static outputSchema() {
-    return outputSchema18;
-  }
-  buildKeyChord(key) {
-    const modifiers = this.config.modifiers?.filter(Boolean) ?? [];
-    return modifiers.length > 0 ? `${modifiers.join("+")}+${key}` : key;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    await ctx.pressKey(this.buildKeyChord(input.key));
-    return { sessionId: input.sessionId };
-  }
-}
-// src/task/tasks/BrowserTypeTask.ts
-import { Task as Task19, TaskConfigSchema as TaskConfigSchema19 } from "@workglow/task-graph";
-var browserTypeTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema19["properties"]
-  },
-  additionalProperties: false
-};
-var inputSchema19 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    },
-    text: {
-      type: "string",
-      title: "Text",
-      description: "The text to type into the currently focused element"
-    }
-  },
-  required: ["sessionId", "text"],
-  additionalProperties: false
-};
-var outputSchema19 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-
-class BrowserTypeTask extends Task19 {
-  static type = "BrowserTypeTask";
-  static category = "Browser";
-  static title = "Browser Type";
-  static description = "Types text into the currently focused element in the browser";
-  static cacheable = false;
-  static configSchema() {
-    return browserTypeTaskConfigSchema;
-  }
-  static inputSchema() {
-    return inputSchema19;
-  }
-  static outputSchema() {
-    return outputSchema19;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    await ctx.type(input.text);
-    return { sessionId: input.sessionId };
-  }
-}
-// src/task/tasks/BrowserScrollTask.ts
-import { Task as Task20, TaskConfigSchema as TaskConfigSchema20 } from "@workglow/task-graph";
-var browserScrollTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema20["properties"],
-    x: {
-      type: "number",
-      title: "X",
-      description: "Horizontal scroll amount in pixels",
-      default: 0
-    },
-    y: {
-      type: "number",
-      title: "Y",
-      description: "Vertical scroll amount in pixels",
-      default: 0
-    },
-    ref: {
-      type: "string",
-      title: "Element Ref",
-      description: "The element reference to scroll within (scrolls page if not provided)"
-    }
-  },
-  additionalProperties: false
-};
-var inputSchema20 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-var outputSchema20 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-
-class BrowserScrollTask extends Task20 {
-  static type = "BrowserScrollTask";
-  static category = "Browser";
-  static title = "Browser Scroll";
-  static description = "Scrolls the page or a specific element by the given pixel deltas";
-  static cacheable = false;
-  static configSchema() {
-    return browserScrollTaskConfigSchema;
-  }
-  static inputSchema() {
-    return inputSchema20;
-  }
-  static outputSchema() {
-    return outputSchema20;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    await ctx.scroll(this.config.x ?? 0, this.config.y ?? 0, this.config.ref);
-    return { sessionId: input.sessionId };
-  }
-}
-// src/task/tasks/BrowserUploadTask.ts
-import {
-  Entitlements as Entitlements4,
-  Task as Task21,
-  TaskConfigSchema as TaskConfigSchema21
-} from "@workglow/task-graph";
-var browserUploadTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema21["properties"]
-  },
-  additionalProperties: false
-};
-var inputSchema21 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    },
-    ref: {
-      type: "string",
-      title: "Element Ref",
-      description: "The file input element reference to upload to"
-    },
-    filePaths: {
-      type: "array",
-      items: {
-        type: "string"
-      },
-      title: "File Paths",
-      description: "The local file paths to upload"
-    }
-  },
-  required: ["sessionId", "ref", "filePaths"],
-  additionalProperties: false
-};
-var outputSchema21 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-
-class BrowserUploadTask extends Task21 {
-  static type = "BrowserUploadTask";
-  static category = "Browser";
-  static title = "Browser Upload";
-  static description = "Uploads one or more files to a file input element in the browser";
-  static cacheable = false;
-  static entitlements() {
-    return {
-      entitlements: [
-        { id: Entitlements4.FILESYSTEM_READ, reason: "Reads local files for upload to browser" }
-      ]
-    };
-  }
-  static configSchema() {
-    return browserUploadTaskConfigSchema;
-  }
-  static inputSchema() {
-    return inputSchema21;
-  }
-  static outputSchema() {
-    return outputSchema21;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    await ctx.uploadFile(input.ref, input.filePaths);
-    return { sessionId: input.sessionId };
-  }
-}
-// src/task/tasks/BrowserWaitTask.ts
-import { Task as Task22, TaskConfigSchema as TaskConfigSchema22 } from "@workglow/task-graph";
-var browserWaitTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema22["properties"],
-    waitFor: {
-      type: "string",
-      enum: ["navigation", "selector", "idle"],
-      title: "Wait For",
-      description: "The condition to wait for",
-      default: "idle"
-    },
-    selector: {
-      type: "string",
-      title: "Selector",
-      description: "CSS selector to wait for (required when waitFor is 'selector')"
-    },
-    timeout: {
-      type: "number",
-      title: "Timeout",
-      description: "Maximum time to wait in milliseconds",
-      default: 30000
-    }
-  },
-  additionalProperties: false
-};
-var inputSchema22 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-var outputSchema22 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-
-class BrowserWaitTask extends Task22 {
-  static type = "BrowserWaitTask";
-  static category = "Browser";
-  static title = "Browser Wait";
-  static description = "Waits for a navigation, selector, or network idle state in the browser";
-  static cacheable = false;
-  static configSchema() {
-    return browserWaitTaskConfigSchema;
-  }
-  static inputSchema() {
-    return inputSchema22;
-  }
-  static outputSchema() {
-    return outputSchema22;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    const waitFor = this.config.waitFor ?? "idle";
-    const timeout = this.config.timeout ?? 30000;
-    switch (waitFor) {
-      case "navigation":
-        await ctx.waitForNavigation({ timeout });
-        break;
-      case "selector": {
-        const selector = this.config.selector;
-        if (!selector) {
-          throw new Error("BrowserWaitTask: selector is required when waitFor is 'selector'");
-        }
-        await ctx.waitForSelector(selector, { timeout });
-        break;
-      }
-      case "idle":
-        await ctx.waitForIdle({ timeout });
-        break;
-    }
-    return { sessionId: input.sessionId };
-  }
-}
-// src/task/tasks/BrowserNewTabTask.ts
-import { Task as Task23, TaskConfigSchema as TaskConfigSchema23 } from "@workglow/task-graph";
-var browserNewTabTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema23["properties"]
-  },
-  additionalProperties: false
-};
-var inputSchema23 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    },
-    url: {
-      type: "string",
-      title: "URL",
-      description: "Optional URL to open in the new tab"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-var outputSchema23 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    },
-    tabId: {
-      type: "string",
-      title: "Tab ID",
-      description: "The unique identifier for the new tab"
-    }
-  },
-  required: ["sessionId", "tabId"],
-  additionalProperties: false
-};
-
-class BrowserNewTabTask extends Task23 {
-  static type = "BrowserNewTabTask";
-  static category = "Browser";
-  static title = "Browser New Tab";
-  static description = "Opens a new browser tab and returns its tab ID";
-  static cacheable = false;
-  static configSchema() {
-    return browserNewTabTaskConfigSchema;
-  }
-  static inputSchema() {
-    return inputSchema23;
-  }
-  static outputSchema() {
-    return outputSchema23;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    const tabInfo = await ctx.newTab(input.url);
-    return { sessionId: input.sessionId, tabId: tabInfo.tabId };
-  }
-}
-// src/task/tasks/BrowserSwitchTabTask.ts
-import { Task as Task24, TaskConfigSchema as TaskConfigSchema24 } from "@workglow/task-graph";
-var browserSwitchTabTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema24["properties"]
-  },
-  additionalProperties: false
-};
-var inputSchema24 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    },
-    tabId: {
-      type: "string",
-      title: "Tab ID",
-      description: "The tab ID to switch to"
-    }
-  },
-  required: ["sessionId", "tabId"],
-  additionalProperties: false
-};
-var outputSchema24 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-
-class BrowserSwitchTabTask extends Task24 {
-  static type = "BrowserSwitchTabTask";
-  static category = "Browser";
-  static title = "Browser Switch Tab";
-  static description = "Switches the active browser tab to the specified tab ID";
-  static cacheable = false;
-  static configSchema() {
-    return browserSwitchTabTaskConfigSchema;
-  }
-  static inputSchema() {
-    return inputSchema24;
-  }
-  static outputSchema() {
-    return outputSchema24;
-  }
-  async execute(input, _executeContext) {
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    await ctx.switchTab(input.tabId);
-    return { sessionId: input.sessionId };
-  }
-}
-// src/task/tasks/BrowserCloseTabTask.ts
-import { Task as Task25, TaskConfigSchema as TaskConfigSchema25 } from "@workglow/task-graph";
-var browserCloseTabTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema25["properties"],
-    tabId: {
-      type: "string",
-      title: "Tab ID",
-      description: "The tab ID to close (closes current tab if not provided)"
-    }
-  },
-  additionalProperties: false
-};
-var inputSchema25 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-var outputSchema25 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-
-class BrowserCloseTabTask extends Task25 {
-  static type = "BrowserCloseTabTask";
-  static category = "Browser";
-  static title = "Browser Close Tab";
-  static description = "Closes a browser tab by tab ID";
-  static cacheable = false;
-  static configSchema() {
-    return browserCloseTabTaskConfigSchema;
-  }
-  static inputSchema() {
-    return inputSchema25;
-  }
-  static outputSchema() {
-    return outputSchema25;
-  }
-  async execute(input, _executeContext) {
-    if (!this.config.tabId) {
-      throw new Error("BrowserCloseTabTask requires config.tabId");
-    }
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    await ctx.closeTab(this.config.tabId);
-    return { sessionId: input.sessionId };
-  }
-}
-// src/task/tasks/BrowserLoginTask.ts
-import {
-  Entitlements as Entitlements5,
-  mergeEntitlements as mergeEntitlements2,
-  Task as Task26,
-  TaskConfigSchema as TaskConfigSchema26
-} from "@workglow/task-graph";
-var browserLoginTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...TaskConfigSchema26["properties"],
-    mode: {
-      type: "string",
-      enum: ["manual", "credential", "ai"],
-      title: "Login Mode",
-      description: "The login strategy to use",
-      default: "manual"
-    },
-    credentialName: {
-      type: "string",
-      title: "Credential Name",
-      description: "Name of the stored credential to use (required when mode is 'credential')"
-    }
-  },
-  additionalProperties: false
-};
-var inputSchema26 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session to use"
-    },
-    url: {
-      type: "string",
-      format: "uri",
-      title: "URL",
-      description: "The login page URL to navigate to"
-    }
-  },
-  required: ["sessionId", "url"],
-  additionalProperties: false
-};
-var outputSchema26 = {
-  type: "object",
-  properties: {
-    sessionId: {
-      type: "string",
-      title: "Session ID",
-      description: "The browser session ID"
-    }
-  },
-  required: ["sessionId"],
-  additionalProperties: false
-};
-
-class BrowserLoginTask extends Task26 {
-  static type = "BrowserLoginTask";
-  static category = "Browser";
-  static title = "Browser Login";
-  static description = "Logs into a website using manual, credential, or AI-driven login strategies";
-  static cacheable = false;
-  static hasDynamicEntitlements = true;
-  static configSchema() {
-    return browserLoginTaskConfigSchema;
-  }
-  static inputSchema() {
-    return inputSchema26;
-  }
-  static outputSchema() {
-    return outputSchema26;
-  }
-  static entitlements() {
-    return {
-      entitlements: [
-        { id: Entitlements5.BROWSER_CONTROL_NAVIGATE, reason: "Navigates to the login page URL" }
-      ]
-    };
-  }
-  entitlements() {
-    const base = BrowserLoginTask.entitlements();
-    if (this.config.mode === "credential") {
-      return mergeEntitlements2(base, {
-        entitlements: [
-          {
-            id: Entitlements5.BROWSER_CONTROL_CREDENTIAL,
-            reason: "Accesses stored credentials for login"
-          }
-        ]
-      });
-    }
-    return base;
-  }
-  async execute(input, executeContext) {
-    const parsed = new URL(input.url, "https://placeholder");
-    if (parsed.protocol === "javascript:") {
-      throw new Error("BrowserLoginTask: javascript: URLs are not allowed");
-    }
-    const ctx = BrowserSessionRegistry.get(input.sessionId);
-    const mode = this.config.mode ?? "manual";
-    await ctx.navigate(input.url);
-    await executeContext.updateProgress(20, "Navigated to login page");
-    switch (mode) {
-      case "manual":
-        await executeContext.updateProgress(50, "Waiting for manual login...");
-        break;
-      case "credential":
-        throw new Error("Credential-based login mode is not yet implemented");
-      case "ai":
-        throw new Error("AI-driven login mode is not yet implemented");
-    }
-    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([]);
-  };
-}
-export {
-  registerBrowserDeps,
-  getBrowserDeps,
-  PlaywrightBackend,
-  ElectronBackend,
-  CDPBrowserBackend,
-  BunWebViewBackend,
-  BrowserWaitTask,
-  BrowserUploadTask,
-  BrowserTypeTask,
-  BrowserSwitchTabTask,
-  BrowserSnapshotTask,
-  BrowserSessionTask,
-  BrowserSessionRegistry,
-  BrowserSelectTask,
-  BrowserScrollTask,
-  BrowserScreenshotTask,
-  BrowserReloadTask,
-  BrowserQuerySelectorTask,
-  BrowserPressKeyTask,
-  BrowserNewTabTask,
-  BrowserNavigateTask,
-  BrowserLoginTask,
-  BrowserHoverTask,
-  BrowserForwardTask,
-  BrowserFillTask,
-  BrowserExtractTextTask,
-  BrowserExtractHtmlTask,
-  BrowserEvaluateTask,
-  BrowserCloseTask,
-  BrowserCloseTabTask,
-  BrowserClickTask,
-  BrowserBackTask,
-  BrowserAttributeTask,
-  BROWSER_CONTROL_TASK_DEPS
-};
-
-//# debugId=F0E5F00740A84F2364756E2164756E21