lobster-cli 0.1.0

package/dist/lib.js

@@ -0,0 +1,4206 @@
+// src/brain/index.ts
+var CLASSIFIER_PROMPT = `You are an intent classifier for a web automation tool. Given a user's question about a webpage, decide what data sources are needed to answer it.
+
+Respond ONLY with a JSON object:
+{
+  "screenshot": true/false,
+  "markdown": true/false,
+  "forms": true/false,
+  "network": true/false,
+  "intent": "brief 5-word description"
+}
+
+Rules:
+- screenshot=true ONLY when the answer requires SEEING the page (images, visual layout, colors, charts, what something looks like)
+- markdown=true for ANY question about text content, meaning, topics, summaries
+- forms=true ONLY when specifically asking about form fields or inputs
+- network=true ONLY when asking about APIs, requests, or data fetching
+- Most questions need only markdown=true`;
+async function classifyIntent(prompt, pageTitle, llmCall) {
+  if (llmCall) {
+    try {
+      const systemPrompt = CLASSIFIER_PROMPT + `
+Current page: "${pageTitle}"`;
+      const response = await llmCall(systemPrompt, prompt);
+      const jsonMatch = response.match(/\{[\s\S]*?\}/);
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        return {
+          screenshot: !!parsed.screenshot,
+          markdown: parsed.markdown !== false,
+          forms: !!parsed.forms,
+          network: !!parsed.network,
+          intent: parsed.intent || "",
+          source: "llm"
+        };
+      }
+    } catch {
+    }
+  }
+  return heuristicClassify(prompt);
+}
+function heuristicClassify(prompt) {
+  const lower = prompt.toLowerCase();
+  const screenshot = /look|see|visual|image|screenshot|screen|what('s| is) (on|showing|displayed|visible)|describe.*layout|picture|colour|color|design|ui |logo|icon|chart|graph|photo|video|banner|appear/i.test(lower);
+  const forms = /form|input|field|submit|login|sign.?in|password|checkbox|dropdown|select|textarea|search.?box|fill/i.test(lower);
+  const network = /api|network|request|fetch|xhr|endpoint|call.*server|data.*load/i.test(lower);
+  return {
+    screenshot,
+    markdown: true,
+    forms,
+    network,
+    intent: "heuristic classification",
+    source: "heuristic"
+  };
+}
+
+// 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/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/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 };
+}
+
+// src/pipeline/registry.ts
+var stepHandlers = /* @__PURE__ */ new Map();
+function registerStep(name, handler) {
+  stepHandlers.set(name, handler);
+}
+function getStep(name) {
+  return stepHandlers.get(name);
+}
+function getStepNames() {
+  return [...stepHandlers.keys()];
+}
+
+// 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/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/types/adapter.ts
+var Strategy = /* @__PURE__ */ ((Strategy2) => {
+  Strategy2["PUBLIC"] = "public";
+  Strategy2["COOKIE"] = "cookie";
+  Strategy2["HEADER"] = "header";
+  Strategy2["INTERCEPT"] = "intercept";
+  Strategy2["UI"] = "ui";
+  return Strategy2;
+})(Strategy || {});
+
+// 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 cli(def) {
+  const adapter = {
+    site: def.site,
+    name: def.name,
+    description: def.description || `${def.site} ${def.name}`,
+    domain: def.domain,
+    strategy: def.strategy || "public" /* PUBLIC */,
+    browser: def.browser ?? def.strategy !== "public" /* PUBLIC */,
+    args: def.args || [],
+    columns: def.columns,
+    func: def.func,
+    pipeline: def.pipeline,
+    timeoutSeconds: def.timeoutSeconds,
+    navigateBefore: def.navigateBefore
+  };
+  const fullName = `${adapter.site}/${adapter.name}`;
+  getRegistry().set(fullName, adapter);
+  return adapter;
+}
+function getAdapter(site, name) {
+  return getRegistry().get(`${site}/${name}`);
+}
+function getAdapterBySite(site) {
+  const adapters = [];
+  for (const [key, adapter] of getRegistry()) {
+    if (key.startsWith(`${site}/`)) adapters.push(adapter);
+  }
+  return adapters;
+}
+function getAdapterByDomain(domain) {
+  const adapters = [];
+  for (const adapter of getRegistry().values()) {
+    if (adapter.domain && domain.includes(adapter.domain)) adapters.push(adapter);
+  }
+  return adapters;
+}
+function getAllAdapters() {
+  return [...getRegistry().values()];
+}
+function getAllSites() {
+  const sites = /* @__PURE__ */ new Set();
+  for (const adapter of getRegistry().values()) {
+    sites.add(adapter.site);
+  }
+  return [...sites].sort();
+}
+
+// src/discover/explore.ts
+import { writeFileSync, mkdirSync, existsSync as existsSync2 } from "fs";
+import { join } from "path";
+var SITE_ALIASES = {
+  "x.com": "twitter",
+  "twitter.com": "twitter",
+  "news.ycombinator.com": "hackernews",
+  "old.reddit.com": "reddit",
+  "www.reddit.com": "reddit",
+  "bilibili.com": "bilibili",
+  "www.bilibili.com": "bilibili",
+  "zhihu.com": "zhihu",
+  "www.zhihu.com": "zhihu"
+};
+var FIELD_ROLES = {
+  title: ["title", "name", "headline", "subject", "text", "caption"],
+  url: ["url", "link", "href", "permalink", "uri", "web_url"],
+  author: ["author", "user", "creator", "owner", "by", "username", "screen_name", "display_name"],
+  score: ["score", "points", "likes", "upvotes", "karma", "vote_count", "favorite_count", "retweet_count"],
+  time: ["time", "date", "created", "created_at", "timestamp", "published", "updated_at", "posted_at"],
+  description: ["description", "summary", "snippet", "excerpt", "body", "content", "selftext"],
+  image: ["image", "thumbnail", "avatar", "icon", "photo", "cover", "poster"],
+  id: ["id", "uid", "pid", "mid", "aid", "bvid"]
+};
+var VOLATILE_PARAMS = /* @__PURE__ */ new Set([
+  "_",
+  "t",
+  "ts",
+  "timestamp",
+  "nonce",
+  "rand",
+  "random",
+  "callback",
+  "jsonp",
+  "_t",
+  "__t"
+]);
+function normalizeUrlPattern(urlStr) {
+  try {
+    const u = new URL(urlStr);
+    const parts = u.pathname.split("/");
+    const normalized = parts.map((p) => {
+      if (!p) return p;
+      if (/^\d+$/.test(p)) return "{id}";
+      if (/^[a-f0-9]{8,}$/i.test(p)) return "{hex}";
+      if (/^BV[a-zA-Z0-9]+$/.test(p)) return "{bvid}";
+      if (/^[a-z0-9]{20,}$/i.test(p)) return "{token}";
+      return p;
+    });
+    return u.origin + normalized.join("/");
+  } catch {
+    return urlStr;
+  }
+}
+function detectAuth(url, headers) {
+  const indicators = [];
+  if (url.includes("signature") || url.includes("sign=") || url.includes("sig=")) indicators.push("signature");
+  if (url.includes("token=") || url.includes("access_token=")) indicators.push("token");
+  if (url.includes("api_key=") || url.includes("apikey=")) indicators.push("api_key");
+  if (headers) {
+    if (headers["authorization"]?.startsWith("Bearer")) indicators.push("bearer");
+    if (headers["x-csrf-token"] || headers["x-xsrf-token"]) indicators.push("csrf");
+  }
+  return indicators;
+}
+function analyzeResponseBody(body) {
+  if (!body || typeof body !== "object") {
+    return { hasItems: false, itemCount: 0, fields: [], fieldRoles: {} };
+  }
+  let items = null;
+  if (Array.isArray(body)) {
+    items = body;
+  } else {
+    const obj = body;
+    for (const key of ["data", "results", "items", "list", "entries", "records", "hits", "posts", "articles", "stories"]) {
+      const val = obj[key];
+      if (Array.isArray(val) && val.length > 0) {
+        items = val;
+        break;
+      }
+      if (val && typeof val === "object" && !Array.isArray(val)) {
+        for (const subKey of ["items", "list", "data", "results", "entries"]) {
+          const subVal = val[subKey];
+          if (Array.isArray(subVal) && subVal.length > 0) {
+            items = subVal;
+            break;
+          }
+        }
+        if (items) break;
+      }
+    }
+  }
+  if (!items || items.length === 0) {
+    return { hasItems: false, itemCount: 0, fields: [], fieldRoles: {} };
+  }
+  const firstItem = items[0];
+  if (!firstItem || typeof firstItem !== "object") {
+    return { hasItems: true, itemCount: items.length, fields: [], fieldRoles: {} };
+  }
+  const fields = Object.keys(firstItem);
+  const fieldRoles = {};
+  for (const field of fields) {
+    const lower = field.toLowerCase();
+    for (const [role, patterns] of Object.entries(FIELD_ROLES)) {
+      if (patterns.some((p) => lower.includes(p))) {
+        fieldRoles[field] = role;
+        break;
+      }
+    }
+  }
+  return { hasItems: true, itemCount: items.length, fields, fieldRoles };
+}
+function scoreEndpoint(ep) {
+  let score = 0;
+  if (ep.contentType.includes("json")) score += 10;
+  if (ep.hasItems) score += 5;
+  if (ep.itemCount > 3) score += 3;
+  if (ep.itemCount > 10) score += 2;
+  if (Object.keys(ep.fieldRoles).length > 2) score += 3;
+  if (ep.url.includes("/api/")) score += 5;
+  if (ep.url.includes("/v1/") || ep.url.includes("/v2/") || ep.url.includes("/v3/")) score += 3;
+  const path = new URL(ep.url).pathname.toLowerCase();
+  if (/search|query|find/.test(path)) score += 4;
+  if (/hot|trending|popular|top|feed|timeline/.test(path)) score += 4;
+  if (/list|index|all|latest|recent/.test(path)) score += 3;
+  if (ep.queryParams.some((p) => /search|keyword|query|q/.test(p))) score += 3;
+  if (ep.queryParams.some((p) => /page|offset|cursor|limit|count|num/.test(p))) score += 2;
+  if (ep.method === "GET") score += 2;
+  if (ep.authIndicators.includes("signature")) score -= 2;
+  if (/\.(js|css|png|jpg|gif|svg|woff|ico)/.test(ep.url)) score -= 30;
+  if (/analytics|tracking|pixel|beacon|log\b/.test(ep.url)) score -= 20;
+  return score;
+}
+function inferCapabilities(endpoints) {
+  const caps = [];
+  for (const ep of endpoints) {
+    const path = ep.url.toLowerCase();
+    if (/search|query|find/.test(path) && !caps.includes("search")) caps.push("search");
+    if (/hot|trending|popular/.test(path) && !caps.includes("hot")) caps.push("hot");
+    if (/feed|timeline|home/.test(path) && !caps.includes("feed")) caps.push("feed");
+    if (/detail|item\/\{|article\/\{|post\/\{/.test(ep.pattern) && !caps.includes("detail")) caps.push("detail");
+    if (/comment|reply|discuss/.test(path) && !caps.includes("comments")) caps.push("comments");
+    if (/user|profile|me\b|account/.test(path) && !caps.includes("me")) caps.push("me");
+    if (/favorite|bookmark|saved|like/.test(path) && !caps.includes("favorites")) caps.push("favorites");
+    if (/history|watch|read/.test(path) && !caps.includes("history")) caps.push("history");
+  }
+  return caps;
+}
+async function smartAutoScroll(page, attempts) {
+  for (let i = 0; i < attempts; i++) {
+    const scrolled = await page.evaluate(`
+      (async () => {
+        const lastHeight = document.body.scrollHeight;
+        window.scrollTo(0, lastHeight);
+
+        // Wait for new content via MutationObserver or timeout
+        const result = await new Promise((resolve) => {
+          let timeoutId;
+          const observer = new MutationObserver(() => {
+            if (document.body.scrollHeight > lastHeight) {
+              clearTimeout(timeoutId);
+              observer.disconnect();
+              setTimeout(() => resolve(true), 100);
+            }
+          });
+          observer.observe(document.body, { childList: true, subtree: true });
+          timeoutId = setTimeout(() => { observer.disconnect(); resolve(false); }, 2000);
+        });
+        return result;
+      })()
+    `);
+    if (!scrolled) break;
+  }
+}
+async function interactiveFuzz(page, maxButtons) {
+  await page.evaluate(`
+    (async () => {
+      const clickTargets = [];
+      const selectors = [
+        'button:not([disabled])',
+        '[role="tab"]',
+        '[role="button"]',
+        '.tab', '.nav-link', '.dropdown-toggle',
+        'a[data-toggle]', '[data-bs-toggle]',
+      ];
+
+      for (const sel of selectors) {
+        for (const el of document.querySelectorAll(sel)) {
+          const rect = el.getBoundingClientRect();
+          if (rect.width > 0 && rect.height > 0 &&
+              rect.top >= 0 && rect.top < window.innerHeight * 2) {
+            const text = el.textContent?.trim()?.slice(0, 40) || '';
+            // Skip destructive-looking buttons
+            if (/delete|remove|logout|sign.?out|cancel|close/i.test(text)) continue;
+            clickTargets.push(el);
+          }
+        }
+      }
+
+      // Click up to N targets with delays
+      const max = Math.min(${maxButtons}, clickTargets.length);
+      for (let i = 0; i < max; i++) {
+        try {
+          clickTargets[i].click();
+          await new Promise(r => setTimeout(r, 800));
+        } catch {}
+      }
+    })()
+  `);
+  await page.wait(1.5);
+}
+async function recoverMissingBodies(page, endpoints) {
+  const needsRecovery = endpoints.filter(
+    (ep) => !ep.hasItems && ep.contentType.includes("json") && ep.score > 5
+  );
+  if (needsRecovery.length === 0) return;
+  const urls = needsRecovery.map((ep) => ep.url).slice(0, 8);
+  const bodies = await page.evaluate(`
+    (async () => {
+      const urls = ${JSON.stringify(urls)};
+      const results = [];
+      for (const url of urls) {
+        try {
+          const resp = await fetch(url, { credentials: 'include' });
+          if (resp.ok) {
+            const json = await resp.json();
+            results.push(json);
+          } else {
+            results.push(null);
+          }
+        } catch { results.push(null); }
+      }
+      return results;
+    })()
+  `);
+  if (!bodies) return;
+  for (let i = 0; i < urls.length; i++) {
+    if (!bodies[i]) continue;
+    const ep = needsRecovery[i];
+    const analysis = analyzeResponseBody(bodies[i]);
+    if (analysis.hasItems) {
+      ep.hasItems = analysis.hasItems;
+      ep.itemCount = analysis.itemCount;
+      ep.fields = analysis.fields;
+      ep.fieldRoles = analysis.fieldRoles;
+      ep.score = scoreEndpoint(ep);
+    }
+  }
+}
+function writeArtifacts(dir, result) {
+  if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "manifest.json"), JSON.stringify({
+    site: result.site,
+    domain: result.domain,
+    framework: result.framework,
+    strategy: result.strategy,
+    capabilities: result.capabilities,
+    endpointCount: result.endpoints.length,
+    exploredAt: (/* @__PURE__ */ new Date()).toISOString()
+  }, null, 2));
+  writeFileSync(join(dir, "endpoints.json"), JSON.stringify(
+    result.endpoints.map((ep) => ({
+      url: ep.url,
+      pattern: ep.pattern,
+      method: ep.method,
+      status: ep.status,
+      score: ep.score,
+      hasItems: ep.hasItems,
+      itemCount: ep.itemCount,
+      fields: ep.fields,
+      fieldRoles: ep.fieldRoles,
+      queryParams: ep.queryParams,
+      authIndicators: ep.authIndicators
+    })),
+    null,
+    2
+  ));
+  writeFileSync(join(dir, "capabilities.json"), JSON.stringify(
+    result.capabilities.map((cap) => {
+      const matchingEndpoints = result.endpoints.filter((ep) => {
+        const path = ep.url.toLowerCase();
+        if (cap === "search") return /search|query|find/.test(path);
+        if (cap === "hot") return /hot|trending|popular/.test(path);
+        if (cap === "feed") return /feed|timeline|home/.test(path);
+        return false;
+      });
+      return {
+        name: cap,
+        description: `${cap} capability`,
+        endpoint: matchingEndpoints[0]?.pattern || null,
+        strategy: result.strategy,
+        confidence: matchingEndpoints.length > 0 ? 0.8 : 0.5,
+        recommendedColumns: matchingEndpoints[0]?.fields?.slice(0, 6) || []
+      };
+    }),
+    null,
+    2
+  ));
+  const authSummary = {};
+  for (const ep of result.endpoints) {
+    for (const ind of ep.authIndicators) {
+      if (!authSummary[ind]) authSummary[ind] = [];
+      authSummary[ind].push(ep.pattern);
+    }
+  }
+  writeFileSync(join(dir, "auth.json"), JSON.stringify(authSummary, null, 2));
+  if (result.stores && result.stores.length > 0) {
+    writeFileSync(join(dir, "stores.json"), JSON.stringify(result.stores, null, 2));
+  }
+  log.success(`Artifacts written to ${dir}/`);
+}
+async function exploreSite(page, url, options) {
+  const parsedUrl = new URL(url);
+  const domain = parsedUrl.hostname;
+  const site = SITE_ALIASES[domain] || domain.replace(/^www\./, "").split(".")[0];
+  log.info(`Exploring ${url}...`);
+  await page.installInterceptor("");
+  await page.goto(url);
+  await page.wait(options?.wait || 3);
+  if (options?.scroll !== false) {
+    log.debug("Smart auto-scrolling to trigger lazy-loaded APIs...");
+    await smartAutoScroll(page, options?.scrollAttempts || 4);
+  }
+  if (options?.fuzz !== false) {
+    log.debug("Fuzzing interactive elements...");
+    await interactiveFuzz(page, options?.maxButtons || 12);
+  }
+  const rawRequests = await page.getInterceptedRequests();
+  const seen = /* @__PURE__ */ new Set();
+  const endpoints = [];
+  for (const raw of rawRequests) {
+    if (!raw?.url || !raw?.status) continue;
+    if (raw.status < 200 || raw.status >= 400) continue;
+    const pattern = normalizeUrlPattern(raw.url);
+    const dedupeKey = `${raw.method || "GET"}:${pattern}`;
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
+    let queryParams = [];
+    try {
+      const u = new URL(raw.url);
+      queryParams = [...u.searchParams.keys()].filter((k) => !VOLATILE_PARAMS.has(k));
+    } catch {
+    }
+    const authIndicators = detectAuth(raw.url);
+    const bodyAnalysis = analyzeResponseBody(raw.body);
+    const ep = {
+      url: raw.url,
+      pattern,
+      method: raw.method || "GET",
+      status: raw.status,
+      contentType: "json",
+      queryParams,
+      ...bodyAnalysis,
+      authIndicators
+    };
+    endpoints.push({ ...ep, score: scoreEndpoint(ep) });
+  }
+  log.debug("Recovering missing response bodies...");
+  await recoverMissingBodies(page, endpoints);
+  endpoints.sort((a, b) => b.score - a.score);
+  const framework = await page.evaluate(`
+    (() => {
+      const app = document.querySelector('#app');
+      if (window.__NEXT_DATA__) return 'nextjs';
+      if (window.__NUXT__) return 'nuxt';
+      if (app && app.__vue_app__) {
+        const gp = app.__vue_app__.config?.globalProperties;
+        if (gp?.$pinia) return 'vue+pinia';
+        if (gp?.$store) return 'vue+vuex';
+        return 'vue';
+      }
+      if (app && app.__vue__) return 'vue2';
+      if (window.__REACT_DEVTOOLS_GLOBAL_HOOK__) return 'react';
+      if (document.querySelector('[data-reactroot]') || document.querySelector('#__next') || document.querySelector('#root')?.['_reactRootContainer']) return 'react';
+      if (window.angular || document.querySelector('[ng-version]')) return 'angular';
+      if (window.__svelte_meta) return 'svelte';
+      return 'unknown';
+    })()
+  `).catch(() => "unknown");
+  const stores = await page.evaluate(`
+    (() => {
+      const results = [];
+      const app = document.querySelector('#app');
+
+      // Pinia via __vue_app__
+      if (app && app.__vue_app__) {
+        try {
+          const pinia = app.__vue_app__.config?.globalProperties?.$pinia;
+          if (pinia && pinia._s) {
+            pinia._s.forEach((store, id) => {
+              const actions = Object.keys(store).filter(k =>
+                typeof store[k] === 'function' && !k.startsWith('$') && !k.startsWith('_')
+              );
+              const stateKeys = Object.keys(store).filter(k =>
+                typeof store[k] !== 'function' && !k.startsWith('$') && !k.startsWith('_')
+              );
+              results.push({ name: id, type: 'pinia', actions: actions.slice(0, 20), stateKeys: stateKeys.slice(0, 20) });
+            });
+          }
+        } catch {}
+
+        // Vuex via __vue_app__
+        try {
+          const store = app.__vue_app__.config?.globalProperties?.$store;
+          if (store && store._actions) {
+            const actions = Object.keys(store._actions);
+            results.push({ name: 'vuex', type: 'vuex', actions: actions.slice(0, 20) });
+          }
+        } catch {}
+      }
+
+      // Legacy Pinia global
+      if (results.length === 0 && window.__pinia) {
+        try {
+          const pinia = window.__pinia;
+          for (const [id, store] of pinia._s || []) {
+            const actions = Object.keys(store).filter(k => typeof store[k] === 'function' && !k.startsWith('$') && !k.startsWith('_'));
+            results.push({ name: id, type: 'pinia', actions: actions.slice(0, 20) });
+          }
+        } catch {}
+      }
+
+      return results;
+    })()
+  `).catch(() => []);
+  let strategy = "public";
+  if (endpoints.length > 0) {
+    const topEp = endpoints[0];
+    if (topEp.authIndicators.includes("signature")) strategy = "intercept";
+    else if (topEp.authIndicators.includes("bearer") || topEp.authIndicators.includes("csrf")) strategy = "header";
+    else if (endpoints.some((e) => !e.hasItems) && endpoints.some((e) => e.hasItems)) strategy = "cookie";
+  } else {
+    strategy = "cookie";
+  }
+  const capabilities = inferCapabilities(endpoints);
+  const result = {
+    site,
+    domain,
+    endpoints: endpoints.slice(0, 30),
+    strategy,
+    framework,
+    stores: stores.length > 0 ? stores : void 0,
+    capabilities
+  };
+  const outputDir = options?.outputDir || join(process.cwd(), ".lobster", "explore", site);
+  writeArtifacts(outputDir, result);
+  result.artifactDir = outputDir;
+  return result;
+}
+
+// src/discover/synthesize.ts
+import yaml from "js-yaml";
+function synthesizeAdapter(result, goal) {
+  const topEndpoints = result.endpoints.filter((e) => e.score > 0).slice(0, 3);
+  if (topEndpoints.length === 0) {
+    return `# No API endpoints discovered for ${result.site}
+# Try using: lobster agent "your task" --url https://${result.domain}`;
+  }
+  const endpoint = topEndpoints[0];
+  let name = goal || "data";
+  if (!goal) {
+    const path = new URL(endpoint.url).pathname.toLowerCase();
+    if (/search|query/.test(path)) name = "search";
+    else if (/hot|trending|popular/.test(path)) name = "hot";
+    else if (/feed|timeline|home/.test(path)) name = "feed";
+    else if (/top|best|rank/.test(path)) name = "top";
+  }
+  const args = {
+    limit: { type: "int", default: 20 }
+  };
+  for (const param of endpoint.queryParams) {
+    if (/search|keyword|query|q/.test(param)) {
+      args[param] = { required: true, positional: true, help: "Search query" };
+    } else if (/page|offset|cursor/.test(param)) {
+      args[param] = { type: "int", default: 1 };
+    } else if (/limit|count|num|size/.test(param)) {
+    }
+  }
+  const columns = [];
+  const mapTemplate = {};
+  for (const [field, role] of Object.entries(endpoint.fieldRoles)) {
+    if (["title", "url", "author", "score", "time", "description"].includes(role)) {
+      columns.push(role);
+      mapTemplate[role] = `\${{ item.${field} }}`;
+    }
+  }
+  if (columns.length === 0) {
+    for (const field of endpoint.fields.slice(0, 5)) {
+      columns.push(field);
+      mapTemplate[field] = `\${{ item.${field} }}`;
+    }
+  }
+  const pipeline = [];
+  if (result.strategy === "public" && !endpoint.authIndicators.length) {
+    pipeline.push({ fetch: endpoint.url });
+  } else {
+    pipeline.push({ navigate: `https://${result.domain}` });
+    pipeline.push({
+      evaluate: `(async () => { const r = await fetch(${JSON.stringify(endpoint.url)}, {credentials:'include'}); return r.json(); })()`
+    });
+  }
+  if (endpoint.hasItems && endpoint.itemCount > 0) {
+    for (const path of ["data", "results", "items", "list", "data.items", "data.list"]) {
+      pipeline.push({ select: path });
+      break;
+    }
+  }
+  if (Object.keys(mapTemplate).length > 0) {
+    pipeline.push({ map: mapTemplate });
+  }
+  pipeline.push({ limit: "${{ args.limit }}" });
+  const adapter = {
+    site: result.site,
+    name,
+    description: `${name} from ${result.domain}`,
+    domain: result.domain,
+    strategy: result.strategy,
+    browser: result.strategy !== "public",
+    args,
+    pipeline,
+    columns: columns.length > 0 ? columns : void 0
+  };
+  return yaml.dump(adapter, { indent: 2, lineWidth: 120 });
+}
+
+// src/cascade/index.ts
+var CASCADE_ORDER = [
+  "public" /* PUBLIC */,
+  "cookie" /* COOKIE */,
+  "header" /* HEADER */,
+  "intercept" /* INTERCEPT */,
+  "ui" /* UI */
+];
+function buildFetchProbeJs(url, opts) {
+  const credentialsLine = opts.credentials ? `credentials: 'include',` : "";
+  const headerSetup = opts.extractCsrf ? `
+      const cookies = document.cookie.split(';').map(c => c.trim());
+      const csrf = cookies.find(c =>
+        c.startsWith('ct0=') || c.startsWith('csrf_token=') ||
+        c.startsWith('_csrf=') || c.startsWith('XSRF-TOKEN=')
+      )?.split('=').slice(1).join('=');
+      const headers = {};
+      if (csrf) { headers['X-Csrf-Token'] = csrf; headers['X-XSRF-Token'] = csrf; }
+    ` : "const headers = {};";
+  return `
+    (async () => {
+      try {
+        ${headerSetup}
+        const resp = await fetch(${JSON.stringify(url)}, {
+          ${credentialsLine}
+          headers
+        });
+        const status = resp.status;
+        if (!resp.ok) return { status, ok: false };
+        const text = await resp.text();
+        let hasData = false;
+        try {
+          const json = JSON.parse(text);
+          hasData = !!json && (Array.isArray(json) ? json.length > 0 :
+            typeof json === 'object' && Object.keys(json).length > 0);
+          // API-level error codes (common in Chinese sites)
+          if (json.code !== undefined && json.code !== 0) hasData = false;
+          if (json.error || json.message === 'Unauthorized') hasData = false;
+        } catch {}
+        return { status, ok: true, hasData, preview: text.slice(0, 200) };
+      } catch (e) { return { ok: false, error: e.message }; }
+    })()
+  `;
+}
+async function probeEndpoint(page, url, strategy) {
+  const result = { strategy, success: false };
+  try {
+    switch (strategy) {
+      case "public" /* PUBLIC */: {
+        const resp = await page.evaluate(buildFetchProbeJs(url, {}));
+        result.statusCode = resp?.status;
+        result.success = resp?.ok && resp?.hasData;
+        result.hasData = resp?.hasData;
+        result.responsePreview = resp?.preview;
+        break;
+      }
+      case "cookie" /* COOKIE */: {
+        const resp = await page.evaluate(buildFetchProbeJs(url, { credentials: true }));
+        result.statusCode = resp?.status;
+        result.success = resp?.ok && resp?.hasData;
+        result.hasData = resp?.hasData;
+        result.responsePreview = resp?.preview;
+        break;
+      }
+      case "header" /* HEADER */: {
+        const resp = await page.evaluate(buildFetchProbeJs(url, { credentials: true, extractCsrf: true }));
+        result.statusCode = resp?.status;
+        result.success = resp?.ok && resp?.hasData;
+        result.hasData = resp?.hasData;
+        result.responsePreview = resp?.preview;
+        break;
+      }
+      case "intercept" /* INTERCEPT */:
+      case "ui" /* UI */:
+        result.success = false;
+        result.error = `Strategy ${strategy} requires site-specific implementation`;
+        break;
+    }
+  } catch (err) {
+    result.success = false;
+    result.error = err.message ?? String(err);
+  }
+  return result;
+}
+async function cascadeProbe(page, url, opts = {}) {
+  const maxIdx = opts.maxStrategy ? CASCADE_ORDER.indexOf(opts.maxStrategy) : CASCADE_ORDER.indexOf("header" /* HEADER */);
+  const probes = [];
+  for (let i = 0; i <= Math.min(maxIdx, CASCADE_ORDER.length - 1); i++) {
+    const strategy = CASCADE_ORDER[i];
+    log.debug(`Probing strategy: ${strategy}`);
+    const probe = await probeEndpoint(page, url, strategy);
+    probes.push(probe);
+    if (probe.success) {
+      return {
+        bestStrategy: strategy,
+        probes,
+        confidence: 1 - i * 0.1
+      };
+    }
+  }
+  return {
+    bestStrategy: "cookie" /* COOKIE */,
+    probes,
+    confidence: 0.3
+  };
+}
+
+// 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/agent/core.ts
+import { readFileSync } from "fs";
+import { join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
+
+// 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(join2(__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/config/index.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir } from "os";
+import yaml2 from "js-yaml";
+
+// src/config/schema.ts
+import { z as z10 } from "zod";
+var LLM_PROVIDERS = {
+  openai: {
+    name: "OpenAI",
+    baseURL: "https://api.openai.com/v1",
+    defaultModel: "gpt-4o",
+    keyPrefix: "sk-",
+    keyEnvHint: "https://platform.openai.com/api-keys",
+    models: ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "o1", "o1-mini", "o3-mini"]
+  },
+  anthropic: {
+    name: "Anthropic",
+    baseURL: "https://api.anthropic.com/v1",
+    defaultModel: "claude-sonnet-4-20250514",
+    keyPrefix: "sk-ant-",
+    keyEnvHint: "https://console.anthropic.com/settings/keys",
+    models: ["claude-opus-4-20250514", "claude-sonnet-4-20250514", "claude-haiku-4-5-20251001"]
+  },
+  gemini: {
+    name: "Google Gemini",
+    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai",
+    defaultModel: "gemini-2.5-flash",
+    keyPrefix: "AI",
+    keyEnvHint: "https://aistudio.google.com/apikey",
+    models: ["gemini-2.5-flash", "gemini-2.5-flash-lite", "gemini-2.5-pro", "gemini-3-flash-preview"]
+  },
+  ollama: {
+    name: "Ollama (local, free)",
+    baseURL: "http://localhost:11434/v1",
+    defaultModel: "llama3.1",
+    keyPrefix: "",
+    keyEnvHint: "No API key needed \u2014 install from https://ollama.ai",
+    models: ["llama3.1", "llama3.2", "mistral", "codestral", "qwen2.5", "deepseek-r1"]
+  }
+};
+var configSchema = z10.object({
+  llm: z10.object({
+    provider: z10.enum(["openai", "anthropic", "gemini", "ollama"]).default("openai"),
+    baseURL: z10.string().default("https://api.openai.com/v1"),
+    model: z10.string().default("gpt-4o"),
+    apiKey: z10.string().default(""),
+    temperature: z10.number().min(0).max(2).default(0.1),
+    maxRetries: z10.number().int().min(0).default(3)
+  }).default({}),
+  browser: z10.object({
+    executablePath: z10.string().default(""),
+    headless: z10.boolean().default(true),
+    connectTimeout: z10.number().default(30),
+    commandTimeout: z10.number().default(60),
+    cdpEndpoint: z10.string().default("")
+  }).default({}),
+  agent: z10.object({
+    maxSteps: z10.number().int().default(40),
+    stepDelay: z10.number().default(0.4)
+  }).default({}),
+  output: z10.object({
+    defaultFormat: z10.enum(["table", "json", "yaml", "markdown", "csv"]).default("table"),
+    color: z10.boolean().default(true)
+  }).default({})
+});
+
+// src/config/index.ts
+var CONFIG_DIR = join3(homedir(), ".lobster");
+var CONFIG_FILE = join3(CONFIG_DIR, "config.yaml");
+function ensureConfigDir() {
+  if (!existsSync3(CONFIG_DIR)) {
+    mkdirSync2(CONFIG_DIR, { recursive: true });
+  }
+}
+function loadConfig() {
+  ensureConfigDir();
+  let fileConfig = {};
+  if (existsSync3(CONFIG_FILE)) {
+    const raw = readFileSync2(CONFIG_FILE, "utf-8");
+    fileConfig = yaml2.load(raw) || {};
+  }
+  const envOverrides = {};
+  if (process.env.LOBSTER_API_KEY) {
+    envOverrides.llm = { ...fileConfig.llm || {}, apiKey: process.env.LOBSTER_API_KEY };
+  }
+  if (process.env.LOBSTER_MODEL) {
+    envOverrides.llm = { ...envOverrides.llm || fileConfig.llm || {}, model: process.env.LOBSTER_MODEL };
+  }
+  if (process.env.LOBSTER_BASE_URL) {
+    envOverrides.llm = { ...envOverrides.llm || fileConfig.llm || {}, baseURL: process.env.LOBSTER_BASE_URL };
+  }
+  if (process.env.LOBSTER_CDP_ENDPOINT) {
+    envOverrides.browser = { ...fileConfig.browser || {}, cdpEndpoint: process.env.LOBSTER_CDP_ENDPOINT };
+  }
+  if (process.env.LOBSTER_BROWSER_PATH) {
+    envOverrides.browser = { ...envOverrides.browser || fileConfig.browser || {}, executablePath: process.env.LOBSTER_BROWSER_PATH };
+  }
+  const merged = { ...fileConfig, ...envOverrides };
+  return configSchema.parse(merged);
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  const existing = loadConfig();
+  const merged = deepMerge(existing, config);
+  writeFileSync2(CONFIG_FILE, yaml2.dump(merged, { indent: 2 }), "utf-8");
+}
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key]) && target[key] && typeof target[key] === "object" && !Array.isArray(target[key])) {
+      result[key] = deepMerge(target[key], source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
+// src/output/table.ts
+import Table from "cli-table3";
+function renderTable(data, columns) {
+  if (!Array.isArray(data) || data.length === 0) {
+    return typeof data === "string" ? data : JSON.stringify(data, null, 2);
+  }
+  const cols = columns || Object.keys(data[0]);
+  const table = new Table({
+    head: cols,
+    style: { head: ["cyan"] },
+    wordWrap: true
+  });
+  for (const row of data) {
+    table.push(cols.map((col) => {
+      const val = row[col];
+      if (val === null || val === void 0) return "";
+      return String(val);
+    }));
+  }
+  return table.toString();
+}
+
+// src/output/json.ts
+function renderJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+
+// src/output/markdown.ts
+function renderMarkdown(data, columns) {
+  if (!Array.isArray(data) || data.length === 0) {
+    return typeof data === "string" ? data : JSON.stringify(data, null, 2);
+  }
+  const cols = columns || Object.keys(data[0]);
+  const lines = [];
+  lines.push("| " + cols.join(" | ") + " |");
+  lines.push("| " + cols.map(() => "---").join(" | ") + " |");
+  for (const row of data) {
+    const vals = cols.map((col) => {
+      const val = row[col];
+      if (val === null || val === void 0) return "";
+      return String(val).replace(/\|/g, "\\|");
+    });
+    lines.push("| " + vals.join(" | ") + " |");
+  }
+  return lines.join("\n");
+}
+
+// src/output/csv.ts
+function renderCsv(data, columns) {
+  if (!Array.isArray(data) || data.length === 0) {
+    return typeof data === "string" ? data : JSON.stringify(data);
+  }
+  const cols = columns || Object.keys(data[0]);
+  const lines = [cols.join(",")];
+  for (const row of data) {
+    const vals = cols.map((col) => {
+      const val = row[col];
+      if (val === null || val === void 0) return "";
+      const str = String(val);
+      return str.includes(",") || str.includes('"') || str.includes("\n") ? `"${str.replace(/"/g, '""')}"` : str;
+    });
+    lines.push(vals.join(","));
+  }
+  return lines.join("\n");
+}
+
+// src/output/yaml.ts
+import yaml3 from "js-yaml";
+function renderYaml(data) {
+  return yaml3.dump(data, { indent: 2, lineWidth: 120 });
+}
+
+// src/output/index.ts
+function render(data, format, columns) {
+  switch (format) {
+    case "table":
+      return renderTable(data, columns);
+    case "json":
+      return renderJson(data);
+    case "markdown":
+      return renderMarkdown(data, columns);
+    case "csv":
+      return renderCsv(data, columns);
+    case "yaml":
+      return renderYaml(data);
+    default:
+      return renderJson(data);
+  }
+}
+export {
+  AgentCore,
+  BrowserManager,
+  FLAT_TREE_SCRIPT,
+  FORM_STATE_SCRIPT,
+  GET_INTERCEPTED_SCRIPT,
+  INTERACTIVE_ELEMENTS_SCRIPT,
+  LLM,
+  LLM_PROVIDERS,
+  MARKDOWN_SCRIPT,
+  OpenAIClient,
+  PuppeteerPage,
+  SEMANTIC_TREE_SCRIPT,
+  SNAPSHOT_SCRIPT,
+  Strategy,
+  buildInterceptorScript,
+  buildSnapshotScript,
+  cascadeProbe,
+  classifyIntent,
+  cli,
+  configSchema,
+  executePipeline,
+  exploreSite,
+  extractLinks,
+  extractMarkdown,
+  extractSnapshot,
+  extractText,
+  flatTreeToString,
+  getAdapter,
+  getAdapterByDomain,
+  getAdapterBySite,
+  getAllAdapters,
+  getAllSites,
+  getConfigDir,
+  getStep,
+  getStepNames,
+  heuristicClassify,
+  loadConfig,
+  lobsterFetch,
+  makeRoutingDecision,
+  parseHtml,
+  registerStep,
+  render,
+  renderTemplate,
+  saveConfig,
+  synthesizeAdapter
+};
+//# sourceMappingURL=lib.js.map