lobster-cli 0.1.0

package/dist/router/index.js

@@ -0,0 +1,3443 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/types/router.ts
+var ExecutionLevel = /* @__PURE__ */ ((ExecutionLevel2) => {
+  ExecutionLevel2[ExecutionLevel2["HTTP"] = 0] = "HTTP";
+  ExecutionLevel2[ExecutionLevel2["BROWSER"] = 1] = "BROWSER";
+  ExecutionLevel2[ExecutionLevel2["ADAPTER"] = 2] = "ADAPTER";
+  ExecutionLevel2[ExecutionLevel2["AGENT"] = 3] = "AGENT";
+  return ExecutionLevel2;
+})(ExecutionLevel || {});
+
+// src/adapter/registry.ts
+var REGISTRY_KEY = "__lobster_registry__";
+if (!globalThis[REGISTRY_KEY]) {
+  globalThis[REGISTRY_KEY] = /* @__PURE__ */ new Map();
+}
+function getRegistry() {
+  return globalThis[REGISTRY_KEY];
+}
+function getAdapter(site, name) {
+  return getRegistry().get(`${site}/${name}`);
+}
+function getAdapterByDomain(domain) {
+  const adapters = [];
+  for (const adapter of getRegistry().values()) {
+    if (adapter.domain && domain.includes(adapter.domain)) adapters.push(adapter);
+  }
+  return adapters;
+}
+
+// src/router/decision.ts
+function makeRoutingDecision(request) {
+  if (request.site && request.command) {
+    const adapter = getAdapter(request.site, request.command);
+    if (adapter) {
+      return {
+        level: 2 /* ADAPTER */,
+        reason: `Matched adapter: ${request.site}/${request.command}`,
+        adapter
+      };
+    }
+  }
+  if (request.url) {
+    try {
+      const domain = new URL(request.url).hostname;
+      const adapters = getAdapterByDomain(domain);
+      if (adapters.length > 0) {
+        return {
+          level: 2 /* ADAPTER */,
+          reason: `Found adapter for domain: ${domain}`,
+          adapter: adapters[0]
+        };
+      }
+    } catch {
+    }
+  }
+  if (request.url && !request.task) {
+    return {
+      level: 0 /* HTTP */,
+      reason: "Direct URL fetch (no task specified)"
+    };
+  }
+  if (request.url) {
+    const url = request.url;
+    if (url.endsWith(".json") || url.includes("/api/") || url.includes("/v1/") || url.includes("/v2/")) {
+      return {
+        level: 0 /* HTTP */,
+        reason: "URL appears to be an API endpoint"
+      };
+    }
+  }
+  if (request.task) {
+    const taskLower = request.task.toLowerCase();
+    const interactionWords = ["click", "scroll", "fill", "type", "login", "sign in", "search", "navigate", "find", "extract", "get"];
+    const needsInteraction = interactionWords.some((w) => taskLower.includes(w));
+    if (needsInteraction || request.url) {
+      return {
+        level: 3 /* AGENT */,
+        reason: "Task requires web interaction"
+      };
+    }
+  }
+  return {
+    level: 3 /* AGENT */,
+    reason: "Defaulting to AI agent for unrecognized task"
+  };
+}
+
+// src/http/index.ts
+async function directFetch(url, options) {
+  const controller = new AbortController();
+  const timeout = options?.timeout || 3e4;
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const resp = await fetch(url, {
+      method: options?.method || "GET",
+      headers: options?.headers,
+      signal: controller.signal,
+      redirect: "follow"
+    });
+    const contentType = resp.headers.get("content-type") || "";
+    const headers = {};
+    resp.headers.forEach((v, k) => {
+      headers[k] = v;
+    });
+    let body;
+    if (contentType.includes("json")) {
+      body = await resp.json();
+    } else {
+      body = await resp.text();
+    }
+    return { url, status: resp.status, headers, body, contentType };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/browser/manager.ts
+import puppeteer from "puppeteer-core";
+import { existsSync } from "fs";
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var log = {
+  info: (msg) => console.log(chalk.blue("\u2139"), msg),
+  success: (msg) => console.log(chalk.green("\u2713"), msg),
+  warn: (msg) => console.log(chalk.yellow("\u26A0"), msg),
+  error: (msg) => console.error(chalk.red("\u2717"), msg),
+  debug: (msg) => {
+    if (process.env.LOBSTER_DEBUG) console.log(chalk.gray("\u22EF"), msg);
+  },
+  step: (n, msg) => console.log(chalk.cyan(`[${n}]`), msg),
+  dim: (msg) => console.log(chalk.dim(msg))
+};
+
+// src/browser/manager.ts
+var BrowserManager = class {
+  browser = null;
+  config;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  async connect() {
+    if (this.browser?.connected) return this.browser;
+    if (this.config.cdpEndpoint) {
+      log.debug(`Connecting to CDP endpoint: ${this.config.cdpEndpoint}`);
+      this.browser = await puppeteer.connect({
+        browserWSEndpoint: this.config.cdpEndpoint
+      });
+      return this.browser;
+    }
+    const executablePath = this.config.executablePath || findChrome();
+    if (!executablePath) {
+      throw new Error(
+        "Chrome/Chromium not found. Set LOBSTER_BROWSER_PATH or config browser.executablePath"
+      );
+    }
+    log.debug(`Launching Chrome: ${executablePath}`);
+    this.browser = await puppeteer.launch({
+      executablePath,
+      headless: this.config.headless ?? true,
+      args: [
+        "--no-sandbox",
+        "--disable-setuid-sandbox",
+        "--disable-dev-shm-usage",
+        "--disable-gpu"
+      ]
+    });
+    return this.browser;
+  }
+  async newPage() {
+    const browser = await this.connect();
+    return browser.newPage();
+  }
+  async close() {
+    if (this.browser) {
+      await this.browser.close().catch(() => {
+      });
+      this.browser = null;
+    }
+  }
+};
+function findChrome() {
+  const paths = process.platform === "darwin" ? [
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary"
+  ] : process.platform === "win32" ? [
+    "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+    "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe"
+  ] : [
+    "/usr/bin/google-chrome",
+    "/usr/bin/google-chrome-stable",
+    "/usr/bin/chromium-browser",
+    "/usr/bin/chromium",
+    "/snap/bin/chromium"
+  ];
+  return paths.find((p) => existsSync(p));
+}
+
+// src/browser/dom/flat-tree.ts
+var FLAT_TREE_SCRIPT = `
+(() => {
+  const INTERACTIVE_TAGS = new Set([
+    'a', 'button', 'input', 'select', 'textarea', 'details', 'summary',
+    'label', 'option', 'fieldset', 'legend',
+  ]);
+
+  const INTERACTIVE_ROLES = new Set([
+    'button', 'link', 'textbox', 'checkbox', 'radio', 'combobox',
+    'listbox', 'menu', 'menuitem', 'tab', 'switch', 'slider',
+    'searchbox', 'spinbutton', 'option', 'menuitemcheckbox', 'menuitemradio',
+  ]);
+
+  const ATTR_WHITELIST = [
+    'type', 'role', 'aria-label', 'aria-expanded', 'aria-selected',
+    'aria-checked', 'aria-disabled', 'placeholder', 'title', 'href',
+    'value', 'name', 'alt', 'src',
+  ];
+
+  let highlightIndex = 0;
+  const nodes = {};
+  const selectorMap = {};
+
+  function isVisible(el) {
+    if (el.offsetWidth === 0 && el.offsetHeight === 0) return false;
+    const style = getComputedStyle(el);
+    if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return false;
+    return true;
+  }
+
+  function isInteractive(el) {
+    const tag = el.tagName.toLowerCase();
+    if (INTERACTIVE_TAGS.has(tag)) return true;
+    const role = el.getAttribute('role');
+    if (role && INTERACTIVE_ROLES.has(role)) return true;
+    if (el.getAttribute('contenteditable') === 'true') return true;
+    if (el.getAttribute('tabindex') !== null && parseInt(el.getAttribute('tabindex')) >= 0) return true;
+    if (el.onclick || el.getAttribute('onclick')) return true;
+    return false;
+  }
+
+  function getAttributes(el) {
+    const attrs = {};
+    for (const attr of ATTR_WHITELIST) {
+      const val = el.getAttribute(attr);
+      if (val !== null && val !== '') attrs[attr] = val;
+    }
+    return attrs;
+  }
+
+  function getScrollable(el) {
+    const style = getComputedStyle(el);
+    const overflowY = style.overflowY;
+    const overflowX = style.overflowX;
+    const isScrollableY = (overflowY === 'auto' || overflowY === 'scroll') && el.scrollHeight > el.clientHeight;
+    const isScrollableX = (overflowX === 'auto' || overflowX === 'scroll') && el.scrollWidth > el.clientWidth;
+    if (!isScrollableY && !isScrollableX) return null;
+    return {
+      left: el.scrollLeft,
+      top: el.scrollTop,
+      right: el.scrollWidth - el.clientWidth - el.scrollLeft,
+      bottom: el.scrollHeight - el.clientHeight - el.scrollTop,
+    };
+  }
+
+  function walk(el, parentId) {
+    if (!el || el.nodeType === 8) return; // skip comments
+
+    if (el.nodeType === 3) { // text node
+      const text = el.textContent.trim();
+      if (!text) return;
+      const id = 'text_' + Math.random().toString(36).slice(2, 8);
+      nodes[id] = { id, tagName: '#text', text, parentId };
+      if (parentId && nodes[parentId]) {
+        nodes[parentId].children = nodes[parentId].children || [];
+        nodes[parentId].children.push(id);
+      }
+      return;
+    }
+
+    if (el.nodeType !== 1) return; // only elements
+
+    const tag = el.tagName.toLowerCase();
+    if (['script', 'style', 'noscript', 'svg', 'path'].includes(tag)) return;
+    if (!isVisible(el)) return;
+
+    const id = tag + '_' + Math.random().toString(36).slice(2, 8);
+    const interactive = isInteractive(el);
+    const node = {
+      id,
+      tagName: tag,
+      attributes: getAttributes(el),
+      parentId,
+      children: [],
+      isInteractive: interactive,
+    };
+
+    if (interactive) {
+      node.highlightIndex = highlightIndex;
+      selectorMap[highlightIndex] = id;
+      highlightIndex++;
+    }
+
+    const scrollable = getScrollable(el);
+    if (scrollable) node.scrollable = scrollable;
+
+    const text = [];
+    for (const child of el.childNodes) {
+      if (child.nodeType === 3 && child.textContent.trim()) {
+        text.push(child.textContent.trim());
+      }
+    }
+    if (text.length > 0) node.text = text.join(' ').slice(0, 200);
+
+    nodes[id] = node;
+
+    if (parentId && nodes[parentId]) {
+      nodes[parentId].children.push(id);
+    }
+
+    for (const child of el.children) {
+      walk(child, id);
+    }
+  }
+
+  const rootId = 'root';
+  nodes[rootId] = { id: rootId, tagName: 'body', children: [], attributes: {} };
+  for (const child of document.body.children) {
+    walk(child, rootId);
+  }
+
+  return { rootId, map: nodes, selectorMap };
+})()
+`;
+function flatTreeToString(tree) {
+  const lines = [];
+  function walk(nodeId, depth) {
+    const node = tree.map[nodeId];
+    if (!node) return;
+    const indent = "	".repeat(depth);
+    if (node.tagName === "#text") {
+      if (node.text) lines.push(`${indent}${node.text}`);
+      return;
+    }
+    const attrs = node.attributes || {};
+    const attrStr = Object.entries(attrs).map(([k, v]) => v === "" ? k : `${k}="${v}"`).join(" ");
+    const prefix = node.highlightIndex !== void 0 ? `[${node.highlightIndex}]` : "";
+    const scrollInfo = node.scrollable ? ` |scroll: ${Math.round(node.scrollable.top)}px up, ${Math.round(node.scrollable.bottom)}px down|` : "";
+    const text = node.text || "";
+    const tag = node.tagName;
+    if (prefix || text || node.children?.length > 0) {
+      const opening = `${indent}${prefix}<${tag}${attrStr ? " " + attrStr : ""}${scrollInfo}>`;
+      if (!node.children?.length || node.children.length === 0 && text) {
+        lines.push(`${opening}${text}</>`);
+      } else {
+        lines.push(`${opening}${text}`);
+        for (const childId of node.children || []) {
+          walk(childId, depth + 1);
+        }
+      }
+    } else {
+      for (const childId of node.children || []) {
+        walk(childId, depth);
+      }
+    }
+  }
+  walk(tree.rootId, 0);
+  return lines.join("\n");
+}
+
+// src/browser/dom/snapshot.ts
+var SNAPSHOT_SCRIPT = `
+(() => {
+  let idx = 0;
+  const __prevHashes = (window.__lobster_prev_hashes) ? new Set(window.__lobster_prev_hashes) : null;
+  const __currentHashes = [];
+
+  const SKIP_TAGS = new Set([
+    'script','style','noscript','svg','path','meta','link','head',
+    'template','slot','colgroup','col',
+  ]);
+
+  const INTERACTIVE_TAGS = new Set([
+    'a','button','input','select','textarea','details','summary','label',
+  ]);
+
+  const INTERACTIVE_ROLES = new Set([
+    'button','link','textbox','checkbox','radio','combobox','listbox',
+    'menu','menuitem','tab','switch','slider','searchbox','spinbutton',
+    'option','menuitemcheckbox','menuitemradio','treeitem',
+  ]);
+
+  const ATTR_WHITELIST = [
+    'type','role','aria-label','aria-expanded','aria-selected','aria-checked',
+    'aria-disabled','aria-haspopup','aria-pressed','placeholder','title',
+    'href','value','name','alt','src','action','method','for',
+    'data-testid','data-id','contenteditable','tabindex',
+  ];
+
+  const AD_PATTERNS = /ad[-_]?banner|ad[-_]?container|google[-_]?ad|doubleclick|adsbygoogle|sponsored|^ad$/i;
+
+  // \u2500\u2500 Stage 1: Visibility check \u2500\u2500
+  function isVisible(el) {
+    if (el.offsetWidth === 0 && el.offsetHeight === 0 && el.tagName !== 'INPUT') return false;
+    const s = getComputedStyle(el);
+    if (s.display === 'none') return false;
+    if (s.visibility === 'hidden' || s.visibility === 'collapse') return false;
+    if (s.opacity === '0') return false;
+    if (s.clipPath === 'inset(100%)') return false;
+    // Check for offscreen positioning
+    const rect = el.getBoundingClientRect();
+    if (rect.right < 0 || rect.bottom < 0) return false;
+    return true;
+  }
+
+  // \u2500\u2500 Stage 2: Interactive detection \u2500\u2500
+  function isInteractive(el) {
+    const tag = el.tagName.toLowerCase();
+    if (INTERACTIVE_TAGS.has(tag)) {
+      // Skip disabled elements
+      if (el.disabled) return false;
+      // Skip hidden inputs
+      if (tag === 'input' && el.type === 'hidden') return false;
+      return true;
+    }
+    const role = el.getAttribute('role');
+    if (role && INTERACTIVE_ROLES.has(role)) return true;
+    if (el.contentEditable === 'true') return true;
+    if (el.tabIndex >= 0 && el.getAttribute('tabindex') !== null) return true;
+    if (el.onclick) return true;
+    return false;
+  }
+
+  // \u2500\u2500 Stage 8: Attribute filtering \u2500\u2500
+  function getAttrs(el) {
+    const parts = [];
+    for (const name of ATTR_WHITELIST) {
+      let v = el.getAttribute(name);
+      if (v === null || v === '') continue;
+      // Truncate long values
+      if (v.length > 80) v = v.slice(0, 77) + '...';
+      // Skip href="javascript:..."
+      if (name === 'href' && v.startsWith('javascript:')) continue;
+      parts.push(name + '=' + v);
+    }
+    return parts.length ? ' ' + parts.join(' ') : '';
+  }
+
+  // \u2500\u2500 Stage 9: Ad filtering \u2500\u2500
+  function isAd(el) {
+    const id = el.id || '';
+    const cls = el.className || '';
+    if (typeof cls === 'string' && AD_PATTERNS.test(cls)) return true;
+    if (AD_PATTERNS.test(id)) return true;
+    if (el.tagName === 'IFRAME' && AD_PATTERNS.test(el.src || '')) return true;
+    return false;
+  }
+
+  // \u2500\u2500 Stage 10: Scroll info \u2500\u2500
+  function getScrollInfo(el) {
+    const s = getComputedStyle(el);
+    const overflowY = s.overflowY;
+    const overflowX = s.overflowX;
+    const scrollableY = (overflowY === 'auto' || overflowY === 'scroll') && el.scrollHeight > el.clientHeight;
+    const scrollableX = (overflowX === 'auto' || overflowX === 'scroll') && el.scrollWidth > el.clientWidth;
+    if (!scrollableY && !scrollableX) return '';
+
+    const parts = [];
+    if (scrollableY) {
+      const up = Math.round(el.scrollTop);
+      const down = Math.round(el.scrollHeight - el.clientHeight - el.scrollTop);
+      if (up > 0) parts.push(up + 'px up');
+      if (down > 0) parts.push(down + 'px down');
+    }
+    if (scrollableX) {
+      const left = Math.round(el.scrollLeft);
+      const right = Math.round(el.scrollWidth - el.clientWidth - el.scrollLeft);
+      if (left > 0) parts.push(left + 'px left');
+      if (right > 0) parts.push(right + 'px right');
+    }
+    return parts.length ? ' |scroll: ' + parts.join(', ') + '|' : '';
+  }
+
+  // \u2500\u2500 Stage 6: Bounding-box dedup \u2500\u2500
+  // If a parent and child are both interactive and have ~same bounding box,
+  // skip the parent (e.g., <a><button>Click</button></a>)
+  function isWrappingInteractive(el) {
+    if (!isInteractive(el)) return false;
+    const rect = el.getBoundingClientRect();
+    if (rect.width === 0 || rect.height === 0) return false;
+    for (const child of el.children) {
+      if (!isInteractive(child)) continue;
+      const cr = child.getBoundingClientRect();
+      const overlapX = Math.min(rect.right, cr.right) - Math.max(rect.left, cr.left);
+      const overlapY = Math.min(rect.bottom, cr.bottom) - Math.max(rect.top, cr.top);
+      const overlapArea = Math.max(0, overlapX) * Math.max(0, overlapY);
+      const parentArea = rect.width * rect.height;
+      if (parentArea > 0 && overlapArea / parentArea > 0.85) return true;
+    }
+    return false;
+  }
+
+  // \u2500\u2500 Stage 7: Occlusion detection \u2500\u2500
+  function isOccluded(el) {
+    const rect = el.getBoundingClientRect();
+    if (rect.width === 0 || rect.height === 0) return false;
+    const cx = rect.left + rect.width / 2;
+    const cy = rect.top + rect.height / 2;
+    const topEl = document.elementFromPoint(cx, cy);
+    if (!topEl) return false;
+    if (topEl === el || el.contains(topEl) || topEl.contains(el)) return false;
+    // Check z-index \u2014 if top element is a modal/overlay, mark as occluded
+    const topZ = parseInt(getComputedStyle(topEl).zIndex) || 0;
+    const elZ = parseInt(getComputedStyle(el).zIndex) || 0;
+    return topZ > elZ + 10;
+  }
+
+  // \u2500\u2500 Stage 5: Iframe content extraction \u2500\u2500
+  function getIframeContent(iframe, depth, maxDepth) {
+    try {
+      const doc = iframe.contentDocument;
+      if (!doc || !doc.body) return '';
+      return '\\n' + walkNode(doc.body, depth, maxDepth);
+    } catch { return ''; }
+  }
+
+  // \u2500\u2500 Stage 4: Shadow DOM traversal \u2500\u2500
+  function getShadowContent(el, depth, maxDepth) {
+    if (!el.shadowRoot) return '';
+    let out = '';
+    for (const child of el.shadowRoot.childNodes) {
+      out += walkNode(child, depth, maxDepth);
+    }
+    return out;
+  }
+
+  // \u2500\u2500 Input value hint \u2500\u2500
+  function getInputHint(el) {
+    const tag = el.tagName.toLowerCase();
+    if (tag === 'input') {
+      const type = el.type || 'text';
+      const val = el.value || '';
+      const checked = el.checked;
+      if (type === 'checkbox' || type === 'radio') {
+        return checked ? ' [checked]' : ' [unchecked]';
+      }
+      if (val) return ' value="' + val.slice(0, 50) + '"';
+    }
+    if (tag === 'textarea' && el.value) {
+      return ' value="' + el.value.slice(0, 50) + '"';
+    }
+    if (tag === 'select' && el.selectedOptions?.length) {
+      return ' selected="' + el.selectedOptions[0].text.slice(0, 40) + '"';
+    }
+    return '';
+  }
+
+  const MAX_DEPTH = 25;
+  const MAX_TEXT = 150;
+
+  function walkNode(node, depth, maxDepth) {
+    if (depth > maxDepth) return '';
+    if (!node) return '';
+
+    // Text node
+    if (node.nodeType === 3) {
+      const t = node.textContent.trim();
+      if (!t) return '';
+      const text = t.length > MAX_TEXT ? t.slice(0, MAX_TEXT) + '...' : t;
+      return '  '.repeat(depth) + text + '\\n';
+    }
+
+    // Comment node \u2014 skip
+    if (node.nodeType === 8) return '';
+
+    // Only element nodes from here
+    if (node.nodeType !== 1) return '';
+
+    const el = node;
+    const tag = el.tagName.toLowerCase();
+
+    // \u2500\u2500 Stage 3: Skip tags \u2500\u2500
+    if (SKIP_TAGS.has(tag)) return '';
+
+    // \u2500\u2500 Stage 2: Visibility \u2500\u2500
+    if (!isVisible(el)) return '';
+
+    // \u2500\u2500 Stage 9: Ad filtering \u2500\u2500
+    if (isAd(el)) return '';
+
+    // \u2500\u2500 Stage 6: Bbox dedup \u2014 skip wrapping interactive parent \u2500\u2500
+    const skipSelf = isWrappingInteractive(el);
+
+    const indent = '  '.repeat(depth);
+    const inter = !skipSelf && isInteractive(el);
+    let prefix = '';
+    if (inter) {
+      const thisIdx = idx++;
+      // Hash: tag + text + key attributes for diff tracking
+      const hashText = tag + ':' + (el.textContent || '').trim().slice(0, 40) + ':' + (el.getAttribute('href') || '') + ':' + (el.getAttribute('aria-label') || '');
+      __currentHashes.push(hashText);
+      const isNew = __prevHashes && __prevHashes.size > 0 && !__prevHashes.has(hashText);
+      prefix = isNew ? '*[' + thisIdx + ']' : '[' + thisIdx + ']';
+    }
+
+    // \u2500\u2500 Stage 11: Annotate with data-ref \u2500\u2500
+    if (inter) {
+      try { el.dataset.ref = String(idx - 1); } catch {}
+    }
+
+    // \u2500\u2500 Stage 7: Occlusion check for interactive elements \u2500\u2500
+    if (inter && isOccluded(el)) {
+      // Still include but mark as occluded
+      // (agent needs to know element exists but may need to scroll/close modal)
+    }
+
+    const a = getAttrs(el);
+    const scrollInfo = getScrollInfo(el);
+    const inputHint = inter ? getInputHint(el) : '';
+
+    // Leaf text extraction
+    let leafText = '';
+    if (el.childNodes.length === 1 && el.childNodes[0].nodeType === 3) {
+      const t = el.childNodes[0].textContent.trim();
+      if (t) leafText = t.length > MAX_TEXT ? t.slice(0, MAX_TEXT) + '...' : t;
+    }
+
+    // \u2500\u2500 Stage 5: Iframe \u2500\u2500
+    if (tag === 'iframe') {
+      const iframeContent = getIframeContent(el, depth + 1, maxDepth);
+      if (iframeContent) {
+        return indent + prefix + '<iframe' + a + '>\\n' + iframeContent;
+      }
+      return '';
+    }
+
+    // Build output
+    let out = '';
+
+    if (skipSelf) {
+      // Skip self but render children
+      for (const c of el.childNodes) out += walkNode(c, depth, maxDepth);
+      out += getShadowContent(el, depth, maxDepth);
+      return out;
+    }
+
+    if (inter || leafText || el.children.length === 0) {
+      if (leafText) {
+        out = indent + prefix + '<' + tag + a + scrollInfo + inputHint + '>' + leafText + '</' + tag + '>\\n';
+      } else {
+        out = indent + prefix + '<' + tag + a + scrollInfo + inputHint + '>\\n';
+        for (const c of el.childNodes) out += walkNode(c, depth + 1, maxDepth);
+        out += getShadowContent(el, depth + 1, maxDepth);
+      }
+    } else {
+      // Non-interactive container \u2014 flatten depth if no useful info
+      if (scrollInfo) {
+        out = indent + '<' + tag + scrollInfo + '>\\n';
+        for (const c of el.childNodes) out += walkNode(c, depth + 1, maxDepth);
+        out += getShadowContent(el, depth + 1, maxDepth);
+      } else {
+        for (const c of el.childNodes) out += walkNode(c, depth, maxDepth);
+        out += getShadowContent(el, depth, maxDepth);
+      }
+    }
+
+    return out;
+  }
+
+  // \u2500\u2500 Page-level scroll info header \u2500\u2500
+  const scrollY = window.scrollY;
+  const scrollMax = document.documentElement.scrollHeight - window.innerHeight;
+  const scrollPct = scrollMax > 0 ? Math.round((scrollY / scrollMax) * 100) : 0;
+  const vpW = window.innerWidth;
+  const vpH = window.innerHeight;
+  const pageH = document.documentElement.scrollHeight;
+
+  let header = '';
+  header += 'viewport: ' + vpW + 'x' + vpH + ' | page_height: ' + pageH + 'px';
+  header += ' | scroll: ' + scrollPct + '%';
+  if (scrollY > 50) header += ' (' + Math.round(scrollY) + 'px from top)';
+  if (scrollMax - scrollY > 50) header += ' (' + Math.round(scrollMax - scrollY) + 'px more below)';
+  header += '\\n---\\n';
+
+  // Store current hashes for next diff comparison
+  window.__lobster_prev_hashes = __currentHashes;
+
+  return header + walkNode(document.body, 0, MAX_DEPTH);
+})()
+`;
+
+// src/browser/dom/semantic-tree.ts
+var SEMANTIC_TREE_SCRIPT = `
+(() => {
+  const SKIP = new Set(['script','style','noscript','svg','head','meta','link','template']);
+
+  const ROLE_MAP = {
+    a: 'link', button: 'button', input: 'textbox', select: 'combobox',
+    textarea: 'textbox', h1: 'heading', h2: 'heading', h3: 'heading',
+    h4: 'heading', h5: 'heading', h6: 'heading', nav: 'navigation',
+    main: 'main', header: 'banner', footer: 'contentinfo', aside: 'complementary',
+    form: 'form', table: 'table', img: 'img', ul: 'list', ol: 'list', li: 'listitem',
+    section: 'region', article: 'article', dialog: 'dialog', details: 'group',
+    summary: 'button', progress: 'progressbar', meter: 'meter', output: 'status',
+    label: 'label', legend: 'legend', fieldset: 'group', option: 'option',
+    tr: 'row', td: 'cell', th: 'columnheader', caption: 'caption',
+  };
+
+  const INTERACTIVE_ROLES = new Set([
+    'button','link','textbox','checkbox','radio','combobox','listbox',
+    'menu','menuitem','tab','switch','slider','searchbox','spinbutton',
+    'option','menuitemcheckbox','menuitemradio','treeitem',
+  ]);
+
+  // \u2500\u2500 W3C Accessible Name Algorithm (simplified) \u2500\u2500
+  function getAccessibleName(el) {
+    // 1. aria-labelledby (highest priority)
+    const labelledBy = el.getAttribute('aria-labelledby');
+    if (labelledBy) {
+      const ids = labelledBy.split(/\\s+/);
+      const parts = ids.map(id => {
+        const ref = document.getElementById(id);
+        return ref ? ref.textContent.trim() : '';
+      }).filter(Boolean);
+      if (parts.length > 0) return parts.join(' ').slice(0, 120);
+    }
+
+    // 2. aria-label
+    const ariaLabel = el.getAttribute('aria-label');
+    if (ariaLabel) return ariaLabel.slice(0, 120);
+
+    // 3. alt (for images)
+    const alt = el.getAttribute('alt');
+    if (alt) return alt.slice(0, 120);
+
+    // 4. title
+    const title = el.getAttribute('title');
+    if (title) return title.slice(0, 120);
+
+    // 5. placeholder (for inputs)
+    const placeholder = el.getAttribute('placeholder');
+    if (placeholder) return placeholder.slice(0, 120);
+
+    // 6. value (for buttons)
+    if (el.tagName === 'INPUT' && (el.type === 'submit' || el.type === 'button')) {
+      const val = el.getAttribute('value');
+      if (val) return val.slice(0, 120);
+    }
+
+    // 7. Associated label
+    if (el.id) {
+      const label = document.querySelector('label[for="' + el.id + '"]');
+      if (label) return label.textContent.trim().slice(0, 120);
+    }
+
+    // 8. Direct text content (only for leaf-ish elements)
+    if (el.children.length <= 2) {
+      const text = el.textContent.trim();
+      if (text && text.length < 120) return text;
+    }
+
+    return '';
+  }
+
+  // \u2500\u2500 XPath generation \u2500\u2500
+  function getXPath(el) {
+    const parts = [];
+    let current = el;
+    while (current && current.nodeType === 1) {
+      let index = 1;
+      let sibling = current.previousElementSibling;
+      while (sibling) {
+        if (sibling.tagName === current.tagName) index++;
+        sibling = sibling.previousElementSibling;
+      }
+      const tag = current.tagName.toLowerCase();
+      parts.unshift(tag + '[' + index + ']');
+      current = current.parentElement;
+    }
+    return '/' + parts.join('/');
+  }
+
+  // \u2500\u2500 Interactivity classification \u2500\u2500
+  function classifyInteractivity(el) {
+    const types = [];
+    const tag = el.tagName.toLowerCase();
+
+    // Native
+    if (['a','button','input','select','textarea','details','summary'].includes(tag)) {
+      if (tag === 'a' && !el.href) {} // anchor without href is not interactive
+      else if (tag === 'input' && el.type === 'hidden') {} // hidden inputs
+      else types.push('native');
+    }
+
+    // ARIA role
+    const role = el.getAttribute('role');
+    if (role && INTERACTIVE_ROLES.has(role)) types.push('aria');
+
+    // Contenteditable
+    if (el.contentEditable === 'true') types.push('contenteditable');
+
+    // Focusable
+    if (el.tabIndex >= 0 && el.getAttribute('tabindex') !== null) types.push('focusable');
+
+    // Event listeners (check onclick and common inline handlers)
+    if (el.onclick || el.onmousedown || el.onkeydown || el.onkeypress ||
+        el.getAttribute('onclick') || el.getAttribute('onmousedown')) {
+      types.push('listener');
+    }
+
+    return types;
+  }
+
+  // \u2500\u2500 Disabled state with fieldset inheritance \u2500\u2500
+  function isDisabled(el) {
+    if (el.disabled) return true;
+    // Check fieldset disabled inheritance
+    let parent = el.parentElement;
+    while (parent) {
+      if (parent.tagName === 'FIELDSET' && parent.disabled) {
+        // Exception: elements inside the first legend child are NOT disabled
+        const firstLegend = parent.querySelector(':scope > legend');
+        if (firstLegend && firstLegend.contains(el)) return false;
+        return true;
+      }
+      parent = parent.parentElement;
+    }
+    return false;
+  }
+
+  // \u2500\u2500 Walk the DOM \u2500\u2500
+  function walk(el, depth, maxDepth) {
+    if (!el || depth > maxDepth) return '';
+
+    if (el.nodeType === 3) {
+      const t = el.textContent.trim();
+      return t ? '  '.repeat(depth) + 'text "' + t.slice(0, 100) + '"\\n' : '';
+    }
+
+    if (el.nodeType !== 1) return '';
+    const tag = el.tagName.toLowerCase();
+    if (SKIP.has(tag)) return '';
+
+    const style = getComputedStyle(el);
+    if (style.display === 'none' || style.visibility === 'hidden') return '';
+
+    const indent = '  '.repeat(depth);
+    const role = el.getAttribute('role') || ROLE_MAP[tag] || '';
+    const name = getAccessibleName(el);
+    const interTypes = classifyInteractivity(el);
+    const interactive = interTypes.length > 0;
+    const disabled = interactive && isDisabled(el);
+
+    let line = indent;
+    line += role || tag;
+
+    if (name) line += ' "' + name.slice(0, 80) + '"';
+
+    if (interactive) {
+      line += ' [' + interTypes.join(',') + ']';
+      if (disabled) line += ' {disabled}';
+      line += ' xpath=' + getXPath(el);
+    }
+
+    // Input state
+    if (tag === 'input') {
+      const type = el.type || 'text';
+      line += ' type=' + type;
+      if (type === 'checkbox' || type === 'radio') {
+        line += el.checked ? ' [checked]' : ' [unchecked]';
+      } else if (el.value) {
+        line += ' value="' + el.value.slice(0, 50) + '"';
+      }
+    }
+    if (tag === 'textarea' && el.value) {
+      line += ' value="' + el.value.slice(0, 50) + '"';
+    }
+    if (tag === 'select') {
+      const opts = Array.from(el.options || []).map(o => ({
+        text: o.text.slice(0, 30),
+        value: o.value,
+        selected: o.selected,
+      }));
+      const selected = opts.find(o => o.selected);
+      if (selected) line += ' selected="' + selected.text + '"';
+      if (opts.length <= 10) {
+        line += ' options=[' + opts.map(o => o.text).join('|') + ']';
+      }
+    }
+
+    line += '\\n';
+
+    let out = line;
+    for (const c of el.childNodes) {
+      out += walk(c, depth + 1, maxDepth);
+    }
+
+    // Shadow DOM
+    if (el.shadowRoot) {
+      for (const c of el.shadowRoot.childNodes) {
+        out += walk(c, depth + 1, maxDepth);
+      }
+    }
+
+    return out;
+  }
+
+  return walk(document.body, 0, 20);
+})()
+`;
+
+// src/browser/dom/markdown.ts
+var MARKDOWN_SCRIPT = `
+(() => {
+  const SKIP = new Set(['script','style','noscript','svg','head','template']);
+  const baseUrl = location.href;
+
+  // Resolve relative URLs to absolute
+  function resolveUrl(href) {
+    if (!href || href.startsWith('javascript:') || href.startsWith('#')) return href;
+    try { return new URL(href, baseUrl).href; } catch { return href; }
+  }
+
+  // Escape Markdown special chars in text
+  function escapeText(text) {
+    return text
+      .replace(/\\\\/g, '\\\\\\\\')
+      .replace(/([*_~\`\\[\\]|])/g, '\\\\$1');
+  }
+
+  // State tracking
+  let listDepth = 0;
+  let orderedCounters = [];
+  let inPre = false;
+  let inTable = false;
+
+  function listIndent() { return '  '.repeat(listDepth); }
+
+  function walk(el) {
+    if (!el) return '';
+
+    // Text node
+    if (el.nodeType === 3) {
+      const text = el.textContent || '';
+      if (inPre) return text;
+      // Collapse whitespace
+      const collapsed = text.replace(/\\s+/g, ' ');
+      return collapsed === ' ' && !el.previousSibling && !el.nextSibling ? '' : collapsed;
+    }
+
+    if (el.nodeType !== 1) return '';
+    const tag = el.tagName.toLowerCase();
+    if (SKIP.has(tag)) return '';
+
+    // Visibility check
+    try {
+      const s = getComputedStyle(el);
+      if (s.display === 'none' || s.visibility === 'hidden') return '';
+    } catch {}
+
+    // Get children content
+    function childContent() {
+      let out = '';
+      for (const c of el.childNodes) out += walk(c);
+      return out;
+    }
+
+    switch (tag) {
+      // \u2500\u2500 Headings \u2500\u2500
+      case 'h1': return '\\n\\n# ' + childContent().trim() + '\\n\\n';
+      case 'h2': return '\\n\\n## ' + childContent().trim() + '\\n\\n';
+      case 'h3': return '\\n\\n### ' + childContent().trim() + '\\n\\n';
+      case 'h4': return '\\n\\n#### ' + childContent().trim() + '\\n\\n';
+      case 'h5': return '\\n\\n##### ' + childContent().trim() + '\\n\\n';
+      case 'h6': return '\\n\\n###### ' + childContent().trim() + '\\n\\n';
+
+      // \u2500\u2500 Block elements \u2500\u2500
+      case 'p': return '\\n\\n' + childContent().trim() + '\\n\\n';
+      case 'br': return '\\n';
+      case 'hr': return '\\n\\n---\\n\\n';
+
+      // \u2500\u2500 Inline formatting \u2500\u2500
+      case 'strong': case 'b': {
+        const inner = childContent().trim();
+        return inner ? '**' + inner + '**' : '';
+      }
+      case 'em': case 'i': {
+        const inner = childContent().trim();
+        return inner ? '*' + inner + '*' : '';
+      }
+      case 's': case 'del': case 'strike': {
+        const inner = childContent().trim();
+        return inner ? '~~' + inner + '~~' : '';
+      }
+      case 'code': {
+        if (inPre) return childContent();
+        const inner = childContent();
+        return inner ? '\\x60' + inner + '\\x60' : '';
+      }
+
+      // \u2500\u2500 Code blocks \u2500\u2500
+      case 'pre': {
+        inPre = true;
+        const inner = childContent();
+        inPre = false;
+        const lang = el.querySelector('code')?.className?.match(/language-(\\w+)/)?.[1] || '';
+        return '\\n\\n\\x60\\x60\\x60' + lang + '\\n' + inner.trim() + '\\n\\x60\\x60\\x60\\n\\n';
+      }
+
+      // \u2500\u2500 Links \u2500\u2500
+      case 'a': {
+        const href = resolveUrl(el.getAttribute('href') || '');
+        const inner = childContent().trim();
+        const name = inner || el.getAttribute('aria-label') || el.getAttribute('title') || '';
+        if (!name) return '';
+        if (!href || href === '#' || href.startsWith('javascript:')) return name;
+        return '[' + name + '](' + href + ')';
+      }
+
+      // \u2500\u2500 Images \u2500\u2500
+      case 'img': {
+        const alt = el.getAttribute('alt') || '';
+        const src = resolveUrl(el.getAttribute('src') || '');
+        return src ? '![' + alt + '](' + src + ')' : '';
+      }
+
+      // \u2500\u2500 Lists \u2500\u2500
+      case 'ul': {
+        listDepth++;
+        orderedCounters.push(0);
+        const inner = childContent();
+        listDepth--;
+        orderedCounters.pop();
+        return '\\n' + inner;
+      }
+      case 'ol': {
+        listDepth++;
+        orderedCounters.push(0);
+        const inner = childContent();
+        listDepth--;
+        orderedCounters.pop();
+        return '\\n' + inner;
+      }
+      case 'li': {
+        const parent = el.parentElement?.tagName?.toLowerCase();
+        const isOrdered = parent === 'ol';
+        const inner = childContent().trim();
+        if (!inner) return '';
+        if (isOrdered) {
+          const counter = orderedCounters.length > 0
+            ? ++orderedCounters[orderedCounters.length - 1] : 1;
+          return listIndent() + counter + '. ' + inner + '\\n';
+        }
+        return listIndent() + '- ' + inner + '\\n';
+      }
+
+      // \u2500\u2500 Blockquote \u2500\u2500
+      case 'blockquote': {
+        const inner = childContent().trim();
+        if (!inner) return '';
+        return '\\n\\n' + inner.split('\\n').map(line => '> ' + line).join('\\n') + '\\n\\n';
+      }
+
+      // \u2500\u2500 Tables \u2500\u2500
+      case 'table': {
+        inTable = true;
+        let out = '\\n\\n';
+        const rows = el.querySelectorAll('tr');
+        let headerDone = false;
+
+        for (let i = 0; i < rows.length; i++) {
+          const cells = rows[i].querySelectorAll('th, td');
+          const isHeader = rows[i].querySelector('th') !== null;
+          const cellTexts = [];
+          for (const cell of cells) {
+            let cellText = '';
+            for (const c of cell.childNodes) cellText += walk(c);
+            cellTexts.push(cellText.trim().replace(/\\|/g, '\\\\|').replace(/\\n/g, ' '));
+          }
+
+          out += '| ' + cellTexts.join(' | ') + ' |\\n';
+
+          if (isHeader && !headerDone) {
+            out += '| ' + cellTexts.map(() => '---').join(' | ') + ' |\\n';
+            headerDone = true;
+          }
+
+          // First data row without headers \u2014 synthesize separator
+          if (i === 0 && !isHeader && !headerDone) {
+            out += '| ' + cellTexts.map(() => '---').join(' | ') + ' |\\n';
+            headerDone = true;
+          }
+        }
+
+        inTable = false;
+        return out + '\\n';
+      }
+      case 'thead': case 'tbody': case 'tfoot':
+        return childContent();
+      case 'tr': case 'td': case 'th':
+        // Handled by table walker above; fallback for orphaned elements
+        return childContent();
+
+      // \u2500\u2500 Definition lists \u2500\u2500
+      case 'dl': return '\\n\\n' + childContent() + '\\n\\n';
+      case 'dt': return '\\n**' + childContent().trim() + '**\\n';
+      case 'dd': return ': ' + childContent().trim() + '\\n';
+
+      // \u2500\u2500 Figure \u2500\u2500
+      case 'figure': return '\\n\\n' + childContent().trim() + '\\n\\n';
+      case 'figcaption': return '\\n*' + childContent().trim() + '*\\n';
+
+      // \u2500\u2500 Details/Summary \u2500\u2500
+      case 'details': return '\\n\\n' + childContent() + '\\n\\n';
+      case 'summary': return '**' + childContent().trim() + '**\\n\\n';
+
+      // \u2500\u2500 Generic blocks \u2500\u2500
+      case 'div': case 'section': case 'article': case 'main': case 'aside':
+      case 'header': case 'footer': case 'nav':
+        return '\\n' + childContent() + '\\n';
+
+      case 'span': case 'small': case 'sub': case 'sup': case 'abbr':
+      case 'time': case 'mark': case 'cite': case 'q':
+        return childContent();
+
+      default:
+        return childContent();
+    }
+  }
+
+  const raw = walk(document.body);
+  // Clean up: collapse 3+ newlines to 2, trim
+  return raw.replace(/\\n{3,}/g, '\\n\\n').replace(/^\\n+|\\n+$/g, '').trim();
+})()
+`;
+
+// src/browser/dom/form-state.ts
+var FORM_STATE_SCRIPT = `
+(() => {
+  function extractField(el) {
+    const tag = el.tagName.toLowerCase();
+    const type = (el.getAttribute('type') || tag).toLowerCase();
+
+    // Skip non-user-facing inputs
+    if (['hidden', 'submit', 'button', 'reset', 'image'].includes(type)) return null;
+
+    const name = el.name || el.id || '';
+
+    // Find label via multiple strategies
+    const label =
+      el.getAttribute('aria-label') ||
+      (el.id ? document.querySelector('label[for="' + el.id + '"]')?.textContent?.trim() : null) ||
+      el.closest('label')?.textContent?.trim() ||
+      el.placeholder ||
+      '';
+
+    // Extract value based on type
+    let value;
+    if (tag === 'select') {
+      const selected = el.options[el.selectedIndex];
+      value = selected ? selected.textContent.trim() : '';
+    } else if (type === 'checkbox' || type === 'radio') {
+      value = el.checked;
+    } else if (type === 'password') {
+      value = el.value ? '\u2022\u2022\u2022\u2022' : '';
+    } else if (el.isContentEditable) {
+      value = el.textContent?.trim()?.slice(0, 200) || '';
+    } else {
+      value = el.value || '';
+    }
+
+    return {
+      tag,
+      type,
+      name,
+      label: label.slice(0, 80),
+      value: typeof value === 'string' ? value.slice(0, 200) : value,
+      required: !!el.required,
+      disabled: !!el.disabled,
+      ref: el.dataset?.ref || null,
+    };
+  }
+
+  const result = { forms: [], orphanFields: [] };
+
+  // Collect forms
+  for (const form of document.forms) {
+    const fields = [];
+    for (const el of form.elements) {
+      const field = extractField(el);
+      if (field) fields.push(field);
+    }
+    result.forms.push({
+      id: form.id || '',
+      name: form.name || '',
+      action: form.action || '',
+      method: (form.method || 'get').toUpperCase(),
+      fields,
+    });
+  }
+
+  // Collect orphan fields (not in a <form>)
+  const allInputs = document.querySelectorAll(
+    'input, textarea, select, [contenteditable="true"]'
+  );
+  for (const el of allInputs) {
+    if (!el.form) {
+      const field = extractField(el);
+      if (field) result.orphanFields.push(field);
+    }
+  }
+
+  return result;
+})()
+`;
+
+// src/browser/interceptor.ts
+function buildInterceptorScript(pattern) {
+  return `
+(() => {
+  if (window.__lobster_interceptor__) return;
+  window.__lobster_interceptor__ = { requests: [] };
+  const store = window.__lobster_interceptor__;
+  const pattern = ${JSON.stringify(pattern)};
+
+  // Patch fetch
+  const origFetch = window.fetch;
+  window.fetch = async function(...args) {
+    const url = typeof args[0] === 'string' ? args[0] : args[0]?.url || '';
+    const resp = await origFetch.apply(this, args);
+    if (url.includes(pattern)) {
+      const clone = resp.clone();
+      try {
+        const body = await clone.json();
+        store.requests.push({ url, method: 'GET', status: resp.status, body, timestamp: Date.now() });
+      } catch {}
+    }
+    return resp;
+  };
+
+  // Patch XHR
+  const origOpen = XMLHttpRequest.prototype.open;
+  const origSend = XMLHttpRequest.prototype.send;
+  XMLHttpRequest.prototype.open = function(method, url, ...rest) {
+    this.__url = url;
+    this.__method = method;
+    return origOpen.call(this, method, url, ...rest);
+  };
+  XMLHttpRequest.prototype.send = function(...args) {
+    this.addEventListener('load', function() {
+      if (this.__url && this.__url.includes(pattern)) {
+        try {
+          const body = JSON.parse(this.responseText);
+          store.requests.push({ url: this.__url, method: this.__method, status: this.status, body, timestamp: Date.now() });
+        } catch {}
+      }
+    });
+    return origSend.apply(this, args);
+  };
+})()
+`;
+}
+var GET_INTERCEPTED_SCRIPT = `
+(() => {
+  const store = window.__lobster_interceptor__;
+  if (!store) return [];
+  const reqs = [...store.requests];
+  store.requests = [];
+  return reqs;
+})()
+`;
+
+// src/browser/page-adapter.ts
+var PuppeteerPage = class {
+  page;
+  constructor(page) {
+    this.page = page;
+  }
+  get raw() {
+    return this.page;
+  }
+  async goto(url, options) {
+    await this.page.goto(url, {
+      waitUntil: options?.waitUntil || "networkidle2",
+      timeout: options?.timeout || 3e4
+    });
+  }
+  async goBack() {
+    await this.page.goBack({ waitUntil: "networkidle2" });
+  }
+  async url() {
+    return this.page.url();
+  }
+  async title() {
+    return this.page.title();
+  }
+  async evaluate(js) {
+    return this.page.evaluate(js);
+  }
+  async snapshot(_opts) {
+    return this.page.evaluate(SNAPSHOT_SCRIPT);
+  }
+  async semanticTree(_opts) {
+    return this.page.evaluate(SEMANTIC_TREE_SCRIPT);
+  }
+  async flatTree() {
+    const raw = await this.page.evaluate(FLAT_TREE_SCRIPT);
+    return raw;
+  }
+  async markdown() {
+    return this.page.evaluate(MARKDOWN_SCRIPT);
+  }
+  async browserState() {
+    const state = await this.page.evaluate(`
+      (() => {
+        const scrollY = window.scrollY;
+        const scrollX = window.scrollX;
+        const vpW = window.innerWidth;
+        const vpH = window.innerHeight;
+        const pageW = document.documentElement.scrollWidth;
+        const pageH = document.documentElement.scrollHeight;
+        const maxScrollY = pageH - vpH;
+        return {
+          url: location.href,
+          title: document.title,
+          viewportWidth: vpW,
+          viewportHeight: vpH,
+          pageWidth: pageW,
+          pageHeight: pageH,
+          scrollX: scrollX,
+          scrollY: scrollY,
+          scrollPercent: maxScrollY > 0 ? Math.round((scrollY / maxScrollY) * 100) : 0,
+          pixelsAbove: Math.round(scrollY),
+          pixelsBelow: Math.round(Math.max(0, maxScrollY - scrollY)),
+        };
+      })()
+    `);
+    return state;
+  }
+  async formState() {
+    return this.page.evaluate(FORM_STATE_SCRIPT);
+  }
+  async click(ref) {
+    if (typeof ref === "number") {
+      await this.page.evaluate((idx) => {
+        const el = document.querySelector('[data-ref="' + idx + '"]');
+        if (!el) throw new Error("Element with index " + idx + " not found");
+        const prev = document.activeElement;
+        if (prev && prev !== el && prev !== document.body) {
+          prev.blur();
+          prev.dispatchEvent(new MouseEvent("mouseout", { bubbles: true, cancelable: true }));
+          prev.dispatchEvent(new MouseEvent("mouseleave", { bubbles: false, cancelable: true }));
+        }
+        if (typeof el.scrollIntoViewIfNeeded === "function") {
+          el.scrollIntoViewIfNeeded();
+        } else {
+          el.scrollIntoView({ behavior: "auto", block: "center", inline: "nearest" });
+        }
+        el.dispatchEvent(new MouseEvent("mouseenter", { bubbles: true, cancelable: true }));
+        el.dispatchEvent(new MouseEvent("mouseover", { bubbles: true, cancelable: true }));
+        el.dispatchEvent(new MouseEvent("mousedown", { bubbles: true, cancelable: true }));
+        el.focus();
+        el.dispatchEvent(new MouseEvent("mouseup", { bubbles: true, cancelable: true }));
+        el.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
+      }, ref);
+      await new Promise((r) => setTimeout(r, 200));
+    } else {
+      await this.page.click(ref);
+    }
+  }
+  async typeText(ref, text) {
+    if (typeof ref === "number") {
+      await this.click(ref);
+      await this.page.evaluate((idx, txt) => {
+        const el = document.querySelector('[data-ref="' + idx + '"]');
+        if (!el) throw new Error("Element with index " + idx + " not found");
+        const isInput = el.tagName === "INPUT" || el.tagName === "TEXTAREA";
+        const isContentEditable = el.isContentEditable;
+        if (isContentEditable) {
+          if (el.dispatchEvent(new InputEvent("beforeinput", {
+            bubbles: true,
+            cancelable: true,
+            inputType: "deleteContent"
+          }))) {
+            el.innerText = "";
+            el.dispatchEvent(new InputEvent("input", {
+              bubbles: true,
+              inputType: "deleteContent"
+            }));
+          }
+          if (el.dispatchEvent(new InputEvent("beforeinput", {
+            bubbles: true,
+            cancelable: true,
+            inputType: "insertText",
+            data: txt
+          }))) {
+            el.innerText = txt;
+            el.dispatchEvent(new InputEvent("input", {
+              bubbles: true,
+              inputType: "insertText",
+              data: txt
+            }));
+          }
+          const planAOk = el.innerText.trim() === txt.trim();
+          if (!planAOk) {
+            el.focus();
+            const doc = el.ownerDocument;
+            const sel = (doc.defaultView || window).getSelection();
+            const range = doc.createRange();
+            range.selectNodeContents(el);
+            sel?.removeAllRanges();
+            sel?.addRange(range);
+            doc.execCommand("delete", false);
+            doc.execCommand("insertText", false, txt);
+          }
+          el.dispatchEvent(new Event("change", { bubbles: true }));
+          el.blur();
+        } else if (isInput) {
+          const inputEl = el;
+          const proto = Object.getPrototypeOf(inputEl);
+          const descriptor = Object.getOwnPropertyDescriptor(proto, "value") || Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value") || Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, "value");
+          if (descriptor?.set) {
+            descriptor.set.call(inputEl, txt);
+          } else {
+            inputEl.value = txt;
+          }
+          inputEl.dispatchEvent(new Event("input", { bubbles: true }));
+          inputEl.dispatchEvent(new Event("change", { bubbles: true }));
+        } else {
+          el.value = txt;
+          el.dispatchEvent(new Event("input", { bubbles: true }));
+          el.dispatchEvent(new Event("change", { bubbles: true }));
+        }
+      }, ref, text);
+    } else {
+      await this.page.click(ref, { count: 3 });
+      await this.page.keyboard.type(text);
+    }
+  }
+  async pressKey(key) {
+    await this.page.keyboard.press(key);
+  }
+  async selectOption(ref, value) {
+    const selector = typeof ref === "number" ? '[data-ref="' + ref + '"]' : ref;
+    await this.page.select(selector, value);
+  }
+  async scroll(direction, amount) {
+    const distance = amount || 500;
+    const isVertical = direction === "up" || direction === "down";
+    const positive = direction === "down" || direction === "right";
+    const delta = positive ? distance : -distance;
+    await this.page.evaluate((dy, dx, isVert) => {
+      const canScroll = (el2) => {
+        if (!el2) return false;
+        const s = getComputedStyle(el2);
+        if (isVert) {
+          return /(auto|scroll|overlay)/.test(s.overflowY) && el2.scrollHeight > el2.clientHeight && el2.clientHeight >= window.innerHeight * 0.3;
+        } else {
+          return /(auto|scroll|overlay)/.test(s.overflowX) && el2.scrollWidth > el2.clientWidth && el2.clientWidth >= window.innerWidth * 0.3;
+        }
+      };
+      let el = document.activeElement;
+      while (el && !canScroll(el) && el !== document.body) {
+        el = el.parentElement;
+      }
+      if (!canScroll(el)) {
+        el = Array.from(document.querySelectorAll("*")).find(canScroll) || null;
+      }
+      const isPageLevel = !el || el === document.body || el === document.documentElement || el === document.scrollingElement;
+      if (isPageLevel) {
+        if (isVert) {
+          window.scrollBy(0, dy);
+        } else {
+          window.scrollBy(dx, 0);
+        }
+      } else {
+        if (isVert) {
+          el.scrollBy({ top: dy, behavior: "smooth" });
+        } else {
+          el.scrollBy({ left: dx, behavior: "smooth" });
+        }
+      }
+    }, isVertical ? delta : 0, isVertical ? 0 : delta, isVertical);
+    await new Promise((r) => setTimeout(r, 150));
+  }
+  async scrollToElement(ref) {
+    const selector = typeof ref === "number" ? '[data-ref="' + ref + '"]' : ref;
+    await this.page.evaluate((sel) => {
+      const el = document.querySelector(sel);
+      if (!el) return;
+      if (typeof el.scrollIntoViewIfNeeded === "function") {
+        el.scrollIntoViewIfNeeded();
+      } else {
+        el.scrollIntoView({ behavior: "auto", block: "center", inline: "nearest" });
+      }
+    }, selector);
+  }
+  async getCookies(opts) {
+    const cookies = await this.page.cookies();
+    const filtered = opts?.domain ? cookies.filter((c) => c.domain.includes(opts.domain)) : cookies;
+    return filtered.map((c) => ({
+      name: c.name,
+      value: c.value,
+      domain: c.domain,
+      path: c.path,
+      expires: c.expires,
+      httpOnly: c.httpOnly,
+      secure: c.secure,
+      sameSite: c.sameSite
+    }));
+  }
+  async wait(options) {
+    if (typeof options === "number") {
+      await new Promise((r) => setTimeout(r, options * 1e3));
+      return;
+    }
+    if (options.time) {
+      await new Promise((r) => setTimeout(r, options.time * 1e3));
+    }
+    if (options.text) {
+      await this.page.waitForFunction(
+        (t) => document.body.innerText.includes(t),
+        { timeout: options.timeout || 3e4 },
+        options.text
+      );
+    }
+  }
+  async networkRequests(includeStatic) {
+    const entries = await this.page.evaluate(`
+      (() => {
+        const entries = performance.getEntriesByType('resource');
+        const staticTypes = new Set(['img', 'font', 'css', 'script', 'link']);
+        const includeStatic = ${!!includeStatic};
+
+        return entries
+          .filter(e => includeStatic || !staticTypes.has(e.initiatorType))
+          .map(e => ({
+            url: e.name,
+            method: 'GET',
+            status: 200,
+            type: e.initiatorType || 'other',
+            size: e.transferSize || e.encodedBodySize || 0,
+            duration: Math.round(e.duration),
+          }));
+      })()
+    `);
+    return entries || [];
+  }
+  async installInterceptor(pattern) {
+    await this.page.evaluate(buildInterceptorScript(pattern));
+  }
+  async getInterceptedRequests() {
+    return this.page.evaluate(GET_INTERCEPTED_SCRIPT);
+  }
+  async screenshot(opts) {
+    const result = await this.page.screenshot({
+      type: opts?.format || "png",
+      fullPage: opts?.fullPage ?? false
+    });
+    return Buffer.from(result);
+  }
+  async tabs() {
+    const browser = this.page.browser();
+    const pages = await browser.pages();
+    return pages.map((p, i) => ({
+      id: i,
+      url: p.url(),
+      title: "",
+      active: p === this.page
+    }));
+  }
+  async close() {
+    await this.page.close();
+  }
+};
+
+// src/agent/core.ts
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+// src/llm/errors.ts
+var InvokeError = class extends Error {
+  type;
+  retryable;
+  rawError;
+  rawResponse;
+  constructor(type, message, opts) {
+    super(message);
+    this.name = "InvokeError";
+    this.type = type;
+    this.retryable = opts?.retryable ?? isRetryable(type);
+    this.rawError = opts?.rawError;
+    this.rawResponse = opts?.rawResponse;
+  }
+};
+function isRetryable(type) {
+  switch (type) {
+    case "NETWORK_ERROR" /* NETWORK_ERROR */:
+    case "RATE_LIMIT" /* RATE_LIMIT */:
+    case "SERVER_ERROR" /* SERVER_ERROR */:
+    case "NO_TOOL_CALL" /* NO_TOOL_CALL */:
+    case "INVALID_TOOL_ARGS" /* INVALID_TOOL_ARGS */:
+    case "TOOL_EXECUTION_ERROR" /* TOOL_EXECUTION_ERROR */:
+    case "UNKNOWN" /* UNKNOWN */:
+      return true;
+    case "AUTH_ERROR" /* AUTH_ERROR */:
+    case "CONTEXT_LENGTH" /* CONTEXT_LENGTH */:
+    case "CONTENT_FILTER" /* CONTENT_FILTER */:
+      return false;
+  }
+}
+
+// src/llm/openai-client.ts
+var OpenAIClient = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Build auth headers based on the provider.
+   * - OpenAI/Gemini/Ollama: Bearer token
+   * - Anthropic: x-api-key header + anthropic-version
+   */
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (!this.config.apiKey) return headers;
+    if (this.config.provider === "anthropic") {
+      headers["x-api-key"] = this.config.apiKey;
+      headers["anthropic-version"] = "2023-06-01";
+    } else {
+      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    }
+    return headers;
+  }
+  /**
+   * Build the request body based on provider.
+   * Anthropic Messages API is different from OpenAI chat completions.
+   */
+  buildBody(messages, tools, opts) {
+    if (this.config.provider === "anthropic") {
+      return this.buildAnthropicBody(messages, tools, opts);
+    }
+    const body = {
+      model: this.config.model,
+      messages,
+      temperature: this.config.temperature ?? 0.1
+    };
+    if (tools && tools.length > 0) {
+      body.tools = tools;
+      body.parallel_tool_calls = false;
+      if (opts?.toolChoice) {
+        body.tool_choice = typeof opts.toolChoice === "string" ? opts.toolChoice : opts.toolChoice;
+      }
+    }
+    return { url: `${this.config.baseURL}/chat/completions`, body };
+  }
+  /**
+   * Build Anthropic Messages API request.
+   * Converts OpenAI-style messages/tools to Anthropic format.
+   */
+  buildAnthropicBody(messages, tools, opts) {
+    let system;
+    const anthropicMessages = [];
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        system = msg.content;
+      } else {
+        anthropicMessages.push({
+          role: msg.role === "assistant" ? "assistant" : "user",
+          content: msg.content
+        });
+      }
+    }
+    const body = {
+      model: this.config.model,
+      messages: anthropicMessages,
+      max_tokens: 4096,
+      temperature: this.config.temperature ?? 0.1
+    };
+    if (system) body.system = system;
+    if (tools && tools.length > 0) {
+      body.tools = tools.map((t) => {
+        const fn = t.function;
+        return {
+          name: fn.name,
+          description: fn.description,
+          input_schema: fn.parameters
+        };
+      });
+      if (opts?.toolChoice) {
+        if (typeof opts.toolChoice === "string") {
+          body.tool_choice = opts.toolChoice === "required" ? { type: "any" } : { type: opts.toolChoice };
+        } else {
+          body.tool_choice = { type: "tool", name: opts.toolChoice.function.name };
+        }
+      }
+    }
+    return { url: `${this.config.baseURL}/messages`, body };
+  }
+  /**
+   * Parse Anthropic response into our unified format.
+   */
+  parseAnthropicResponse(json) {
+    const content = json.content;
+    if (!content || !Array.isArray(content)) {
+      throw new InvokeError("UNKNOWN" /* UNKNOWN */, "No content in Anthropic response", { rawResponse: json });
+    }
+    let textContent;
+    const toolCalls = [];
+    for (const block of content) {
+      if (block.type === "text") {
+        textContent = block.text;
+      } else if (block.type === "tool_use") {
+        toolCalls.push({
+          id: block.id,
+          type: "function",
+          function: {
+            name: block.name,
+            arguments: JSON.stringify(block.input)
+          }
+        });
+      }
+    }
+    const usage = json.usage;
+    return {
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      content: textContent,
+      usage: usage ? {
+        promptTokens: usage.input_tokens ?? 0,
+        completionTokens: usage.output_tokens ?? 0,
+        totalTokens: (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0)
+      } : void 0
+    };
+  }
+  async chatCompletion(messages, tools, opts) {
+    const { url, body } = this.buildBody(messages, tools, opts);
+    const headers = this.buildHeaders();
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      });
+    } catch (err) {
+      throw new InvokeError("NETWORK_ERROR" /* NETWORK_ERROR */, `Network error: ${err}`, { rawError: err });
+    }
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      if (response.status === 401) {
+        throw new InvokeError("AUTH_ERROR" /* AUTH_ERROR */, `Authentication failed: ${text}`, { retryable: false, rawResponse: text });
+      }
+      if (response.status === 429) {
+        throw new InvokeError("RATE_LIMIT" /* RATE_LIMIT */, `Rate limited: ${text}`, { rawResponse: text });
+      }
+      if (response.status >= 500) {
+        throw new InvokeError("SERVER_ERROR" /* SERVER_ERROR */, `Server error ${response.status}: ${text}`, { rawResponse: text });
+      }
+      throw new InvokeError("UNKNOWN" /* UNKNOWN */, `HTTP ${response.status}: ${text}`, { rawResponse: text });
+    }
+    const json = await response.json();
+    if (this.config.provider === "anthropic") {
+      return this.parseAnthropicResponse(json);
+    }
+    const choice = json.choices?.[0];
+    if (!choice) {
+      throw new InvokeError("UNKNOWN" /* UNKNOWN */, "No choices in response", { rawResponse: json });
+    }
+    const message = choice.message;
+    const finishReason = choice.finish_reason;
+    if (finishReason === "content_filter") {
+      throw new InvokeError("CONTENT_FILTER" /* CONTENT_FILTER */, "Content filtered", { retryable: false, rawResponse: json });
+    }
+    if (finishReason === "length") {
+      throw new InvokeError("CONTEXT_LENGTH" /* CONTEXT_LENGTH */, "Context length exceeded", { retryable: false, rawResponse: json });
+    }
+    const usage = json.usage;
+    return {
+      toolCalls: message.tool_calls,
+      content: message.content,
+      usage: usage ? {
+        promptTokens: usage.prompt_tokens ?? 0,
+        completionTokens: usage.completion_tokens ?? 0,
+        totalTokens: usage.total_tokens ?? 0
+      } : void 0
+    };
+  }
+};
+
+// src/llm/utils.ts
+function zodToJsonSchema(schema) {
+  if ("_def" in schema) {
+    const def = schema._def;
+    const typeName = def.typeName;
+    if (typeName === "ZodObject") {
+      const shape = def.shape();
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = zodToJsonSchema(value);
+        if (!(value._def?.typeName === "ZodOptional")) {
+          required.push(key);
+        }
+      }
+      const result = { type: "object", properties };
+      if (required.length > 0) result.required = required;
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    if (typeName === "ZodString") {
+      const result = { type: "string" };
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    if (typeName === "ZodNumber") {
+      const result = { type: "number" };
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    if (typeName === "ZodBoolean") {
+      const result = { type: "boolean" };
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    if (typeName === "ZodEnum") {
+      return { type: "string", enum: def.values, ...def.description ? { description: def.description } : {} };
+    }
+    if (typeName === "ZodArray") {
+      return { type: "array", items: zodToJsonSchema(def.type), ...def.description ? { description: def.description } : {} };
+    }
+    if (typeName === "ZodOptional") {
+      return zodToJsonSchema(def.innerType);
+    }
+    if (typeName === "ZodDefault") {
+      const inner = zodToJsonSchema(def.innerType);
+      return { ...inner, default: def.defaultValue() };
+    }
+    if (typeName === "ZodUnion") {
+      return { oneOf: def.options.map((opt) => zodToJsonSchema(opt)) };
+    }
+    if (typeName === "ZodRecord") {
+      return { type: "object", additionalProperties: zodToJsonSchema(def.valueType) };
+    }
+    if (typeName === "ZodLiteral") {
+      return { const: def.value };
+    }
+    if (typeName === "ZodAny") {
+      return {};
+    }
+  }
+  return { type: "string" };
+}
+function zodToOpenAITool(name, description, schema) {
+  return {
+    type: "function",
+    function: {
+      name,
+      description,
+      parameters: zodToJsonSchema(schema)
+    }
+  };
+}
+
+// src/llm/client.ts
+var LLM = class {
+  client;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.client = new OpenAIClient({
+      baseURL: config.baseURL,
+      model: config.model,
+      apiKey: config.apiKey,
+      temperature: config.temperature,
+      provider: config.provider
+    });
+  }
+  async invoke(messages, tool, abortSignal) {
+    const openaiTool = zodToOpenAITool(tool.name, tool.description, tool.schema);
+    return this.withRetry(async () => {
+      if (abortSignal?.aborted) throw new Error("Aborted");
+      const response = await this.client.chatCompletion(
+        messages,
+        [openaiTool],
+        { toolChoice: { type: "function", function: { name: tool.name } } }
+      );
+      const toolCall = response.toolCalls?.[0];
+      if (!toolCall) {
+        if (response.content) {
+          const extracted = extractJsonFromString(response.content);
+          if (extracted) {
+            const args2 = typeof extracted === "string" ? JSON.parse(extracted) : extracted;
+            const result2 = await tool.execute(args2);
+            return {
+              toolCall: { name: tool.name, args: args2 },
+              toolResult: result2,
+              usage: response.usage
+            };
+          }
+        }
+        throw new InvokeError("NO_TOOL_CALL" /* NO_TOOL_CALL */, "No tool call in response");
+      }
+      let args;
+      try {
+        args = JSON.parse(toolCall.function.arguments);
+      } catch {
+        try {
+          args = JSON.parse(JSON.parse(toolCall.function.arguments));
+        } catch {
+          throw new InvokeError("INVALID_TOOL_ARGS" /* INVALID_TOOL_ARGS */, `Invalid JSON in tool args: ${toolCall.function.arguments}`);
+        }
+      }
+      let result;
+      try {
+        result = await tool.execute(args);
+      } catch (err) {
+        throw new InvokeError("TOOL_EXECUTION_ERROR" /* TOOL_EXECUTION_ERROR */, `Tool execution failed: ${err}`, { rawError: err });
+      }
+      return {
+        toolCall: { name: tool.name, args },
+        toolResult: result,
+        usage: response.usage
+      };
+    });
+  }
+  async withRetry(fn) {
+    const maxRetries = this.config.maxRetries ?? 3;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err;
+        if (err instanceof InvokeError && !err.retryable) throw err;
+        if (err instanceof Error && err.name === "AbortError") throw err;
+        if (attempt < maxRetries) {
+          await new Promise((r) => setTimeout(r, 100 * (attempt + 1)));
+        }
+      }
+    }
+    throw lastError;
+  }
+};
+function extractJsonFromString(str) {
+  const start = str.indexOf("{");
+  const end = str.lastIndexOf("}");
+  if (start === -1 || end === -1 || end <= start) return null;
+  try {
+    return JSON.parse(str.slice(start, end + 1));
+  } catch {
+    return null;
+  }
+}
+
+// src/agent/tools/click.ts
+import { z } from "zod";
+function createClickTool(page) {
+  return {
+    description: "Click on an interactive element by its index number from the page content.",
+    inputSchema: z.object({
+      index: z.number().describe("The index of the element to click")
+    }),
+    execute: async (args) => {
+      await page.click(args.index);
+      return `Clicked element [${args.index}]`;
+    }
+  };
+}
+
+// src/agent/tools/type.ts
+import { z as z2 } from "zod";
+function createTypeTool(page) {
+  return {
+    description: "Type text into an input field identified by its index number.",
+    inputSchema: z2.object({
+      index: z2.number().describe("The index of the input element"),
+      text: z2.string().describe("The text to type")
+    }),
+    execute: async (args) => {
+      await page.typeText(args.index, args.text);
+      return `Typed "${args.text}" into element [${args.index}]`;
+    }
+  };
+}
+
+// src/agent/tools/scroll.ts
+import { z as z3 } from "zod";
+function createScrollTool(page) {
+  return {
+    description: "Scroll the page in a given direction. Use to reveal more content.",
+    inputSchema: z3.object({
+      direction: z3.enum(["up", "down", "left", "right"]).describe("Scroll direction"),
+      amount: z3.number().optional().describe("Pixels to scroll (default 500)")
+    }),
+    execute: async (args) => {
+      await page.scroll(args.direction, args.amount);
+      return `Scrolled ${args.direction}${args.amount ? ` ${args.amount}px` : ""}`;
+    }
+  };
+}
+
+// src/agent/tools/select.ts
+import { z as z4 } from "zod";
+function createSelectTool(page) {
+  return {
+    description: "Select an option from a dropdown/select element by its index.",
+    inputSchema: z4.object({
+      index: z4.number().describe("The index of the select element"),
+      value: z4.string().describe("The option text or value to select")
+    }),
+    execute: async (args) => {
+      await page.selectOption(args.index, args.value);
+      return `Selected "${args.value}" in element [${args.index}]`;
+    }
+  };
+}
+
+// src/agent/tools/wait.ts
+import { z as z5 } from "zod";
+function createWaitTool() {
+  return {
+    description: "Wait for a specified number of seconds before continuing.",
+    inputSchema: z5.object({
+      seconds: z5.number().min(0.1).max(30).describe("Seconds to wait")
+    }),
+    execute: async (args) => {
+      await new Promise((r) => setTimeout(r, args.seconds * 1e3));
+      return `Waited ${args.seconds} seconds`;
+    }
+  };
+}
+
+// src/agent/tools/done.ts
+import { z as z6 } from "zod";
+function createDoneTool() {
+  return {
+    description: "Signal that the task is complete. Call this when you have finished the task or cannot proceed further.",
+    inputSchema: z6.object({
+      success: z6.boolean().describe("Whether the task was completed successfully"),
+      text: z6.string().describe("Summary of the result or explanation of failure")
+    }),
+    execute: async (args) => {
+      return JSON.stringify({ done: true, success: args.success, text: args.text });
+    }
+  };
+}
+
+// src/agent/tools/ask-user.ts
+import { z as z7 } from "zod";
+import { createInterface } from "readline";
+function createAskUserTool() {
+  return {
+    description: "Ask the user a question when you need clarification or input to proceed.",
+    inputSchema: z7.object({
+      question: z7.string().describe("The question to ask the user")
+    }),
+    execute: async (args) => {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      return new Promise((resolve) => {
+        rl.question(`
+\u{1F916} Agent asks: ${args.question}
+> `, (answer) => {
+          rl.close();
+          resolve(`User answered: ${answer}`);
+        });
+      });
+    }
+  };
+}
+
+// src/agent/tools/execute-js.ts
+import { z as z8 } from "zod";
+function createExecuteJsTool(page) {
+  return {
+    description: "Execute JavaScript code on the current page. Returns the result.",
+    inputSchema: z8.object({
+      code: z8.string().describe("JavaScript code to execute on the page")
+    }),
+    execute: async (args) => {
+      const result = await page.evaluate(args.code);
+      return typeof result === "string" ? result : JSON.stringify(result, null, 2);
+    }
+  };
+}
+
+// src/agent/tools/index.ts
+function createDefaultTools(page) {
+  return {
+    click_element_by_index: createClickTool(page),
+    input_text: createTypeTool(page),
+    scroll: createScrollTool(page),
+    select_dropdown_option: createSelectTool(page),
+    wait: createWaitTool(),
+    done: createDoneTool(),
+    ask_user: createAskUserTool(),
+    execute_javascript: createExecuteJsTool(page)
+  };
+}
+
+// src/agent/macro-tool.ts
+import { z as z9 } from "zod";
+
+// src/agent/auto-fixer.ts
+function normalizeResponse(raw, toolName, availableActions, toolSchemas) {
+  let result = { ...raw };
+  if (result.type === "function" && result.function) {
+    const fn = result.function;
+    if (typeof fn.arguments === "string") {
+      try {
+        result = JSON.parse(fn.arguments);
+      } catch {
+      }
+    } else if (typeof fn.arguments === "object") {
+      result = fn.arguments;
+    }
+  }
+  for (const [key, value] of Object.entries(result)) {
+    if (typeof value === "string") {
+      try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed === "object" && parsed !== null) {
+          result[key] = parsed;
+        }
+      } catch {
+      }
+    }
+  }
+  if (!result.action) {
+    for (const actionName of availableActions) {
+      if (actionName in result) {
+        result = {
+          ...result,
+          action: { [actionName]: result[actionName] }
+        };
+        delete result[actionName];
+        break;
+      }
+    }
+  }
+  if (!result.action) {
+    result.action = { wait: { seconds: 1 } };
+  }
+  if (typeof result.action === "string") {
+    if (availableActions.includes(result.action)) {
+      result.action = { [result.action]: {} };
+    } else {
+      result.action = { wait: { seconds: 1 } };
+    }
+  }
+  const action = result.action;
+  for (const [name, input] of Object.entries(action)) {
+    if (typeof input !== "object" || input === null) {
+      if (toolSchemas && toolSchemas[name]) {
+        const schema = toolSchemas[name].inputSchema;
+        const coerced = coercePrimitiveToSchema(input, schema);
+        if (coerced !== null) {
+          action[name] = coerced;
+          continue;
+        }
+      }
+      if (typeof input === "number") {
+        action[name] = { index: input };
+      } else if (typeof input === "string") {
+        action[name] = { text: input };
+      } else {
+        action[name] = {};
+      }
+    }
+    if (toolSchemas && toolSchemas[name] && typeof action[name] === "object") {
+      const schema = toolSchemas[name].inputSchema;
+      const validation = schema.safeParse(action[name]);
+      if (!validation.success) {
+        const fixed = attemptSchemaFix(action[name], schema, validation.error);
+        if (fixed) {
+          action[name] = fixed;
+        }
+      }
+    }
+  }
+  return result;
+}
+function coercePrimitiveToSchema(value, schema) {
+  try {
+    const def = schema._def;
+    if (def?.typeName !== "ZodObject") return null;
+    const shape = def.shape();
+    const keys = Object.keys(shape);
+    const requiredKeys = keys.filter((k) => {
+      const fieldDef = shape[k]?._def;
+      return fieldDef?.typeName !== "ZodOptional";
+    });
+    if (requiredKeys.length === 1) {
+      return { [requiredKeys[0]]: value };
+    }
+    const indexField = keys.find((k) => /index|idx|num|number/i.test(k));
+    if (indexField && typeof value === "number") {
+      return { [indexField]: value };
+    }
+    const textField = keys.find((k) => /text|value|query|code|question|url/i.test(k));
+    if (textField && typeof value === "string") {
+      return { [textField]: value };
+    }
+  } catch {
+  }
+  return null;
+}
+function attemptSchemaFix(input, schema, error) {
+  try {
+    const def = schema._def;
+    if (def?.typeName !== "ZodObject") return null;
+    const shape = def.shape();
+    const expectedKeys = Object.keys(shape);
+    const inputKeys = Object.keys(input);
+    const fixed = { ...input };
+    for (const issue of error.issues) {
+      if (issue.code === "invalid_type" && issue.path.length === 1) {
+        const key = String(issue.path[0]);
+        const val = input[key];
+        if (issue.expected === "number" && typeof val === "string") {
+          const num = Number(val);
+          if (!isNaN(num)) fixed[key] = num;
+        } else if (issue.expected === "string" && typeof val === "number") {
+          fixed[key] = String(val);
+        } else if (issue.expected === "boolean" && typeof val === "string") {
+          fixed[key] = val === "true";
+        }
+      }
+      if (issue.code === "unrecognized_keys") {
+        for (const k of issue.keys || []) {
+          delete fixed[k];
+        }
+      }
+    }
+    const result = schema.safeParse(fixed);
+    if (result.success) return fixed;
+  } catch {
+  }
+  return null;
+}
+
+// src/agent/macro-tool.ts
+function packMacroTool(tools) {
+  const actionSchemas = [];
+  const toolNames = [];
+  for (const [name, tool] of Object.entries(tools)) {
+    toolNames.push(name);
+    actionSchemas.push(
+      z9.object({ [name]: tool.inputSchema }).describe(tool.description)
+    );
+  }
+  const actionSchema = actionSchemas.length === 1 ? actionSchemas[0] : z9.union(actionSchemas);
+  const macroSchema = z9.object({
+    evaluation_previous_goal: z9.string().optional().describe("Evaluate whether the previous goal was achieved"),
+    memory: z9.string().optional().describe("Important information to remember for future steps"),
+    next_goal: z9.string().optional().describe("The next immediate goal to achieve"),
+    action: actionSchema.describe("The action to take")
+  });
+  return {
+    name: "AgentOutput",
+    description: "The agent's output containing reflection and action. Must be called every step.",
+    schema: macroSchema,
+    execute: async (args) => {
+      const normalized = normalizeResponse(args, "AgentOutput", toolNames, tools);
+      const action = normalized.action;
+      const [toolName, toolInput] = Object.entries(action)[0];
+      const tool = tools[toolName];
+      if (!tool) {
+        return `Error: Unknown tool "${toolName}". Available: ${toolNames.join(", ")}`;
+      }
+      try {
+        const result = await tool.execute(toolInput);
+        return result;
+      } catch (err) {
+        return `Error executing ${toolName}: ${err}`;
+      }
+    }
+  };
+}
+
+// src/agent/core.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var AgentCore = class {
+  page;
+  config;
+  llm;
+  history = [];
+  _status = "idle";
+  listeners = /* @__PURE__ */ new Map();
+  previousElementHashes = /* @__PURE__ */ new Set();
+  totalWaitTime = 0;
+  constructor(page, config) {
+    this.page = page;
+    this.config = config;
+    this.llm = new LLM(config.llm);
+  }
+  // ── Event system ──
+  on(event, listener) {
+    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+    this.listeners.get(event).add(listener);
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+  emit(event) {
+    const listeners = this.listeners.get(event.type);
+    if (listeners) {
+      for (const fn of listeners) {
+        try {
+          fn(event);
+        } catch {
+        }
+      }
+    }
+  }
+  get status() {
+    return this._status;
+  }
+  setStatus(newStatus) {
+    const prev = this._status;
+    this._status = newStatus;
+    this.emit({ type: "statuschange", status: newStatus, previousStatus: prev });
+  }
+  pushHistory(event) {
+    this.history.push(event);
+    this.emit({ type: "historychange", history: this.history });
+  }
+  async execute(task, abortSignal) {
+    this.setStatus("running");
+    this.history = [];
+    this.previousElementHashes.clear();
+    this.totalWaitTime = 0;
+    const maxSteps = this.config.maxSteps ?? 40;
+    const stepDelay = this.config.stepDelay ?? 0.4;
+    const tools = {
+      ...createDefaultTools(this.page),
+      ...this.config.customTools || {}
+    };
+    for (const [name, tool] of Object.entries(tools)) {
+      if (tool === null) delete tools[name];
+    }
+    const macroTool = packMacroTool(tools);
+    let systemPrompt;
+    try {
+      systemPrompt = readFileSync(join(__dirname, "prompts", "system.md"), "utf-8");
+    } catch {
+      systemPrompt = "You are an AI web agent that navigates web pages to complete tasks.";
+    }
+    if (this.config.instructions?.system) {
+      systemPrompt += "\n\n" + this.config.instructions.system;
+    }
+    let lastURL = "";
+    for (let step = 1; step <= maxSteps; step++) {
+      if (abortSignal?.aborted) {
+        this.setStatus("error");
+        return { success: false, data: "Aborted", history: this.history };
+      }
+      const browserState = await this.page.browserState().catch(() => ({
+        url: "",
+        title: "",
+        viewportWidth: 0,
+        viewportHeight: 0,
+        pageWidth: 0,
+        pageHeight: 0,
+        scrollX: 0,
+        scrollY: 0,
+        scrollPercent: 0,
+        pixelsAbove: 0,
+        pixelsBelow: 0
+      }));
+      const flatTree = await this.page.flatTree().catch(() => ({ rootId: "", map: {} }));
+      const pageContent = flatTreeToString(flatTree);
+      const currentHashes = /* @__PURE__ */ new Set();
+      let newElementCount = 0;
+      for (const node of Object.values(flatTree.map)) {
+        if (node.isInteractive && node.highlightIndex !== void 0) {
+          const hash = `${node.tagName}:${node.text || ""}:${JSON.stringify(node.attributes || {})}`;
+          currentHashes.add(hash);
+          if (!this.previousElementHashes.has(hash)) {
+            newElementCount++;
+          }
+        }
+      }
+      this.previousElementHashes = currentHashes;
+      const observations = [];
+      if (browserState.url !== lastURL && lastURL) {
+        observations.push(`Navigated to ${browserState.url}`);
+      }
+      lastURL = browserState.url;
+      if (newElementCount > 0 && step > 1) {
+        observations.push(`${newElementCount} new interactive element(s) appeared`);
+      }
+      if (this.totalWaitTime > 3) {
+        observations.push(`Total wait time: ${this.totalWaitTime.toFixed(1)}s \u2014 consider if page is still loading`);
+      }
+      if (step >= maxSteps - 5) {
+        observations.push(`Warning: ${maxSteps - step} steps remaining`);
+      }
+      if (this.config.instructions?.getPageInstructions) {
+        try {
+          const pi = this.config.instructions.getPageInstructions(browserState.url);
+          if (pi) observations.push(`Page instructions: ${pi}`);
+        } catch {
+        }
+      }
+      for (const obs of observations) {
+        this.pushHistory({ type: "observation", message: obs });
+        this.emit({ type: "activity", kind: "observation", message: obs, step });
+      }
+      const userPrompt = assembleUserPrompt(
+        task,
+        pageContent,
+        browserState,
+        this.history,
+        step,
+        maxSteps
+      );
+      const messages = [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userPrompt }
+      ];
+      log.step(step, `Thinking... (${browserState.url})`);
+      this.emit({ type: "activity", kind: "thinking", message: `Step ${step}: thinking`, step });
+      if (this.config.onBeforeStep) await this.config.onBeforeStep(step);
+      const startTime = Date.now();
+      let result;
+      try {
+        result = await this.llm.invoke(messages, macroTool, abortSignal);
+      } catch (err) {
+        log.error(`LLM error at step ${step}: ${err}`);
+        this.pushHistory({ type: "error", error: String(err), step });
+        this.emit({ type: "activity", kind: "error", message: String(err), step });
+        continue;
+      }
+      const duration = Date.now() - startTime;
+      const args = result.toolCall.args;
+      const action = args.action || args;
+      const [actionName, actionInput] = Object.entries(action)[0] || ["unknown", {}];
+      this.emit({ type: "activity", kind: "executing", message: actionName, step });
+      if (actionName === "wait") {
+        const secs = actionInput?.seconds || 0;
+        this.totalWaitTime += secs;
+      }
+      const stepEvent = {
+        type: "step",
+        step,
+        reflection: {
+          evaluation_previous_goal: args.evaluation_previous_goal || "",
+          memory: args.memory || "",
+          next_goal: args.next_goal || ""
+        },
+        action: { name: actionName, args: actionInput },
+        output: result.toolResult,
+        duration
+      };
+      this.pushHistory(stepEvent);
+      log.step(step, `Action: ${actionName} \u2192 ${result.toolResult.slice(0, 100)}`);
+      this.emit({ type: "activity", kind: "executed", message: `${actionName}: ${result.toolResult.slice(0, 80)}`, step, duration });
+      if (this.config.onAfterStep) await this.config.onAfterStep(this.history);
+      if (actionName === "done") {
+        try {
+          const doneResult = JSON.parse(result.toolResult);
+          this.setStatus("completed");
+          return { success: doneResult.success, data: doneResult.text || result.toolResult, history: this.history };
+        } catch {
+          this.setStatus("completed");
+          return { success: true, data: result.toolResult, history: this.history };
+        }
+      }
+      if (stepDelay > 0) {
+        await new Promise((r) => setTimeout(r, stepDelay * 1e3));
+      }
+    }
+    this.setStatus("error");
+    return { success: false, data: `Reached maximum steps (${maxSteps})`, history: this.history };
+  }
+};
+function assembleUserPrompt(task, pageContent, state, history, step, maxSteps) {
+  let prompt = `# Task
+${task}
+
+`;
+  prompt += `# Current Page
+`;
+  prompt += `URL: ${state.url}
+`;
+  prompt += `Title: ${state.title}
+`;
+  prompt += `Viewport: ${state.viewportWidth}x${state.viewportHeight} | Page height: ${state.pageHeight}px
+`;
+  prompt += `Scroll: ${state.scrollPercent}%`;
+  if (state.pixelsAbove > 50) prompt += ` | ${state.pixelsAbove}px above`;
+  if (state.pixelsBelow > 50) prompt += ` | ${state.pixelsBelow}px below`;
+  prompt += `
+Step: ${step}/${maxSteps}
+
+`;
+  prompt += `# Browser State
+${pageContent}
+
+`;
+  if (history.length > 0) {
+    prompt += `# History
+`;
+    const recent = history.slice(-10);
+    for (const event of recent) {
+      if (event.type === "step") {
+        const s = event;
+        prompt += `<step_${s.step}>
+`;
+        if (s.reflection) {
+          prompt += `  eval: ${s.reflection.evaluation_previous_goal}
+`;
+          prompt += `  memory: ${s.reflection.memory}
+`;
+          prompt += `  goal: ${s.reflection.next_goal}
+`;
+        }
+        prompt += `  action: ${s.action.name}(${JSON.stringify(s.action.args)})
+`;
+        prompt += `  result: ${s.output.slice(0, 200)}
+`;
+        prompt += `</step_${s.step}>
+`;
+      } else if (event.type === "observation") {
+        prompt += `<sys>${event.message}</sys>
+`;
+      }
+    }
+  }
+  return prompt;
+}
+
+// src/pipeline/template.ts
+var EXPR_RE = /\$\{\{\s*(.*?)\s*\}\}/g;
+function renderTemplate(template, ctx) {
+  if (typeof template !== "string") {
+    if (typeof template === "object" && template !== null) {
+      if (Array.isArray(template)) return template.map((v) => renderTemplate(v, ctx));
+      const result = {};
+      for (const [k, v] of Object.entries(template)) {
+        result[k] = renderTemplate(v, ctx);
+      }
+      return result;
+    }
+    return template;
+  }
+  const fullMatch = template.match(/^\$\{\{\s*(.*?)\s*\}\}$/);
+  if (fullMatch) {
+    return evaluateExpression(fullMatch[1], ctx);
+  }
+  return template.replace(EXPR_RE, (_, expr) => {
+    const val = evaluateExpression(expr, ctx);
+    return val === null || val === void 0 ? "" : String(val);
+  });
+}
+function evaluateExpression(expr, ctx) {
+  const parts = expr.split(/\s*\|\s*/);
+  let value = resolveValue(parts[0].trim(), ctx);
+  for (let i = 1; i < parts.length; i++) {
+    value = applyFilter(value, parts[i].trim());
+  }
+  return value;
+}
+function resolveValue(path, ctx) {
+  const arithMatch = path.match(/^(\w[\w.]*)\s*([+\-*])\s*(\d+)$/);
+  if (arithMatch) {
+    const base = Number(resolvePath(arithMatch[1], ctx));
+    const op = arithMatch[2];
+    const num = Number(arithMatch[3]);
+    if (op === "+") return base + num;
+    if (op === "-") return base - num;
+    if (op === "*") return base * num;
+  }
+  const orMatch = path.match(/^(.+?)\s*\|\|\s*(.+)$/);
+  if (orMatch) {
+    const left = resolvePath(orMatch[1].trim(), ctx);
+    if (left !== null && left !== void 0 && left !== "" && left !== false) return left;
+    const right = orMatch[2].trim();
+    if (right.startsWith("'") && right.endsWith("'") || right.startsWith('"') && right.endsWith('"')) {
+      return right.slice(1, -1);
+    }
+    return resolvePath(right, ctx);
+  }
+  if (path.startsWith("'") && path.endsWith("'") || path.startsWith('"') && path.endsWith('"')) {
+    return path.slice(1, -1);
+  }
+  if (!isNaN(Number(path)) && path !== "") return Number(path);
+  return resolvePath(path, ctx);
+}
+function resolvePath(path, ctx) {
+  if (path === "index") return ctx.index ?? 0;
+  const parts = path.split(".");
+  let root;
+  if (parts[0] === "args") {
+    root = ctx.args;
+    parts.shift();
+  } else if (parts[0] === "item") {
+    root = ctx.item;
+    parts.shift();
+  } else if (parts[0] === "data") {
+    root = ctx.data;
+    parts.shift();
+  } else {
+    root = getNestedValue(ctx.item, parts);
+    if (root !== void 0) return root;
+    root = getNestedValue(ctx.args, parts);
+    if (root !== void 0) return root;
+    root = getNestedValue(ctx.data, parts);
+    if (root !== void 0) return root;
+    return void 0;
+  }
+  return getNestedValue(root, parts);
+}
+function getNestedValue(obj, parts) {
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current === "object") {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function applyFilter(value, filter) {
+  const match = filter.match(/^(\w+)(?:\((.+)\))?$/);
+  if (!match) return value;
+  const name = match[1];
+  const arg = match[2]?.replace(/^['"]|['"]$/g, "");
+  switch (name) {
+    case "default":
+      return value === null || value === void 0 || value === "" ? arg : value;
+    case "join":
+      return Array.isArray(value) ? value.join(arg || ", ") : value;
+    case "upper":
+      return typeof value === "string" ? value.toUpperCase() : value;
+    case "lower":
+      return typeof value === "string" ? value.toLowerCase() : value;
+    case "trim":
+      return typeof value === "string" ? value.trim() : value;
+    case "truncate": {
+      const len = parseInt(arg || "100");
+      if (typeof value === "string" && value.length > len) return value.slice(0, len) + "...";
+      return value;
+    }
+    case "replace": {
+      if (typeof value !== "string" || !arg) return value;
+      const [from, to] = arg.split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, ""));
+      return value.replaceAll(from, to || "");
+    }
+    case "keys":
+      return typeof value === "object" && value !== null ? Object.keys(value) : [];
+    case "length":
+      return Array.isArray(value) ? value.length : typeof value === "string" ? value.length : 0;
+    case "first":
+      return Array.isArray(value) ? value[0] : value;
+    case "last":
+      return Array.isArray(value) ? value[value.length - 1] : value;
+    case "json":
+      return JSON.stringify(value);
+    case "slugify":
+      return typeof value === "string" ? value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") : value;
+    case "sanitize":
+      return typeof value === "string" ? value.replace(/[<>:"/\\|?*\x00-\x1f]/g, "_").replace(/__+/g, "_").trim() : value;
+    case "ext": {
+      if (typeof value !== "string") return "";
+      const extMatch = value.match(/\.([a-zA-Z0-9]+)(?:\?.*)?$/);
+      return extMatch ? extMatch[1] : "";
+    }
+    case "basename": {
+      if (typeof value !== "string") return "";
+      try {
+        return new URL(value).pathname.split("/").pop() || "";
+      } catch {
+      }
+      return value.split("/").pop() || "";
+    }
+    default:
+      return value;
+  }
+}
+
+// src/pipeline/registry.ts
+var stepHandlers = /* @__PURE__ */ new Map();
+function registerStep(name, handler) {
+  stepHandlers.set(name, handler);
+}
+function getStep(name) {
+  return stepHandlers.get(name);
+}
+
+// src/pipeline/steps/fetch.ts
+async function fetchBatchInBrowser(page, urls, method, headers, concurrency) {
+  const headersJs = JSON.stringify(headers);
+  const urlsJs = JSON.stringify(urls);
+  return page.evaluate(`
+    (async () => {
+      const urls = ${urlsJs};
+      const method = ${JSON.stringify(method)};
+      const headers = ${headersJs};
+      const concurrency = ${concurrency};
+
+      const results = new Array(urls.length);
+      let idx = 0;
+
+      async function worker() {
+        while (idx < urls.length) {
+          const i = idx++;
+          try {
+            const resp = await fetch(urls[i], { method, headers, credentials: "include" });
+            results[i] = await resp.json();
+          } catch (e) {
+            results[i] = { error: e.message };
+          }
+        }
+      }
+
+      const workers = Array.from({ length: Math.min(concurrency, urls.length) }, () => worker());
+      await Promise.all(workers);
+      return results;
+    })()
+  `);
+}
+async function mapConcurrent(items, limit, fn) {
+  const results = new Array(items.length);
+  let index = 0;
+  async function worker() {
+    while (index < items.length) {
+      const i = index++;
+      results[i] = await fn(items[i], i);
+    }
+  }
+  const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
+async function fetchSingle(page, url, method, headers) {
+  if (page) {
+    const headersJs = JSON.stringify(headers);
+    const urlJs = JSON.stringify(url);
+    const methodJs = JSON.stringify(method);
+    return page.evaluate(`
+      (async () => {
+        const resp = await fetch(${urlJs}, {
+          method: ${methodJs}, headers: ${headersJs}, credentials: "include"
+        });
+        return await resp.json();
+      })()
+    `);
+  }
+  const resp = await fetch(url, { method, headers });
+  return resp.json();
+}
+registerStep("fetch", async (ctx, params) => {
+  const data = ctx.data;
+  const urlOrObj = typeof params === "string" ? params : params?.url ?? "";
+  const method = params?.method || "GET";
+  const rawHeaders = params?.headers ?? {};
+  const rawParams = params?.params ?? {};
+  const urlTemplate = String(urlOrObj);
+  const headers = {};
+  for (const [k, v] of Object.entries(rawHeaders)) {
+    headers[k] = String(renderTemplate(v, { args: ctx.args, data }));
+  }
+  if (Array.isArray(data) && urlTemplate.includes("item")) {
+    const concurrency = typeof params?.concurrency === "number" ? params.concurrency : 5;
+    const renderedParams2 = {};
+    for (const [k, v] of Object.entries(rawParams)) {
+      renderedParams2[k] = String(renderTemplate(v, { args: ctx.args, data }));
+    }
+    const urls = data.map((item, index) => {
+      let url2 = String(renderTemplate(urlTemplate, { args: ctx.args, data, item, index }));
+      if (Object.keys(renderedParams2).length > 0) {
+        const qs = new URLSearchParams(renderedParams2).toString();
+        url2 = `${url2}${url2.includes("?") ? "&" : "?"}${qs}`;
+      }
+      return url2;
+    });
+    if (ctx.page) {
+      return fetchBatchInBrowser(ctx.page, urls, method.toUpperCase(), headers, concurrency);
+    }
+    return mapConcurrent(urls, concurrency, async (url2) => {
+      return fetchSingle(null, url2, method.toUpperCase(), headers);
+    });
+  }
+  let url = String(renderTemplate(urlOrObj, { args: ctx.args, data }));
+  const renderedParams = {};
+  for (const [k, v] of Object.entries(rawParams)) {
+    renderedParams[k] = String(renderTemplate(v, { args: ctx.args, data }));
+  }
+  if (Object.keys(renderedParams).length > 0) {
+    const qs = new URLSearchParams(renderedParams).toString();
+    url = `${url}${url.includes("?") ? "&" : "?"}${qs}`;
+  }
+  return fetchSingle(ctx.page, url, method.toUpperCase(), headers);
+});
+
+// src/pipeline/steps/browser.ts
+registerStep("navigate", async (ctx, params) => {
+  if (!ctx.page) throw new Error("Browser page required for navigate step");
+  const url = renderTemplate(params, { args: ctx.args, data: ctx.data });
+  await ctx.page.goto(url);
+  return ctx.data;
+});
+registerStep("click", async (ctx, params) => {
+  if (!ctx.page) throw new Error("Browser page required for click step");
+  const ref = renderTemplate(params, { args: ctx.args, data: ctx.data });
+  await ctx.page.click(ref);
+  return ctx.data;
+});
+registerStep("type", async (ctx, params) => {
+  if (!ctx.page) throw new Error("Browser page required for type step");
+  const p = renderTemplate(params, { args: ctx.args, data: ctx.data });
+  await ctx.page.typeText(p.ref, p.text);
+  if (p.submit) await ctx.page.pressKey("Enter");
+  return ctx.data;
+});
+registerStep("wait", async (ctx, params) => {
+  if (!ctx.page) throw new Error("Browser page required for wait step");
+  const rendered = renderTemplate(params, { args: ctx.args, data: ctx.data });
+  if (typeof rendered === "number") {
+    await ctx.page.wait(rendered);
+  } else {
+    await ctx.page.wait(rendered);
+  }
+  return ctx.data;
+});
+registerStep("press", async (ctx, params) => {
+  if (!ctx.page) throw new Error("Browser page required for press step");
+  const key = renderTemplate(params, { args: ctx.args, data: ctx.data });
+  await ctx.page.pressKey(key);
+  return ctx.data;
+});
+registerStep("snapshot", async (ctx, _params) => {
+  if (!ctx.page) throw new Error("Browser page required for snapshot step");
+  return ctx.page.snapshot();
+});
+registerStep("evaluate", async (ctx, params) => {
+  if (!ctx.page) throw new Error("Browser page required for evaluate step");
+  const js = renderTemplate(params, { args: ctx.args, data: ctx.data });
+  const result = await ctx.page.evaluate(js);
+  if (typeof result === "string") {
+    try {
+      return JSON.parse(result);
+    } catch {
+      return result;
+    }
+  }
+  return result;
+});
+
+// src/pipeline/steps/transform.ts
+registerStep("select", async (ctx, params) => {
+  const path = renderTemplate(params, { args: ctx.args, data: ctx.data });
+  const parts = path.split(".");
+  let current = ctx.data;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    const indexMatch = part.match(/^(\w+)\[(\d+)\]$/);
+    if (indexMatch) {
+      current = current[indexMatch[1]];
+      if (Array.isArray(current)) current = current[Number(indexMatch[2])];
+      else return void 0;
+      continue;
+    }
+    const wildcardMatch = part.match(/^(\w+)\[\*\]$/);
+    if (wildcardMatch) {
+      current = current[wildcardMatch[1]];
+      if (!Array.isArray(current)) return void 0;
+      const remaining = parts.slice(parts.indexOf(part) + 1);
+      if (remaining.length > 0) {
+        return current.map((item) => {
+          let val = item;
+          for (const r of remaining) {
+            if (val === null || val === void 0) return void 0;
+            val = val[r];
+          }
+          return val;
+        });
+      }
+      continue;
+    }
+    current = current[part];
+  }
+  return current;
+});
+registerStep("map", async (ctx, params) => {
+  if (!Array.isArray(ctx.data)) throw new Error("map requires array data");
+  const template = params;
+  return ctx.data.map(
+    (item, index) => renderTemplate(template, { args: ctx.args, item, data: ctx.data, index })
+  );
+});
+registerStep("filter", async (ctx, params) => {
+  if (!Array.isArray(ctx.data)) throw new Error("filter requires array data");
+  const expr = params;
+  return ctx.data.filter((item, index) => {
+    const result = renderTemplate(`\${{ ${expr} }}`, { args: ctx.args, item, data: ctx.data, index });
+    return Boolean(result);
+  });
+});
+registerStep("sort", async (ctx, params) => {
+  if (!Array.isArray(ctx.data)) throw new Error("sort requires array data");
+  const p = params;
+  const sorted = [...ctx.data].sort((a, b) => {
+    const va = a[p.by];
+    const vb = b[p.by];
+    if (typeof va === "number" && typeof vb === "number") return va - vb;
+    return String(va).localeCompare(String(vb));
+  });
+  return p.order === "desc" ? sorted.reverse() : sorted;
+});
+registerStep("limit", async (ctx, params) => {
+  if (!Array.isArray(ctx.data)) return ctx.data;
+  const n = renderTemplate(params, { args: ctx.args, data: ctx.data });
+  return ctx.data.slice(0, Number(n) || 20);
+});
+
+// src/pipeline/steps/intercept.ts
+registerStep("intercept", async (ctx, params) => {
+  if (!ctx.page) throw new Error("Browser page required for intercept step");
+  const p = params;
+  const pattern = renderTemplate(p.pattern, { args: ctx.args, data: ctx.data });
+  await ctx.page.installInterceptor(pattern);
+  if (p.trigger) {
+    const trigger = renderTemplate(p.trigger, { args: ctx.args, data: ctx.data });
+    const [action, value] = trigger.split(":");
+    switch (action) {
+      case "navigate":
+        await ctx.page.goto(value);
+        break;
+      case "click":
+        await ctx.page.click(value);
+        break;
+      case "evaluate":
+        await ctx.page.evaluate(value);
+        break;
+      case "scroll":
+        await ctx.page.scroll("down");
+        break;
+    }
+  }
+  const timeout = p.timeout || 10;
+  await ctx.page.wait(timeout);
+  const requests = await ctx.page.getInterceptedRequests();
+  if (requests.length === 0) return ctx.data;
+  let result = requests.map((r) => r.body);
+  if (result && Array.isArray(result) && result.length === 1) result = result[0];
+  if (p.select && result) {
+    const parts = p.select.split(".");
+    let current = result;
+    for (const part of parts) {
+      if (current && typeof current === "object") {
+        current = current[part];
+      }
+    }
+    result = current;
+  }
+  return result;
+});
+
+// src/pipeline/steps/download.ts
+import { writeFileSync, mkdirSync, existsSync as existsSync2 } from "fs";
+import { join as join2, basename } from "path";
+import { execSync } from "child_process";
+import { tmpdir } from "os";
+var DownloadProgressTracker = class {
+  total;
+  completed = 0;
+  failed = 0;
+  totalBytes = 0;
+  constructor(total) {
+    this.total = total;
+  }
+  success(bytes) {
+    this.completed++;
+    this.totalBytes += bytes;
+  }
+  fail() {
+    this.completed++;
+    this.failed++;
+  }
+  summary() {
+    return `Downloaded ${this.completed - this.failed}/${this.total} files (${formatBytes(this.totalBytes)})${this.failed > 0 ? `, ${this.failed} failed` : ""}`;
+  }
+};
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+async function exportCookiesNetscape(ctx, domain) {
+  if (!ctx.page) return null;
+  try {
+    const cookies = await ctx.page.getCookies({ domain });
+    if (cookies.length === 0) return null;
+    const lines = ["# Netscape HTTP Cookie File"];
+    for (const c of cookies) {
+      const httpOnly = c.httpOnly ? "TRUE" : "FALSE";
+      const secure = c.secure ? "TRUE" : "FALSE";
+      const expires = c.expires ? Math.floor(c.expires) : 0;
+      lines.push(`${c.domain || domain}	TRUE	${c.path || "/"}	${secure}	${expires}	${c.name}	${c.value}`);
+    }
+    const tmpFile = join2(tmpdir(), `lobster-cookies-${Date.now()}.txt`);
+    writeFileSync(tmpFile, lines.join("\n"));
+    return tmpFile;
+  } catch {
+    return null;
+  }
+}
+function hasYtDlp() {
+  try {
+    execSync("yt-dlp --version", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function downloadWithYtDlp(url, dir, opts) {
+  const args = ["yt-dlp", "-o", join2(dir, opts.filename || "%(title)s.%(ext)s")];
+  if (opts.format) args.push("-f", opts.format);
+  if (opts.cookieFile) args.push("--cookies", opts.cookieFile);
+  args.push("--no-warnings", "--no-progress", url);
+  try {
+    execSync(args.join(" "), { stdio: "pipe", timeout: 3e5 });
+    return { url, file: dir, success: true };
+  } catch (err) {
+    return { url, file: "", success: false, error: err.message?.slice(0, 200) };
+  }
+}
+async function downloadPool(items, concurrency, fn) {
+  const results = new Array(items.length);
+  let idx = 0;
+  async function worker() {
+    while (idx < items.length) {
+      const i = idx++;
+      results[i] = await fn(items[i], i);
+    }
+  }
+  const workers = Array.from(
+    { length: Math.min(concurrency, items.length) },
+    () => worker()
+  );
+  await Promise.all(workers);
+  return results;
+}
+registerStep("download", async (ctx, params) => {
+  const p = params;
+  const dir = renderTemplate(p.dir || "./downloads", { args: ctx.args, data: ctx.data });
+  if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
+  const concurrency = p.concurrency || 3;
+  const skipExisting = p.skip_existing ?? false;
+  const timeout = (p.timeout || 60) * 1e3;
+  const items = [];
+  if (p.url) {
+    items.push({
+      url: renderTemplate(p.url, { args: ctx.args, data: ctx.data }),
+      index: 0
+    });
+  } else if (Array.isArray(ctx.data)) {
+    for (let i = 0; i < ctx.data.length; i++) {
+      const item = ctx.data[i];
+      const url = typeof item === "string" ? item : item.url;
+      if (url) items.push({ url, item, index: i });
+    }
+  }
+  if (items.length === 0) return [];
+  const tracker = new DownloadProgressTracker(items.length);
+  if (p.video) {
+    if (!hasYtDlp()) {
+      throw new Error("yt-dlp not found. Install: brew install yt-dlp (mac) or pip install yt-dlp");
+    }
+    const cookieFile = await exportCookiesNetscape(ctx, new URL(items[0].url).hostname);
+    const results2 = await downloadPool(items, Math.min(concurrency, 2), async (entry) => {
+      const result = downloadWithYtDlp(entry.url, dir, {
+        format: p.format,
+        cookieFile,
+        filename: p.filename ? renderTemplate(p.filename, { args: ctx.args, item: entry.item, data: ctx.data, index: entry.index }) : void 0
+      });
+      if (result.success) tracker.success(0);
+      else tracker.fail();
+      return result;
+    });
+    if (cookieFile) try {
+      __require("fs").unlinkSync(cookieFile);
+    } catch {
+    }
+    if (ctx.debug) console.log(tracker.summary());
+    return results2;
+  }
+  if (p.content) {
+    const results2 = await downloadPool(items, concurrency, async (entry) => {
+      try {
+        const resp = await fetch(entry.url, {
+          signal: AbortSignal.timeout(timeout)
+        });
+        if (!resp.ok) return { url: entry.url, file: "", success: false, error: `HTTP ${resp.status}` };
+        let content;
+        const html = await resp.text();
+        if (p.content === "html") {
+          content = html;
+        } else if (p.content === "text") {
+          content = html.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+        } else if (p.content === "json") {
+          try {
+            content = JSON.stringify(JSON.parse(html), null, 2);
+          } catch {
+            content = html;
+          }
+        } else {
+          content = html.replace(/<h[1-6][^>]*>(.*?)<\/h[1-6]>/gi, "\n## $1\n").replace(/<p[^>]*>(.*?)<\/p>/gi, "\n$1\n").replace(/<a[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>/gi, "[$2]($1)").replace(/<[^>]+>/g, "").replace(/\n{3,}/g, "\n\n").trim();
+        }
+        const filename = p.filename ? renderTemplate(p.filename, { args: ctx.args, item: entry.item, data: ctx.data, index: entry.index }) : basename(new URL(entry.url).pathname).replace(/\.[^.]+$/, "") + (p.content === "json" ? ".json" : ".md");
+        const filepath = join2(dir, filename);
+        if (p.metadata) {
+          const meta = renderTemplate(p.metadata, { args: ctx.args, item: entry.item, data: ctx.data, index: entry.index });
+          const header = Object.entries(meta).map(([k, v]) => `${k}: ${v}`).join("\n");
+          content = `---
+${header}
+---
+
+${content}`;
+        }
+        writeFileSync(filepath, content, "utf-8");
+        tracker.success(Buffer.byteLength(content));
+        return { url: entry.url, file: filepath, success: true, size: Buffer.byteLength(content), content: content.slice(0, 200) };
+      } catch (err) {
+        tracker.fail();
+        return { url: entry.url, file: "", success: false, error: err.message };
+      }
+    });
+    if (ctx.debug) console.log(tracker.summary());
+    return results2;
+  }
+  const results = await downloadPool(items, concurrency, async (entry) => {
+    try {
+      const filename = p.filename ? renderTemplate(p.filename, { args: ctx.args, item: entry.item, data: ctx.data, index: entry.index }) : decodeURIComponent(basename(new URL(entry.url).pathname)) || `download-${entry.index}`;
+      const filepath = join2(dir, filename);
+      if (skipExisting && existsSync2(filepath)) {
+        tracker.success(0);
+        return { url: entry.url, file: filepath, success: true, size: 0 };
+      }
+      const resp = await fetch(entry.url, {
+        signal: AbortSignal.timeout(timeout)
+      });
+      if (!resp.ok) {
+        tracker.fail();
+        return { url: entry.url, file: "", success: false, error: `HTTP ${resp.status}` };
+      }
+      const buffer = Buffer.from(await resp.arrayBuffer());
+      writeFileSync(filepath, buffer);
+      tracker.success(buffer.length);
+      return { url: entry.url, file: filepath, success: true, size: buffer.length };
+    } catch (err) {
+      tracker.fail();
+      return { url: entry.url, file: "", success: false, error: err.message };
+    }
+  });
+  if (ctx.debug) console.log(tracker.summary());
+  return results;
+});
+
+// src/pipeline/steps/tap.ts
+registerStep("tap", async (ctx, params) => {
+  if (!ctx.page) throw new Error("Browser page required for tap step");
+  const p = renderTemplate(params, { args: ctx.args, data: ctx.data });
+  const storeName = p.store;
+  const actionName = p.action;
+  const capturePattern = p.capture;
+  const actionArgs = p.args || [];
+  const timeoutSec = p.timeout || 5;
+  const selectPath = p.select;
+  const result = await ctx.page.evaluate(`
+    (async () => {
+      let captured = null;
+      let captureResolve;
+      const capturePromise = new Promise(r => { captureResolve = r; });
+      const capturePattern = ${JSON.stringify(capturePattern)};
+      const timeoutMs = ${timeoutSec * 1e3};
+
+      // 1. Patch fetch
+      const origFetch = window.fetch;
+      window.fetch = async function(...args) {
+        const resp = await origFetch.apply(this, args);
+        try {
+          const url = typeof args[0] === 'string' ? args[0] : args[0]?.url || '';
+          if (url.includes(capturePattern) && !captured) {
+            captured = await resp.clone().json();
+            captureResolve();
+          }
+        } catch {}
+        return resp;
+      };
+
+      // 2. Patch XHR
+      const origSend = XMLHttpRequest.prototype.send;
+      const origOpen = XMLHttpRequest.prototype.open;
+      XMLHttpRequest.prototype.open = function(method, url, ...rest) {
+        this.__tapUrl = url;
+        return origOpen.call(this, method, url, ...rest);
+      };
+      XMLHttpRequest.prototype.send = function(...args) {
+        this.addEventListener('load', function() {
+          if (this.__tapUrl?.includes(capturePattern) && !captured) {
+            try {
+              captured = JSON.parse(this.responseText);
+              captureResolve();
+            } catch {}
+          }
+        });
+        return origSend.apply(this, args);
+      };
+
+      try {
+        // 3. Find the store
+        const app = document.querySelector('#app');
+        let store = null;
+
+        // Try Pinia via __vue_app__
+        if (app?.__vue_app__) {
+          const pinia = app.__vue_app__.config?.globalProperties?.$pinia;
+          if (pinia?._s) {
+            store = pinia._s.get(${JSON.stringify(storeName)});
+          }
+          // Try Vuex
+          if (!store) {
+            const vuex = app.__vue_app__.config?.globalProperties?.$store;
+            if (vuex) store = vuex;
+          }
+        }
+
+        // Fallback: global pinia
+        if (!store && window.__pinia?._s) {
+          store = window.__pinia._s.get(${JSON.stringify(storeName)});
+        }
+
+        if (!store) {
+          return { error: 'Store not found: ' + ${JSON.stringify(storeName)} };
+        }
+
+        // 4. Call the action
+        const actionFn = store[${JSON.stringify(actionName)}];
+        if (typeof actionFn !== 'function') {
+          return { error: 'Action not found: ' + ${JSON.stringify(actionName)} };
+        }
+
+        await actionFn.apply(store, ${JSON.stringify(actionArgs)});
+
+        // 5. Wait for capture
+        if (!captured) {
+          await Promise.race([
+            capturePromise,
+            new Promise(r => setTimeout(r, timeoutMs)),
+          ]);
+        }
+      } finally {
+        // 6. Restore originals
+        window.fetch = origFetch;
+        XMLHttpRequest.prototype.send = origSend;
+        XMLHttpRequest.prototype.open = origOpen;
+      }
+
+      return captured;
+    })()
+  `);
+  if (!result) return null;
+  if (result?.error) {
+    throw new Error(result.error);
+  }
+  if (selectPath) {
+    let current = result;
+    for (const part of selectPath.split(".")) {
+      if (current === null || current === void 0) return null;
+      current = current[part];
+    }
+    return current;
+  }
+  return result;
+});
+
+// src/pipeline/executor.ts
+async function executePipeline(steps, page, args, debug = false) {
+  const ctx = { page, args, data: null, debug };
+  for (let i = 0; i < steps.length; i++) {
+    const stepDef = steps[i];
+    const [stepName, params] = Object.entries(stepDef)[0];
+    const handler = getStep(stepName);
+    if (!handler) {
+      throw new Error(`Unknown pipeline step: ${stepName}`);
+    }
+    if (debug) {
+      log.step(i + 1, `${stepName}`);
+    }
+    ctx.data = await handler(ctx, params);
+    if (debug && ctx.data !== void 0) {
+      const preview = JSON.stringify(ctx.data)?.slice(0, 200);
+      log.dim(`  \u2192 ${preview}...`);
+    }
+  }
+  return ctx.data;
+}
+
+// src/utils/timeout.ts
+function runWithTimeout(promise, timeoutMs, label = "Operation") {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error(`${label} timed out after ${timeoutMs}ms`)),
+      timeoutMs
+    );
+    promise.then((result) => {
+      clearTimeout(timer);
+      resolve(result);
+    }).catch((err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+// src/router/index.ts
+var SmartRouter = class {
+  config;
+  browserManager;
+  constructor(config) {
+    this.config = config;
+    this.browserManager = new BrowserManager({
+      executablePath: config.browser.executablePath || void 0,
+      headless: config.browser.headless,
+      cdpEndpoint: config.browser.cdpEndpoint || void 0
+    });
+  }
+  async execute(request) {
+    const decision = makeRoutingDecision(request);
+    log.debug(`Routing: Level ${ExecutionLevel[decision.level]} \u2014 ${decision.reason}`);
+    try {
+      switch (decision.level) {
+        case 0 /* HTTP */:
+          return await this.executeHttp(request);
+        case 2 /* ADAPTER */:
+          return await this.executeAdapter(request, decision);
+        case 1 /* BROWSER */:
+        case 3 /* AGENT */:
+          return await this.executeAgent(request);
+      }
+    } catch (err) {
+      if (decision.level < 3 /* AGENT */) {
+        log.warn(`Level ${ExecutionLevel[decision.level]} failed, escalating...`);
+        return this.execute({
+          ...request,
+          task: request.task || `Fetch content from ${request.url}`
+        });
+      }
+      throw err;
+    }
+  }
+  async executeHttp(request) {
+    if (!request.url) throw new Error("URL required for HTTP execution");
+    const result = await directFetch(request.url);
+    return { data: result.body, format: request.format || "json" };
+  }
+  async executeAdapter(request, decision) {
+    const adapter = decision.adapter;
+    const args = request.args || {};
+    for (const arg of adapter.args) {
+      if (args[arg.name] === void 0 && arg.default !== void 0) {
+        args[arg.name] = arg.default;
+      }
+    }
+    let data;
+    if (adapter.pipeline) {
+      let page = null;
+      if (adapter.browser !== false && adapter.strategy !== "public" /* PUBLIC */) {
+        const rawPage = await this.browserManager.newPage();
+        page = new PuppeteerPage(rawPage);
+        if (adapter.domain) {
+          await page.goto(`https://${adapter.domain}`);
+        }
+      }
+      try {
+        data = await executePipeline(adapter.pipeline, page, args);
+      } finally {
+        if (page) await page.close();
+      }
+    } else if (adapter.func) {
+      const rawPage = await this.browserManager.newPage();
+      const page = new PuppeteerPage(rawPage);
+      try {
+        if (adapter.domain) {
+          await page.goto(`https://${adapter.domain}`);
+        }
+        data = await runWithTimeout(
+          adapter.func(page, args),
+          (adapter.timeoutSeconds || this.config.browser.commandTimeout) * 1e3,
+          `${adapter.site}/${adapter.name}`
+        );
+      } finally {
+        await page.close();
+      }
+    } else {
+      throw new Error(`Adapter ${adapter.site}/${adapter.name} has neither func nor pipeline`);
+    }
+    return { data, format: request.format || "table" };
+  }
+  async executeAgent(request) {
+    if (!this.config.llm.apiKey) {
+      throw new Error("LLM API key required for agent mode. Run: lobster config set llm.apiKey <key>");
+    }
+    const rawPage = await this.browserManager.newPage();
+    const page = new PuppeteerPage(rawPage);
+    try {
+      if (request.url) {
+        await page.goto(request.url);
+      }
+      const agent = new AgentCore(page, {
+        llm: this.config.llm,
+        maxSteps: this.config.agent.maxSteps,
+        stepDelay: this.config.agent.stepDelay
+      });
+      const task = request.task || `Extract content from ${request.url}`;
+      const result = await agent.execute(task);
+      return { data: result.data, format: request.format || "json" };
+    } finally {
+      await page.close();
+    }
+  }
+  async close() {
+    await this.browserManager.close();
+  }
+};
+export {
+  SmartRouter
+};
+//# sourceMappingURL=index.js.map