@workglow/browser-control 0.2.28

package/dist/task-electron.js

@@ -0,0 +1,3449 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/task/ElectronBackend.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/ElectronBackend.ts
+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 sleep(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 sleep(interval);
+    }
+    throw new Error("ElectronBackend: waitForIdle timed out");
+  }
+  networkRequests = (_filter) => {
+    return Promise.resolve([]);
+  };
+  consoleMessages = () => {
+    return Promise.resolve([]);
+  };
+}
+
+// src/task/PlaywrightBackend.ts
+var playwrightModule;
+async function getPlaywright() {
+  if (!playwrightModule) {
+    playwrightModule = await import("playwright");
+  }
+  return playwrightModule;
+}
+function parseAriaLine(line) {
+  const match = line.match(/^(\s*)-\s+(.*)$/);
+  if (!match)
+    return null;
+  const indent = match[1].length;
+  let rest = match[2].trim();
+  const hasChildren = rest.endsWith(":");
+  if (hasChildren)
+    rest = rest.slice(0, -1).trim();
+  const attrs = {};
+  rest = rest.replace(/\[([^\]]+)\]/g, (_m, attr) => {
+    const eqIdx = attr.indexOf("=");
+    if (eqIdx !== -1) {
+      attrs[attr.slice(0, eqIdx).trim()] = attr.slice(eqIdx + 1).trim();
+    } else {
+      attrs[attr.trim()] = "true";
+    }
+    return "";
+  }).trim();
+  const roleNameMatch = rest.match(/^(\S+)(?:\s+"((?:[^"\\]|\\.)*)")?/);
+  if (!roleNameMatch)
+    return null;
+  const role = roleNameMatch[1];
+  const name = roleNameMatch[2] !== undefined ? roleNameMatch[2].replace(/\\"/g, '"') : "";
+  return { indent, role, name, attrs, hasChildren };
+}
+function parseAriaYaml(yaml, refCounter, refMap) {
+  const lines = yaml.split(`
+`);
+  const stack = [];
+  let root = null;
+  for (const line of lines) {
+    if (!line.trim())
+      continue;
+    const parsed = parseAriaLine(line);
+    if (!parsed)
+      continue;
+    const ref = `e${++refCounter.count}`;
+    const locatorStr = buildLocatorString(parsed.role, parsed.name);
+    refMap.set(ref, locatorStr);
+    const node = {
+      ref,
+      role: parsed.role,
+      name: parsed.name
+    };
+    if (parsed.attrs.level !== undefined) {
+      node.level = parseInt(parsed.attrs.level, 10);
+    }
+    if (parsed.attrs.checked !== undefined) {
+      node.checked = parsed.attrs.checked === "mixed" ? "mixed" : parsed.attrs.checked === "true";
+    }
+    if (parsed.attrs.disabled !== undefined) {
+      node.disabled = parsed.attrs.disabled === "true";
+    }
+    if (parsed.attrs.expanded !== undefined) {
+      node.expanded = parsed.attrs.expanded === "true";
+    }
+    if (parsed.attrs.pressed !== undefined) {
+      node.pressed = parsed.attrs.pressed === "mixed" ? "mixed" : parsed.attrs.pressed === "true";
+    }
+    if (parsed.attrs.selected !== undefined) {
+      node.selected = parsed.attrs.selected === "true";
+    }
+    if (parsed.attrs.value !== undefined) {
+      const numVal = Number(parsed.attrs.value);
+      node.value = isNaN(numVal) ? parsed.attrs.value : numVal;
+    }
+    if (parsed.hasChildren) {
+      node.children = [];
+    }
+    while (stack.length > 0 && stack[stack.length - 1].indent >= parsed.indent) {
+      stack.pop();
+    }
+    if (stack.length === 0) {
+      root = node;
+    } else {
+      const parent = stack[stack.length - 1].node;
+      if (!parent.children)
+        parent.children = [];
+      parent.children.push(node);
+    }
+    stack.push({ node, indent: parsed.indent });
+  }
+  if (!root) {
+    const ref = `e${++refCounter.count}`;
+    refMap.set(ref, 'locator("body")');
+    return { ref, role: "document", name: "" };
+  }
+  return root;
+}
+function buildLocatorString(role, name) {
+  if (role === "text" || role === "StaticText") {
+    return `getByText:${name}`;
+  }
+  if (name) {
+    return `getByRole:${role}:${name}`;
+  }
+  return `getByRole:${role}:`;
+}
+
+class PlaywrightBackend {
+  sharedLocalBrowser;
+  constructor(sharedLocalBrowser) {
+    this.sharedLocalBrowser = sharedLocalBrowser;
+  }
+  _browser = null;
+  _context = null;
+  _page = null;
+  _connected = false;
+  _launchedLocalChromium = false;
+  _refMap = new Map;
+  _refCounter = { count: 0 };
+  _dialogHandler = null;
+  async connect(options = {}) {
+    const pw = await getPlaywright();
+    const { headless = true, cdpUrl, backend = "local" } = options;
+    if (backend === "cloud" || cdpUrl) {
+      if (this.sharedLocalBrowser) {
+        throw new Error("PlaywrightBackend: sharedLocalBrowser is only supported for local backend");
+      }
+      this._launchedLocalChromium = false;
+      if (!cdpUrl) {
+        throw new Error("PlaywrightBackend: cdpUrl is required for cloud backend");
+      }
+      this._browser = await pw.chromium.connectOverCDP(cdpUrl);
+      const contexts = this._browser.contexts();
+      this._context = contexts.length > 0 ? contexts[0] : await this._browser.newContext();
+      const pages = this._context.pages();
+      this._page = pages.length > 0 ? pages[0] : await this._context.newPage();
+    } else {
+      if (this.sharedLocalBrowser) {
+        this._browser = this.sharedLocalBrowser;
+        this._launchedLocalChromium = false;
+      } else {
+        this._launchedLocalChromium = true;
+        this._browser = await pw.chromium.launch({
+          headless,
+          args: ["--disable-dev-shm-usage"]
+        });
+      }
+      this._context = await this._browser.newContext();
+      this._page = await this._context.newPage();
+    }
+    this._page.on("dialog", async (dialog) => {
+      const info = {
+        type: dialog.type(),
+        message: dialog.message(),
+        defaultValue: dialog.defaultValue() ?? undefined
+      };
+      if (this._dialogHandler) {
+        const action = await this._dialogHandler(info);
+        if (action.accept) {
+          await dialog.accept("promptText" in action ? action.promptText : undefined);
+        } else {
+          await dialog.dismiss();
+        }
+      } else {
+        await dialog.dismiss();
+      }
+    });
+    this._connected = true;
+  }
+  async disconnect() {
+    this._connected = false;
+    const page = this._page;
+    const context = this._context;
+    const browser = this._browser;
+    const launchedLocal = this._launchedLocalChromium;
+    const sharedLocal = this.sharedLocalBrowser !== undefined;
+    this._page = null;
+    this._context = null;
+    this._browser = null;
+    this._launchedLocalChromium = false;
+    try {
+      if (launchedLocal || sharedLocal) {
+        if (page) {
+          try {
+            await page.close({ runBeforeUnload: false });
+          } catch {}
+        }
+        if (context) {
+          try {
+            await context.close();
+          } catch {}
+        }
+      }
+      if (browser && !sharedLocal) {
+        await browser.close();
+      }
+    } finally {
+      this._refMap.clear();
+      this._refCounter.count = 0;
+    }
+  }
+  isConnected() {
+    return this._connected;
+  }
+  get page() {
+    if (!this._page)
+      throw new Error("PlaywrightBackend: not connected — call connect() first");
+    return this._page;
+  }
+  get context() {
+    if (!this._context)
+      throw new Error("PlaywrightBackend: not connected — call connect() first");
+    return this._context;
+  }
+  resolveRef(ref) {
+    const descriptor = this._refMap.get(ref);
+    if (!descriptor) {
+      throw new Error(`PlaywrightBackend: unknown ref "${ref}"`);
+    }
+    return this.descriptorToLocator(descriptor);
+  }
+  descriptorToLocator(descriptor) {
+    const page = this.page;
+    if (descriptor.startsWith("getByRole:")) {
+      const rest = descriptor.slice("getByRole:".length);
+      const colonIdx = rest.indexOf(":");
+      const role = rest.slice(0, colonIdx);
+      const name = rest.slice(colonIdx + 1);
+      if (name) {
+        return page.getByRole(role, { name });
+      }
+      return page.getByRole(role);
+    }
+    if (descriptor.startsWith("getByText:")) {
+      const text = descriptor.slice("getByText:".length);
+      return page.getByText(text);
+    }
+    if (descriptor.startsWith("css:")) {
+      const selector = descriptor.slice("css:".length);
+      return page.locator(selector);
+    }
+    if (descriptor.startsWith("nth:")) {
+      const withoutPrefix = descriptor.slice("nth:".length);
+      const lastColon = withoutPrefix.lastIndexOf(":");
+      const inner = withoutPrefix.slice(0, lastColon);
+      const idx = parseInt(withoutPrefix.slice(lastColon + 1), 10);
+      return this.descriptorToLocator(inner).nth(idx);
+    }
+    return page.locator(descriptor);
+  }
+  async navigate(url, options = {}) {
+    const { waitUntil = "load", timeout = 30000 } = options;
+    await this.page.goto(url, { waitUntil, timeout });
+  }
+  async goBack(options = {}) {
+    const { waitUntil = "load", timeout = 30000 } = options;
+    await this.page.goBack({ waitUntil, timeout });
+  }
+  async goForward(options = {}) {
+    const { waitUntil = "load", timeout = 30000 } = options;
+    await this.page.goForward({ waitUntil, timeout });
+  }
+  async reload(options = {}) {
+    const { waitUntil = "load", timeout = 30000 } = options;
+    await this.page.reload({ waitUntil, timeout });
+  }
+  async currentUrl() {
+    return this.page.url();
+  }
+  async title() {
+    return this.page.title();
+  }
+  async snapshot(options = {}) {
+    let locator;
+    if (options.ref) {
+      locator = this.resolveRef(options.ref);
+    } else {
+      locator = this.page.locator("body");
+    }
+    const yaml = await locator.ariaSnapshot();
+    const root = parseAriaYaml(yaml, this._refCounter, this._refMap);
+    return { root, yaml };
+  }
+  async click(ref, options = {}) {
+    const locator = this.resolveRef(ref);
+    const { modifiers, button, clickCount, timeout } = options;
+    await locator.click({
+      ...modifiers !== undefined ? { modifiers } : {},
+      ...button !== undefined ? { button } : {},
+      ...clickCount !== undefined ? { clickCount } : {},
+      ...timeout !== undefined ? { timeout } : {}
+    });
+  }
+  async fill(ref, value, options = {}) {
+    const locator = this.resolveRef(ref);
+    const { timeout } = options;
+    await locator.fill(value, ...timeout !== undefined ? [{ timeout }] : []);
+  }
+  async selectOption(ref, values, options = {}) {
+    const locator = this.resolveRef(ref);
+    const { timeout } = options;
+    await locator.selectOption(values, ...timeout !== undefined ? [{ timeout }] : []);
+  }
+  async hover(ref, options = {}) {
+    const locator = this.resolveRef(ref);
+    const { timeout } = options;
+    await locator.hover(...timeout !== undefined ? [{ timeout }] : []);
+  }
+  async clickByRole(role, name, options = {}) {
+    const { modifiers, button, clickCount, timeout } = options;
+    await this.page.getByRole(role, { name }).click({
+      ...modifiers !== undefined ? { modifiers } : {},
+      ...button !== undefined ? { button } : {},
+      ...clickCount !== undefined ? { clickCount } : {},
+      ...timeout !== undefined ? { timeout } : {}
+    });
+  }
+  async fillByLabel(label, value, options = {}) {
+    const { timeout } = options;
+    await this.page.getByLabel(label).fill(value, ...timeout !== undefined ? [{ timeout }] : []);
+  }
+  async content() {
+    return this.page.content();
+  }
+  async innerHTML(ref) {
+    const locator = this.resolveRef(ref);
+    return locator.innerHTML();
+  }
+  async textContent(ref) {
+    const locator = this.resolveRef(ref);
+    return locator.textContent();
+  }
+  async attribute(ref, name) {
+    const locator = this.resolveRef(ref);
+    return locator.getAttribute(name);
+  }
+  async querySelector(selector) {
+    const locator = this.page.locator(selector);
+    const count = await locator.count();
+    if (count === 0)
+      return null;
+    const ref = `e${++this._refCounter.count}`;
+    this._refMap.set(ref, `css:${selector}`);
+    return ref;
+  }
+  async querySelectorAll(selector) {
+    const locator = this.page.locator(selector);
+    const count = await locator.count();
+    const refs = [];
+    for (let i = 0;i < count; i++) {
+      const ref = `e${++this._refCounter.count}`;
+      this._refMap.set(ref, `nth:css:${selector}:${i}`);
+      refs.push(ref);
+    }
+    return refs;
+  }
+  async evaluate(expression) {
+    return this.page.evaluate(expression);
+  }
+  async screenshot(options = {}) {
+    const { format = "png", quality, fullPage = false } = options;
+    const screenshotOptions = {
+      type: format,
+      fullPage
+    };
+    if (format === "jpeg" && quality !== undefined) {
+      screenshotOptions.quality = quality;
+    }
+    return this.page.screenshot(screenshotOptions);
+  }
+  async pressKey(key, _options = {}) {
+    await this.page.keyboard.press(key);
+  }
+  async type(text, _options = {}) {
+    await this.page.keyboard.type(text);
+  }
+  async scroll(x, y, ref) {
+    if (ref) {
+      const locator = this.resolveRef(ref);
+      await locator.evaluate((el, args) => {
+        el.scrollBy(args.x, args.y);
+      }, { x, y });
+    } else {
+      await this.page.mouse.wheel(x, y);
+    }
+  }
+  async uploadFile(ref, paths) {
+    const locator = this.resolveRef(ref);
+    await locator.setInputFiles(paths);
+  }
+  async download(trigger, options = {}) {
+    const { timeout } = options;
+    const [download] = await Promise.all([
+      this.page.waitForEvent("download", ...timeout !== undefined ? [{ timeout }] : []),
+      trigger()
+    ]);
+    const path = await download.path();
+    const suggestedFilename = download.suggestedFilename();
+    if (!path) {
+      throw new Error("PlaywrightBackend: download failed — path is null");
+    }
+    return { path, suggestedFilename };
+  }
+  onDialog(handler) {
+    this._dialogHandler = handler;
+  }
+  async tabs() {
+    const pages = this.context.pages();
+    return Promise.all(pages.map(async (p, idx) => ({
+      tabId: String(idx),
+      url: p.url(),
+      title: await p.title()
+    })));
+  }
+  async switchTab(tabId) {
+    const pages = this.context.pages();
+    const idx = parseInt(tabId, 10);
+    if (isNaN(idx) || idx < 0 || idx >= pages.length) {
+      throw new Error(`PlaywrightBackend: no tab with id "${tabId}"`);
+    }
+    this._page = pages[idx];
+    await this._page.bringToFront();
+  }
+  async newTab(url) {
+    const newPage = await this.context.newPage();
+    if (url) {
+      await newPage.goto(url, { waitUntil: "load" });
+    }
+    const pages = this.context.pages();
+    const idx = pages.indexOf(newPage);
+    const tabId = String(idx >= 0 ? idx : pages.length - 1);
+    return {
+      tabId,
+      url: newPage.url(),
+      title: await newPage.title()
+    };
+  }
+  async closeTab(tabId) {
+    const pages = this.context.pages();
+    const idx = parseInt(tabId, 10);
+    if (isNaN(idx) || idx < 0 || idx >= pages.length) {
+      throw new Error(`PlaywrightBackend: no tab with id "${tabId}"`);
+    }
+    const target = pages[idx];
+    await target.close();
+    if (this._page === target) {
+      const remaining = this.context.pages();
+      this._page = remaining.length > 0 ? remaining[remaining.length - 1] : null;
+    }
+  }
+  async waitForNavigation(options = {}) {
+    const { timeout } = options;
+    await this.page.waitForLoadState("load", ...timeout !== undefined ? [{ timeout }] : []);
+  }
+  async waitForSelector(selector, options = {}) {
+    const { timeout } = options;
+    await this.page.waitForSelector(selector, ...timeout !== undefined ? [{ timeout }] : []);
+    const ref = `e${++this._refCounter.count}`;
+    this._refMap.set(ref, `css:${selector}`);
+    return ref;
+  }
+  async waitForIdle(options = {}) {
+    const { timeout } = options;
+    await this.page.waitForLoadState("networkidle", ...timeout !== undefined ? [{ timeout }] : []);
+  }
+  networkRequests = (_filter) => {
+    return Promise.resolve([]);
+  };
+  consoleMessages = () => {
+    return Promise.resolve([]);
+  };
+}
+
+// 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.electron.ts
+registerBrowserDeps({
+  createContext: (options) => {
+    if (options.backend === "local") {
+      return new PlaywrightBackend;
+    }
+    return new ElectronBackend;
+  },
+  availableBackends: ["electron-native", "local"],
+  defaultBackend: "electron-native",
+  profileStorage: {
+    async save(_projectId, _profileName, _state) {},
+    async load(_projectId, _profileName) {
+      return null;
+    },
+    async delete(_projectId, _profileName) {}
+  }
+});
+
+// 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 as sleep2 } from "@workglow/util";
+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 sleep2(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 sleep2(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 };
+  }
+}
+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=479D8BD17839E5C064756E2164756E21