lobster-cli 0.1.0

package/dist/browser/index.js

@@ -0,0 +1,2034 @@
+// 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
+function buildSnapshotScript(previousHashes) {
+  return SNAPSHOT_SCRIPT_FN(previousHashes || []);
+}
+function SNAPSHOT_SCRIPT_FN(prevHashes) {
+  return `
+(() => {
+  let idx = 0;
+  const __prevHashes = new Set(${JSON.stringify(prevHashes)});
+  const __currentHashes = [];
+`;
+}
+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/browser/dom/interactive.ts
+var INTERACTIVE_ELEMENTS_SCRIPT = `
+(() => {
+  const results = [];
+
+  function classify(el) {
+    const tag = el.tagName.toLowerCase();
+    const role = el.getAttribute('role');
+    const types = [];
+
+    // Native interactive
+    if (['a', 'button', 'input', 'select', 'textarea', 'details', 'summary'].includes(tag)) {
+      types.push('native');
+    }
+
+    // ARIA role interactive
+    if (role && ['button', 'link', 'textbox', 'checkbox', 'radio', 'combobox', 'tab', 'switch', 'menuitem', 'slider'].includes(role)) {
+      types.push('aria');
+    }
+
+    // Contenteditable
+    if (el.contentEditable === 'true') types.push('contenteditable');
+
+    // Focusable
+    if (el.tabIndex >= 0 && el.getAttribute('tabindex') !== null) types.push('focusable');
+
+    // Has click listener (approximate)
+    if (el.onclick) types.push('listener');
+
+    return types;
+  }
+
+  let idx = 0;
+  const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT);
+  let node;
+  while (node = walker.nextNode()) {
+    const types = classify(node);
+    if (types.length === 0) continue;
+
+    const style = getComputedStyle(node);
+    if (style.display === 'none' || style.visibility === 'hidden') continue;
+
+    const rect = node.getBoundingClientRect();
+    results.push({
+      index: idx++,
+      tag: node.tagName.toLowerCase(),
+      role: node.getAttribute('role') || '',
+      text: (node.textContent || '').trim().slice(0, 100),
+      types,
+      ariaLabel: node.getAttribute('aria-label') || '',
+      rect: { x: rect.x, y: rect.y, width: rect.width, height: rect.height },
+    });
+  }
+
+  return results;
+})()
+`;
+
+// src/browser/wait.ts
+async function waitForCondition(page, condition, timeout = 3e4) {
+  switch (condition) {
+    case "load":
+      await page.waitForNavigation({ waitUntil: "load", timeout }).catch(() => {
+      });
+      break;
+    case "domcontentloaded":
+      await page.waitForNavigation({ waitUntil: "domcontentloaded", timeout }).catch(() => {
+      });
+      break;
+    case "networkidle0":
+      await page.waitForNavigation({ waitUntil: "networkidle0", timeout }).catch(() => {
+      });
+      break;
+    case "networkidle2":
+      await page.waitForNavigation({ waitUntil: "networkidle2", timeout }).catch(() => {
+      });
+      break;
+  }
+}
+
+// src/browser/lightpanda.ts
+var SELF_CLOSING = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var RAWTEXT_TAGS = /* @__PURE__ */ new Set(["script", "style", "textarea", "title"]);
+function parseHtml(html) {
+  const root = [];
+  const stack = [{ node: { type: "element", tag: "root", children: root }, children: root }];
+  let pos = 0;
+  function current() {
+    return stack[stack.length - 1];
+  }
+  function addText(text) {
+    if (!text) return;
+    const decoded = decodeEntities(text);
+    if (decoded.trim() || decoded.includes("\n")) {
+      current().children.push({ type: "text", text: decoded });
+    }
+  }
+  while (pos < html.length) {
+    const nextTag = html.indexOf("<", pos);
+    if (nextTag === -1) {
+      addText(html.slice(pos));
+      break;
+    }
+    if (nextTag > pos) {
+      addText(html.slice(pos, nextTag));
+    }
+    if (html.startsWith("<!--", nextTag)) {
+      const endComment = html.indexOf("-->", nextTag + 4);
+      pos = endComment === -1 ? html.length : endComment + 3;
+      continue;
+    }
+    if (html.startsWith("<!", nextTag) || html.startsWith("<?", nextTag)) {
+      const endDoctype = html.indexOf(">", nextTag);
+      pos = endDoctype === -1 ? html.length : endDoctype + 1;
+      continue;
+    }
+    if (html[nextTag + 1] === "/") {
+      const endClose = html.indexOf(">", nextTag);
+      if (endClose === -1) {
+        pos = html.length;
+        break;
+      }
+      const closeTag = html.slice(nextTag + 2, endClose).trim().toLowerCase();
+      pos = endClose + 1;
+      for (let i = stack.length - 1; i > 0; i--) {
+        if (stack[i].node.tag === closeTag) {
+          stack.length = i;
+          break;
+        }
+      }
+      continue;
+    }
+    const tagEnd = html.indexOf(">", nextTag);
+    if (tagEnd === -1) {
+      pos = html.length;
+      break;
+    }
+    const tagContent = html.slice(nextTag + 1, tagEnd);
+    const selfClose = tagContent.endsWith("/");
+    const cleanContent = selfClose ? tagContent.slice(0, -1).trim() : tagContent.trim();
+    const spaceIdx = cleanContent.search(/[\s/]/);
+    const tagName = (spaceIdx === -1 ? cleanContent : cleanContent.slice(0, spaceIdx)).toLowerCase();
+    const attrStr = spaceIdx === -1 ? "" : cleanContent.slice(spaceIdx);
+    if (!tagName || tagName.startsWith("!")) {
+      pos = tagEnd + 1;
+      continue;
+    }
+    const attributes = parseAttributes(attrStr);
+    const isSelfClosing = selfClose || SELF_CLOSING.has(tagName);
+    const node = {
+      type: "element",
+      tag: tagName,
+      attributes,
+      children: isSelfClosing ? void 0 : [],
+      selfClosing: isSelfClosing
+    };
+    current().children.push(node);
+    pos = tagEnd + 1;
+    if (isSelfClosing) continue;
+    if (RAWTEXT_TAGS.has(tagName)) {
+      const endRaw = html.toLowerCase().indexOf(`</${tagName}`, pos);
+      if (endRaw !== -1) {
+        const rawText = html.slice(pos, endRaw);
+        if (rawText.trim()) {
+          node.children.push({ type: "text", text: rawText });
+        }
+        pos = html.indexOf(">", endRaw) + 1;
+      }
+      continue;
+    }
+    stack.push({ node, children: node.children });
+    if (tagName === "p" || tagName === "li" || tagName === "td" || tagName === "th" || tagName === "dt" || tagName === "dd") {
+      if (stack.length >= 3 && stack[stack.length - 2].node.tag === tagName) {
+        stack.splice(stack.length - 2, 1);
+      }
+    }
+  }
+  return root;
+}
+function parseAttributes(str) {
+  const attrs = {};
+  const re = /(\w[\w-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+)))?/g;
+  let m;
+  while ((m = re.exec(str)) !== null) {
+    attrs[m[1].toLowerCase()] = decodeEntities(m[2] ?? m[3] ?? m[4] ?? "");
+  }
+  return attrs;
+}
+function decodeEntities(text) {
+  return text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&apos;/g, "'").replace(/&nbsp;/g, " ").replace(/&#(\d+);/g, (_, n) => String.fromCharCode(parseInt(n))).replace(/&#x([0-9a-fA-F]+);/g, (_, n) => String.fromCharCode(parseInt(n, 16)));
+}
+var SKIP_TAGS = /* @__PURE__ */ new Set(["script", "style", "noscript", "svg", "head", "template", "iframe"]);
+var BLOCK_TAGS = /* @__PURE__ */ new Set(["div", "p", "section", "article", "main", "aside", "blockquote", "pre", "ul", "ol", "li", "table", "tr", "td", "th", "h1", "h2", "h3", "h4", "h5", "h6", "br", "hr", "figure", "figcaption", "details", "summary", "dl", "dt", "dd", "header", "footer", "nav", "form"]);
+var HEADING_LEVELS = { h1: "#", h2: "##", h3: "###", h4: "####", h5: "#####", h6: "######" };
+var INTERACTIVE_TAGS = /* @__PURE__ */ new Set(["a", "button", "input", "select", "textarea", "details", "summary"]);
+var INTERACTIVE_ROLES = /* @__PURE__ */ new Set(["button", "link", "textbox", "checkbox", "radio", "combobox", "tab", "switch", "menuitem"]);
+function extractText(nodes) {
+  let out = "";
+  for (const node of nodes) {
+    if (node.type === "text") {
+      out += node.text;
+      continue;
+    }
+    if (node.type !== "element" || !node.tag) continue;
+    if (SKIP_TAGS.has(node.tag)) continue;
+    const inner = node.children ? extractText(node.children) : "";
+    if (BLOCK_TAGS.has(node.tag)) {
+      out += "\n" + inner.trim() + "\n";
+    } else {
+      out += inner;
+    }
+  }
+  return out.replace(/\n{3,}/g, "\n\n").trim();
+}
+function extractMarkdown(nodes, baseUrl) {
+  let listDepth = 0;
+  let olCounter = [];
+  function resolveUrl(href) {
+    if (!href || href.startsWith("javascript:") || href.startsWith("#")) return href;
+    if (href.startsWith("http://") || href.startsWith("https://") || href.startsWith("//")) return href;
+    if (baseUrl) {
+      try {
+        return new URL(href, baseUrl).href;
+      } catch {
+      }
+    }
+    return href;
+  }
+  function walk(nodes2) {
+    let out = "";
+    for (const node of nodes2) {
+      if (node.type === "text") {
+        out += node.text?.replace(/\s+/g, " ") || "";
+        continue;
+      }
+      if (node.type !== "element" || !node.tag) continue;
+      if (SKIP_TAGS.has(node.tag)) continue;
+      const tag = node.tag;
+      const children = node.children || [];
+      const inner = walk(children).trim();
+      if (HEADING_LEVELS[tag]) {
+        out += `
+
+${HEADING_LEVELS[tag]} ${inner}
+
+`;
+        continue;
+      }
+      switch (tag) {
+        case "p":
+          out += `
+
+${inner}
+
+`;
+          break;
+        case "br":
+          out += "\n";
+          break;
+        case "hr":
+          out += "\n\n---\n\n";
+          break;
+        case "strong":
+        case "b":
+          if (inner) out += `**${inner}**`;
+          break;
+        case "em":
+        case "i":
+          if (inner) out += `*${inner}*`;
+          break;
+        case "s":
+        case "del":
+        case "strike":
+          if (inner) out += `~~${inner}~~`;
+          break;
+        case "code":
+          if (inner) out += `\`${inner}\``;
+          break;
+        case "pre": {
+          const lang = children.find((c) => c.tag === "code")?.attributes?.class?.match(/language-(\w+)/)?.[1] || "";
+          out += `
+
+\`\`\`${lang}
+${inner}
+\`\`\`
+
+`;
+          break;
+        }
+        case "a": {
+          const href = resolveUrl(node.attributes?.href || "");
+          const text = inner || node.attributes?.["aria-label"] || node.attributes?.title || "";
+          if (!text) break;
+          if (!href || href === "#" || href.startsWith("javascript:")) {
+            out += text;
+            break;
+          }
+          out += `[${text}](${href})`;
+          break;
+        }
+        case "img": {
+          const alt = node.attributes?.alt || "";
+          const src = resolveUrl(node.attributes?.src || "");
+          if (src) out += `![${alt}](${src})`;
+          break;
+        }
+        case "ul":
+          listDepth++;
+          olCounter.push(0);
+          out += "\n" + walk(children);
+          listDepth--;
+          olCounter.pop();
+          break;
+        case "ol":
+          listDepth++;
+          olCounter.push(0);
+          out += "\n" + walk(children);
+          listDepth--;
+          olCounter.pop();
+          break;
+        case "li": {
+          const indent = "  ".repeat(Math.max(0, listDepth - 1));
+          const isOrdered = olCounter.length > 0 && olCounter[olCounter.length - 1] >= 0;
+          if (isOrdered && olCounter.length > 0) olCounter[olCounter.length - 1]++;
+          const counter = isOrdered && olCounter.length > 0 ? olCounter[olCounter.length - 1] : 0;
+          const bullet = isOrdered ? `${counter}. ` : "- ";
+          out += `${indent}${bullet}${inner}
+`;
+          break;
+        }
+        case "blockquote": {
+          if (inner) out += "\n\n" + inner.split("\n").map((l) => `> ${l}`).join("\n") + "\n\n";
+          break;
+        }
+        case "table": {
+          const rows = collectTableRows(children);
+          if (rows.length > 0) {
+            out += "\n\n";
+            for (let i = 0; i < rows.length; i++) {
+              out += "| " + rows[i].join(" | ") + " |\n";
+              if (i === 0) out += "| " + rows[i].map(() => "---").join(" | ") + " |\n";
+            }
+            out += "\n";
+          }
+          break;
+        }
+        case "dt":
+          out += `
+**${inner}**
+`;
+          break;
+        case "dd":
+          out += `: ${inner}
+`;
+          break;
+        case "figcaption":
+          out += `
+*${inner}*
+`;
+          break;
+        case "summary":
+          out += `**${inner}**
+
+`;
+          break;
+        default:
+          if (BLOCK_TAGS.has(tag)) {
+            out += "\n" + walk(children) + "\n";
+          } else {
+            out += walk(children);
+          }
+      }
+    }
+    return out;
+  }
+  function collectTableRows(nodes2) {
+    const rows = [];
+    for (const node of nodes2) {
+      if (node.tag === "tr") {
+        const cells = [];
+        for (const cell of node.children || []) {
+          if (cell.tag === "td" || cell.tag === "th") {
+            cells.push(walk(cell.children || []).trim().replace(/\|/g, "\\|").replace(/\n/g, " "));
+          }
+        }
+        if (cells.length > 0) rows.push(cells);
+      } else if (node.tag === "thead" || node.tag === "tbody" || node.tag === "tfoot") {
+        rows.push(...collectTableRows(node.children || []));
+      }
+    }
+    return rows;
+  }
+  const raw = walk(nodes);
+  return raw.replace(/\n{3,}/g, "\n\n").trim();
+}
+function extractSnapshot(nodes) {
+  let idx = 0;
+  const ATTR_WHITELIST = ["type", "role", "aria-label", "placeholder", "href", "value", "name", "alt"];
+  function isInteractive(node) {
+    if (!node.tag) return false;
+    if (INTERACTIVE_TAGS.has(node.tag)) return true;
+    const role = node.attributes?.role;
+    if (role && INTERACTIVE_ROLES.has(role)) return true;
+    if (node.attributes?.contenteditable === "true") return true;
+    if (node.attributes?.tabindex && parseInt(node.attributes.tabindex) >= 0) return true;
+    return false;
+  }
+  function getAttrs(node) {
+    const parts = [];
+    for (const name of ATTR_WHITELIST) {
+      const v = node.attributes?.[name];
+      if (v) parts.push(`${name}=${v.slice(0, 60)}`);
+    }
+    return parts.length ? " " + parts.join(" ") : "";
+  }
+  function walk(nodes2, depth) {
+    let out = "";
+    for (const node of nodes2) {
+      if (node.type === "text") {
+        const t = node.text?.trim();
+        if (t) out += "  ".repeat(depth) + t.slice(0, 150) + "\n";
+        continue;
+      }
+      if (node.type !== "element" || !node.tag) continue;
+      if (SKIP_TAGS.has(node.tag)) continue;
+      const indent = "  ".repeat(depth);
+      const inter = isInteractive(node);
+      const prefix = inter ? `[${idx++}]` : "";
+      const attrs = getAttrs(node);
+      const leafText = node.children?.length === 1 && node.children[0].type === "text" ? node.children[0].text?.trim().slice(0, 150) || "" : "";
+      if (inter || leafText || !node.children?.length) {
+        if (leafText) {
+          out += `${indent}${prefix}<${node.tag}${attrs}>${leafText}</${node.tag}>
+`;
+        } else {
+          out += `${indent}${prefix}<${node.tag}${attrs}>
+`;
+          if (node.children) out += walk(node.children, depth + 1);
+        }
+      } else {
+        if (node.children) out += walk(node.children, depth);
+      }
+    }
+    return out;
+  }
+  return walk(nodes, 0);
+}
+function extractLinks(nodes, baseUrl) {
+  const links = [];
+  function walk(nodes2) {
+    for (const node of nodes2) {
+      if (node.type === "element" && node.tag === "a" && node.attributes?.href) {
+        let href = node.attributes.href;
+        if (baseUrl && !href.startsWith("http")) {
+          try {
+            href = new URL(href, baseUrl).href;
+          } catch {
+          }
+        }
+        const text = extractText(node.children || []).trim();
+        if (text && href && !href.startsWith("javascript:")) {
+          links.push({ text: text.slice(0, 200), href });
+        }
+      }
+      if (node.children) walk(node.children);
+    }
+  }
+  walk(nodes);
+  return links;
+}
+async function lobsterFetch(url, options) {
+  const timeout = options?.timeout || 3e4;
+  const dump = options?.dump || "markdown";
+  const start = Date.now();
+  const resp = await fetch(url, {
+    headers: {
+      "User-Agent": "LobsterCLI/0.1 (+https://github.com/iexcalibur/lobster-cli)",
+      "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+      "Accept-Language": "en-US,en;q=0.5",
+      ...options?.headers || {}
+    },
+    redirect: options?.followRedirects !== false ? "follow" : "manual",
+    signal: AbortSignal.timeout(timeout)
+  });
+  if (!resp.ok) {
+    throw new Error(`HTTP ${resp.status} ${resp.statusText}`);
+  }
+  const html = await resp.text();
+  const duration = Date.now() - start;
+  const finalUrl = resp.url || url;
+  const nodes = parseHtml(html);
+  let title = "";
+  function findTitle(nodes2) {
+    for (const node of nodes2) {
+      if (node.tag === "title" && node.children?.[0]?.text) {
+        title = node.children[0].text.trim();
+        return;
+      }
+      if (node.children) findTitle(node.children);
+    }
+  }
+  findTitle(nodes);
+  let content;
+  let links;
+  switch (dump) {
+    case "markdown":
+      content = extractMarkdown(nodes, finalUrl);
+      break;
+    case "text":
+      content = extractText(nodes);
+      break;
+    case "snapshot":
+      content = extractSnapshot(nodes);
+      break;
+    case "html":
+      content = html;
+      break;
+    case "links":
+      links = extractLinks(nodes, finalUrl);
+      content = links.map((l, i) => `${i + 1}. [${l.text}](${l.href})`).join("\n");
+      break;
+    default:
+      content = extractMarkdown(nodes, finalUrl);
+  }
+  return { url, finalUrl, status: resp.status, title, content, links, duration };
+}
+export {
+  BrowserManager,
+  FLAT_TREE_SCRIPT,
+  FORM_STATE_SCRIPT,
+  GET_INTERCEPTED_SCRIPT,
+  INTERACTIVE_ELEMENTS_SCRIPT,
+  MARKDOWN_SCRIPT,
+  PuppeteerPage,
+  SEMANTIC_TREE_SCRIPT,
+  SNAPSHOT_SCRIPT,
+  buildInterceptorScript,
+  buildSnapshotScript,
+  extractLinks,
+  extractMarkdown,
+  extractSnapshot,
+  extractText,
+  flatTreeToString,
+  lobsterFetch,
+  parseHtml,
+  waitForCondition
+};
+//# sourceMappingURL=index.js.map