@ashx-j/lunr 0.2.20 → 0.2.22

package/dist/node-runtime/{pi-web-access-2CQGFLT2.js → pi-web-access-WTGMNZ32.js}

@@ -2,6 +2,10 @@ import { createRequire as __lunrRequire } from "node:module"; const require = __
 import {
   runSessionCleanups
 } from "./chunk-AUXVGBO4.js";
+import {
+  loadEnabledModelPatterns,
+  modelMatchesEnabledPatterns
+} from "./chunk-4ZWGEEAS.js";
 import {
   isBrowserCookieAccessAllowed
 } from "./chunk-DMMTJQMQ.js";
@@ -18,7 +22,7 @@ import {
   loadPerplexity,
   loadSummaryReview,
   loadTavily
-} from "./chunk-7NBZ5P7I.js";
+} from "./chunk-NAY6UUQZ.js";
 import {
   activityMonitor
 } from "./chunk-DAPBPCBP.js";
@@ -27,14 +31,10 @@ import {
   getWebSearchConfigPath
 } from "./chunk-VRB2IYGG.js";
 import {
-  loadEnabledModelPatterns,
-  modelMatchesEnabledPatterns
-} from "./chunk-4ZWGEEAS.js";
-import {
-  formatGroupedCall,
+  GroupedCallText,
   toolGroupTree,
   toolStatusDotFromContext
-} from "./chunk-KBKMCJDU.js";
+} from "./chunk-5ZQXRPMC.js";
 import "./chunk-CSFI6YXL.js";
 import "./chunk-FQMM2EZ2.js";
 import "./chunk-Q4Q6D4IY.js";
@@ -1035,7 +1035,7 @@ Open manually: ${handle.url}` }],
   }), initConfig.webSearch?.enabled !== !1 && pi.registerTool({
     name: "web_search",
     label: "Web Search",
-    description: 'Search the web using OpenAI, Brave, Parallel, Tavily, Exa, Perplexity, or Gemini. Returns an AI-synthesized answer with source citations. OpenAI web_search uses a Codex subscription or OpenAI API key. For comprehensive research, prefer queries (plural) with 2-4 varied angles over a single query \u2014 each query gets its own synthesized answer, so varying phrasing and scope gives much broader coverage. When includeContent is true, full page content is fetched in the background. Searches auto-open the interactive browser curator and stream results live; set workflow to "none" to skip curation or "auto-summary" for a model-generated summary without the browser curator. Provider auto-selects: OpenAI when suitable and available, then Exa, Brave, Parallel, Tavily, Perplexity, Gemini API, then Gemini Web.',
+    description: 'Search the web using OpenAI, Brave, Parallel, Tavily, Exa, Perplexity, or Gemini. Use web_search for discovery and fetch_content for reading URLs. When the browser tool is available, use it for JavaScript-rendered inspection or explicit website interaction; never automatically fall back to browser. Returns an AI-synthesized answer with source citations. OpenAI web_search uses a Codex subscription or OpenAI API key. For comprehensive research, prefer queries (plural) with 2-4 varied angles over a single query \u2014 each query gets its own synthesized answer, so varying phrasing and scope gives much broader coverage. When includeContent is true, full page content is fetched in the background. Searches auto-open the interactive browser curator and stream results live; set workflow to "none" to skip curation or "auto-summary" for a model-generated summary without the browser curator. Provider auto-selects: OpenAI when suitable and available, then Exa, Brave, Parallel, Tavily, Perplexity, Gemini API, then Gemini Web.',
     promptSnippet: "Use for web research questions. Prefer {queries:[...]} with 2-4 varied angles over a single query for broader coverage.",
     parameters: Type.Object({
       query: Type.Optional(Type.String({ description: "Single search query. For research tasks, prefer 'queries' with multiple varied angles instead." })),
@@ -1245,15 +1245,15 @@ Open manually: ${handle.url}` }],
       let queryList = collectSearchQueries(args), compact = !!(context && !context.isPartial && !context.expanded && !context.isError);
       if (formatSearchCallTitle(queryList).empty)
         return new Text(theme.fg("toolTitle", theme.bold("search ")) + theme.fg("error", "(no query)"), 0, 0);
-      let detail = formatSearchDetail(queryList, compact ? context?.result?.details : void 0);
-      return new Text(formatGroupedCall({
+      let detail = formatSearchDetail(queryList, compact ? context?.result?.details : void 0), header = new GroupedCallText("", 0, 0);
+      return header.setCall({
         role: context?.groupRole ?? "singleton",
         compact,
         tree: context ? toolGroupTree(context) : !1,
         dot: context ? toolStatusDotFromContext(context, theme) : theme.fg("success", "\u25CF"),
         title: theme.fg("toolTitle", theme.bold("search")),
         detail: theme.fg("accent", detail)
-      }), 0, 0);
+      }), header;
     },
     renderResult(result, { expanded, isPartial }, theme, context) {
       let details = result.details;
@@ -1294,7 +1294,7 @@ Open manually: ${handle.url}` }],
   }), pi.registerTool({
     name: "fetch_content",
     label: "Fetch Content",
-    description: "Fetch URL(s) and extract readable content as markdown. Supports YouTube video transcripts (with thumbnail), GitHub repository contents, and local video files (with frame thumbnail). Video frames can be extracted via timestamp/range or sampled across the entire video with frames alone. Falls back to Gemini for pages that block bots or fail Readability extraction. For YouTube and video files: ALWAYS pass the user's specific question via the prompt parameter \u2014 this directs the AI to focus on that aspect of the video, producing much better results than a generic extraction. Content is always stored and can be retrieved with get_search_content.",
+    description: "Fetch URL(s) and extract readable content as markdown. Prefer fetch_content for reading URLs and web_search for discovery. The browser tool handles JavaScript-rendered inspection and explicit website interactions when enabled; it is not an automatic fallback, and interaction tasks do not require a preliminary fetch. Supports YouTube video transcripts (with thumbnail), GitHub repository contents, and local video files (with frame thumbnail). Video frames can be extracted via timestamp/range or sampled across the entire video with frames alone. Falls back to Gemini for pages that block bots or fail Readability extraction. For YouTube and video files: ALWAYS pass the user's specific question via the prompt parameter \u2014 this directs the AI to focus on that aspect of the video, producing much better results than a generic extraction. Content is always stored and can be retrieved with get_search_content.",
     promptSnippet: "Use to extract readable content from URL(s), YouTube, GitHub repos, or local videos. For video questions, pass the user's exact question in prompt.",
     parameters: Type.Object({
       url: Type.Optional(Type.String({ description: "Single URL to fetch" })),
@@ -1402,15 +1402,15 @@ Use get_search_content({ responseId: "${responseId}", urlIndex: 0 }) to retrieve
       let urlList = collectFetchUrls(args), compact = !!(context && !context.isPartial && !context.expanded && !context.isError);
       if (formatFetchCallTitle(urlList).empty)
         return new Text(theme.fg("toolTitle", theme.bold("fetch ")) + theme.fg("error", "(no URL)"), 0, 0);
-      let detail = formatFetchDetail(urlList, compact ? context?.result?.details : void 0);
-      return new Text(formatGroupedCall({
+      let detail = formatFetchDetail(urlList, compact ? context?.result?.details : void 0), header = new GroupedCallText("", 0, 0);
+      return header.setCall({
         role: context?.groupRole ?? "singleton",
         compact,
         tree: context ? toolGroupTree(context) : !1,
         dot: context ? toolStatusDotFromContext(context, theme) : theme.fg("success", "\u25CF"),
         title: theme.fg("toolTitle", theme.bold("fetch")),
         detail: theme.fg("accent", detail)
-      }), 0, 0);
+      }), header;
     },
     renderResult(result, { expanded, isPartial }, theme, context) {
       let details = result.details;

package/dist/node-runtime/process-registry-4FAKZQOL.js

@@ -0,0 +1,31 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  clearRegistry,
+  isWindows,
+  kill,
+  killAll,
+  list,
+  markExited,
+  pause,
+  register,
+  restart,
+  resume,
+  unregister
+} from "./chunk-KKUTQQV7.js";
+import "./chunk-CSFI6YXL.js";
+import "./chunk-FQMM2EZ2.js";
+import "./chunk-Q4Q6D4IY.js";
+import "./chunk-BRJX2PRC.js";
+export {
+  clearRegistry,
+  isWindows,
+  kill,
+  killAll,
+  list,
+  markExited,
+  pause,
+  register,
+  restart,
+  resume,
+  unregister
+};

package/dist/node-runtime/{proxy-modes-V6YVFH3C.js → proxy-modes-OSQCWRBI.js}

@@ -6,7 +6,7 @@ import {
   resolveMcpOutputGuardOptions,
   resolveMcpResultContent,
   transformMcpContent
-} from "./chunk-IRPJXI6U.js";
+} from "./chunk-BX2RB477.js";
 import {
   buildToolMetadata,
   findToolByName,
@@ -17,13 +17,7 @@ import {
   updateMetadataCache,
   updateServerMetadata,
   updateStatusBar
-} from "./chunk-UWQYRSYQ.js";
-import {
-  abortable,
-  formatAuthRequiredMessage,
-  throwIfAborted,
-  truncateAtWord
-} from "./chunk-VSELYKWU.js";
+} from "./chunk-YJMMG7C6.js";
 import {
   UrlElicitationRequiredError,
   authenticate,
@@ -31,12 +25,18 @@ import {
   startAuth,
   supportsOAuth
 } from "./chunk-4TLO4PO2.js";
+import {
+  abortable,
+  formatAuthRequiredMessage,
+  throwIfAborted,
+  truncateAtWord
+} from "./chunk-VSELYKWU.js";
 import "./chunk-4HXHDDCF.js";
-import "./chunk-BI3DHYCN.js";
 import {
   getServerPrefix,
   parseUiPromptHandoff
 } from "./chunk-ARC4KOTI.js";
+import "./chunk-BI3DHYCN.js";
 import "./chunk-Q4Q6D4IY.js";
 import "./chunk-BRJX2PRC.js";
 

package/dist/node-runtime/rpc-entry.js

@@ -2,51 +2,66 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 import {
   main
-} from "./chunk-AL2FMKKM.js";
-import "./chunk-K3646JTM.js";
-import "./chunk-4DJ6HEGH.js";
-import "./chunk-AROOY4BB.js";
-import "./chunk-25I2BHAA.js";
-import "./chunk-JYNNB7DU.js";
-import "./chunk-STERBGUB.js";
-import "./chunk-4CSFRBCN.js";
+} from "./chunk-IWOWXRWU.js";
+import "./chunk-LMBNLFXQ.js";
+import "./chunk-UAFLNHSH.js";
+import "./chunk-YPHAIRZT.js";
+import "./chunk-PL6JKXWI.js";
+import "./chunk-5ZH3ZFIZ.js";
+import "./chunk-CSUZVNYE.js";
+import "./chunk-TDL7UWJ7.js";
+import "./chunk-CCCN2UCX.js";
+import "./chunk-IQIEU7SB.js";
 import "./chunk-OBMWP3I5.js";
 import "./chunk-DVGWF6A2.js";
 import "./chunk-QFWG2RVL.js";
-import "./chunk-CGBXPL3E.js";
-import "./chunk-WKDK4C5P.js";
+import "./chunk-VSSXXL36.js";
 import "./chunk-53YJI7JU.js";
-import "./chunk-KBKMCJDU.js";
-import "./chunk-CSFI6YXL.js";
+import "./chunk-5ZQXRPMC.js";
+import "./chunk-AD6VXAO7.js";
+import "./chunk-GS66LV4M.js";
 import {
   configureHttpDispatcher
-} from "./chunk-CBGB57XT.js";
-import "./chunk-GKLEQ3I4.js";
-import "./chunk-FVDOXRUD.js";
-import "./chunk-AOFXZQKA.js";
-import "./chunk-W3CVH5RX.js";
-import "./chunk-LTYWTR3V.js";
-import "./chunk-PL6JKXWI.js";
-import "./chunk-AD6VXAO7.js";
-import "./chunk-6N22HULO.js";
+} from "./chunk-WADV2VDS.js";
+import "./chunk-UP2XBVH5.js";
+import "./chunk-VWCE2HSZ.js";
+import "./chunk-LISUTZS3.js";
+import "./chunk-GMHJCCEN.js";
+import "./chunk-HTFRRDSF.js";
+import "./chunk-URD2SLIT.js";
+import "./chunk-OFKSVRV7.js";
+import "./chunk-5BNJ4JUH.js";
+import "./chunk-CGBXPL3E.js";
+import "./chunk-BBUVIEZB.js";
+import "./chunk-5D7LC2ZQ.js";
 import "./chunk-M3LZLQW2.js";
+import "./chunk-KKUTQQV7.js";
+import "./chunk-CSFI6YXL.js";
+import "./chunk-AZJHNQKQ.js";
+import "./chunk-XLTL257W.js";
+import "./chunk-FVDOXRUD.js";
+import "./chunk-4EULYYR4.js";
+import "./chunk-UJOCPOMX.js";
+import "./chunk-2TKODGBZ.js";
+import "./chunk-2MI5OPMN.js";
+import "./chunk-IMLCWLPI.js";
+import "./chunk-ORH324EP.js";
+import "./chunk-UAEOTO52.js";
 import "./chunk-RQ2Q5IYR.js";
 import "./chunk-JHYKXIMM.js";
 import "./chunk-H2EOZYMP.js";
+import "./chunk-5EFIU3OM.js";
 import "./chunk-PVCDKGR6.js";
 import "./chunk-OR4L3IB2.js";
-import "./chunk-HQCKFM2O.js";
-import "./chunk-AY6CAJSL.js";
-import "./chunk-QZMODZQ2.js";
+import "./chunk-R3K2F5GI.js";
+import "./chunk-E24EO34J.js";
 import "./chunk-CCZJ3PYY.js";
-import "./chunk-6KDIOJL3.js";
-import "./chunk-2SJB2AWP.js";
+import "./chunk-6427XAWG.js";
+import "./chunk-PC2Z5TKZ.js";
 import "./chunk-I6R76AG7.js";
-import "./chunk-JZQ7F36T.js";
-import "./chunk-5EFIU3OM.js";
-import "./chunk-BOHIDQT4.js";
-import "./chunk-DDWHZ633.js";
-import "./chunk-RNBHABBA.js";
+import "./chunk-6B2POMK7.js";
+import "./chunk-GNN7H3B7.js";
+import "./chunk-7QWNYZDI.js";
 import {
   APP_NAME
 } from "./chunk-FQMM2EZ2.js";

package/dist/node-runtime/{rpc-mode-W5ZTLTMZ.js → rpc-mode-P5ODXPEG.js}

@@ -1,10 +1,10 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 import {
   runRpcMode
-} from "./chunk-OPEK5RRY.js";
+} from "./chunk-IVXYUAJE.js";
 import "./chunk-OBMWP3I5.js";
 import "./chunk-CSFI6YXL.js";
-import "./chunk-RNBHABBA.js";
+import "./chunk-7QWNYZDI.js";
 import "./chunk-FQMM2EZ2.js";
 import "./chunk-Q4Q6D4IY.js";
 import "./chunk-BRJX2PRC.js";

package/dist/node-runtime/runtime-4VA6JKNF.js

@@ -0,0 +1,373 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  truncateHead
+} from "./chunk-53YJI7JU.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/core/browser/network.js
+import { lookup } from "node:dns/promises";
+import { createServer, request } from "node:http";
+import { BlockList, connect, isIP } from "node:net";
+var blocked = new BlockList();
+for (let [address, prefix] of [
+  ["0.0.0.0", 8],
+  ["10.0.0.0", 8],
+  ["100.64.0.0", 10],
+  ["127.0.0.0", 8],
+  ["169.254.0.0", 16],
+  ["172.16.0.0", 12],
+  ["192.0.0.0", 24],
+  ["192.0.2.0", 24],
+  ["192.168.0.0", 16],
+  ["192.88.99.0", 24],
+  ["198.18.0.0", 15],
+  ["198.51.100.0", 24],
+  ["203.0.113.0", 24],
+  ["224.0.0.0", 4],
+  ["240.0.0.0", 4]
+])
+  blocked.addSubnet(address, prefix, "ipv4");
+for (let [address, prefix] of [
+  ["2001::", 23],
+  ["2001:db8::", 32],
+  ["2002::", 16],
+  ["3fff::", 20]
+])
+  blocked.addSubnet(address, prefix, "ipv6");
+var globalV6 = new BlockList();
+globalV6.addSubnet("2000::", 3, "ipv6");
+function isPublicAddress(address) {
+  return isIP(address) === 4 ? !blocked.check(address, "ipv4") : isIP(address) === 6 && globalV6.check(address, "ipv6") && !blocked.check(address, "ipv6");
+}
+function browserUrl(raw) {
+  let url = new URL(raw);
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password)
+    throw new Error("Browser permits HTTP(S) URLs without embedded credentials only.");
+  return url;
+}
+async function resolveBrowserHost(host, allowPrivate) {
+  let hostname = host.replace(/^\[|\]$/g, ""), addresses = isIP(hostname) ? [{ address: hostname }] : await lookup(hostname, { all: !0 });
+  if (!addresses.length || !allowPrivate && addresses.some(({ address }) => !isPublicAddress(address)))
+    throw new Error("Browser network policy blocked a private or reserved address. Local/private access requires explicit user configuration.");
+  return addresses[0].address;
+}
+async function createBrowserProxy(allowPrivate) {
+  let sockets = /* @__PURE__ */ new Set(), closed = !1, lastBlocked, track = (socket) => {
+    if (closed || sockets.size >= 128) {
+      socket.destroy();
+      return;
+    }
+    sockets.add(socket), socket.setTimeout(3e4, () => socket.destroy()), socket.on("close", () => sockets.delete(socket)), socket.on("error", () => socket.destroy());
+  }, server = createServer(async (incoming, outgoing) => {
+    try {
+      let url = browserUrl(incoming.url ?? "");
+      if (url.protocol !== "http:")
+        throw new Error("Use CONNECT for HTTPS.");
+      let address2 = await resolveBrowserHost(url.hostname, allowPrivate);
+      if (closed || incoming.destroyed)
+        return outgoing.destroy();
+      let headers = { ...incoming.headers, host: url.host };
+      delete headers["proxy-authorization"], delete headers["proxy-connection"];
+      let upstream = request({
+        hostname: address2,
+        port: url.port || 80,
+        method: incoming.method,
+        path: `${url.pathname}${url.search}`,
+        headers,
+        agent: !1
+      }, (response) => {
+        outgoing.writeHead(response.statusCode ?? 502, response.headers), response.pipe(outgoing);
+      });
+      upstream.on("socket", track), upstream.on("error", () => outgoing.destroy()), outgoing.on("close", () => upstream.destroy()), incoming.pipe(upstream);
+    } catch (error) {
+      lastBlocked = error instanceof Error ? error.message : "Network request blocked.", outgoing.writeHead(403).end("Browser network policy blocked this request.");
+    }
+  });
+  server.on("connection", track), server.on("connect", async (incoming, client, head) => {
+    try {
+      let url = browserUrl(`https://${incoming.url}`), address2 = await resolveBrowserHost(url.hostname, allowPrivate);
+      if (closed || client.destroyed)
+        return client.destroy();
+      let upstream = connect({ host: address2, port: Number(url.port || 443) });
+      track(upstream), client.on("close", () => upstream.destroy()), upstream.on("close", () => client.destroy()), upstream.on("connect", () => {
+        client.write(`HTTP/1.1 200 Connection Established\r
+\r
+`), head.length && upstream.write(head), client.pipe(upstream), upstream.pipe(client);
+      });
+    } catch (error) {
+      lastBlocked = error instanceof Error ? error.message : "Network request blocked.", client.end(`HTTP/1.1 403 Forbidden\r
+Connection: close\r
+\r
+`);
+    }
+  }), server.on("upgrade", (_request, socket) => socket.destroy()), server.on("clientError", (_error, socket) => socket.destroy()), await new Promise((resolve, reject) => {
+    server.once("error", reject), server.listen(0, "127.0.0.1", () => {
+      server.off("error", reject), resolve();
+    });
+  });
+  let address = server.address();
+  if (!address || typeof address == "string")
+    throw new Error("Browser proxy failed to listen.");
+  return {
+    url: `http://127.0.0.1:${address.port}`,
+    blockedReason: () => lastBlocked,
+    async close() {
+      closed = !0;
+      for (let socket of sockets)
+        socket.destroy();
+      await new Promise((resolve) => server.close(() => resolve()));
+    }
+  };
+}
+
+// packages/coding-agent/dist/core/browser/runtime.js
+function boundedBrowserText(text) {
+  let result = truncateHead(text.replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, ""), { maxBytes: 16384, maxLines: 300 });
+  return result.content + (result.truncated ? `
+[Snapshot truncated. Inspect a specific role/name or label to narrow it.]` : "");
+}
+function target(page, input) {
+  if (input.label !== void 0 && input.role === void 0 && input.name === void 0)
+    return page.getByLabel(input.label, { exact: !0 });
+  if (input.role && input.label === void 0)
+    return page.getByRole(input.role, { name: input.name, exact: !0 });
+  throw new Error("Specify role with optional exact name, or label alone. Inspect the page to find a target.");
+}
+async function uniqueTarget(page, input) {
+  let locator = target(page, input), count = await locator.count();
+  if (count !== 1)
+    throw new Error(`Target matched ${count} elements. Inspect and choose a unique exact role/name or label; no action was taken.`);
+  return locator;
+}
+var BrowserSession = class {
+  resources;
+  queue = Promise.resolve();
+  closing = Promise.resolve();
+  generation = 0;
+  queued = 0;
+  idle;
+  allowPrivate;
+  idleMs;
+  constructor(allowPrivate = !1, idleMs = 3e5) {
+    this.allowPrivate = allowPrivate, this.idleMs = idleMs;
+  }
+  async close() {
+    this.generation++, clearTimeout(this.idle);
+    let pending = this.resources;
+    this.resources = void 0;
+    let previous = this.closing, closing = (async () => {
+      await previous;
+      let resources = await pending?.catch(() => {
+      });
+      if (resources)
+        try {
+          await resources.browser.close();
+        } finally {
+          await resources.proxy.close();
+        }
+    })();
+    return this.closing = closing.catch(() => {
+    }), closing;
+  }
+  async run(input, signal) {
+    if (this.queued >= 16)
+      throw new Error("Browser queue is full. Wait for the current operation.");
+    let generation = this.generation;
+    this.queued++;
+    let operation = this.queue.then(async () => {
+      if (signal?.aborted || generation !== this.generation)
+        throw new Error("Browser operation cancelled; navigate again in a new call.");
+      clearTimeout(this.idle);
+      let cancellation = new AbortController(), abort = () => {
+        cancellation.abort(), this.close().catch(() => {
+        });
+      };
+      signal?.addEventListener("abort", abort, { once: !0 });
+      let deadline = setTimeout(abort, 3e4);
+      try {
+        if (input.action === "close")
+          return await this.close(), {
+            content: [{ type: "text", text: "Browser closed; ephemeral cookies and tabs discarded." }],
+            details: { action: input.action }
+          };
+        if (await this.closing, signal?.aborted || generation !== this.generation)
+          throw new Error("Browser operation cancelled.");
+        if (!this.resources && input.action !== "navigate" && !(input.action === "tabs" && input.operation === "create"))
+          throw new Error("No browser is open. Use navigate or tabs/create first. Idle cleanup discards tabs after 5 minutes.");
+        this.resources ??= this.open().catch((error) => {
+          throw generation === this.generation && (this.resources = void 0), error;
+        });
+        let resources = await this.resources;
+        if (generation !== this.generation)
+          throw new Error("Browser operation cancelled.");
+        let content = await Promise.race([
+          this.perform(resources, input),
+          new Promise((_resolve, reject) => {
+            let cancelled = () => reject(new Error("Browser cancelled or exceeded 30s; browser closed. External effects may already have occurred."));
+            cancellation.signal.aborted ? cancelled() : cancellation.signal.addEventListener("abort", cancelled, { once: !0 });
+          })
+        ]);
+        if (signal?.aborted || generation !== this.generation)
+          throw new Error("Browser operation cancelled; external effects may already have occurred. Inspect before retrying.");
+        return this.idle = setTimeout(() => {
+          this.close().catch(() => {
+          });
+        }, this.idleMs), this.idle.unref(), { content, details: { action: input.action } };
+      } catch (error) {
+        generation === this.generation && (this.idle = setTimeout(() => {
+          this.close().catch(() => {
+          });
+        }, this.idleMs), this.idle.unref());
+        let message = error instanceof Error ? error.message : String(error);
+        throw new Error(boundedBrowserText(message));
+      } finally {
+        clearTimeout(deadline), signal?.removeEventListener("abort", abort);
+      }
+    });
+    this.queue = operation.catch(() => {
+    });
+    try {
+      return await operation;
+    } finally {
+      this.queued--;
+    }
+  }
+  async open() {
+    let proxy = await createBrowserProxy(this.allowPrivate), browser;
+    try {
+      let { chromium } = await import("playwright-core");
+      browser = await chromium.launch({
+        headless: !0,
+        timeout: 15e3,
+        chromiumSandbox: !0,
+        proxy: { server: proxy.url, bypass: "<-loopback>" },
+        args: ["--disable-quic", "--force-webrtc-ip-handling-policy=disable_non_proxied_udp"]
+      });
+      let context = await browser.newContext({
+        acceptDownloads: !1,
+        serviceWorkers: "block",
+        permissions: [],
+        viewport: { width: 1280, height: 800 }
+      });
+      context.setDefaultTimeout(1e4), context.setDefaultNavigationTimeout(15e3), await context.route("**/*", async (route) => {
+        try {
+          browserUrl(route.request().url()), await route.continue();
+        } catch {
+          await route.abort().catch(() => {
+          });
+        }
+      }), await context.routeWebSocket("**/*", (socket) => socket.close());
+      let resources = { browser, context, proxy, pages: /* @__PURE__ */ new Map(), nextId: 1 };
+      return context.on("page", (page) => {
+        if (resources.pages.size >= 4) {
+          page.close().catch(() => {
+          });
+          return;
+        }
+        let id = resources.nextId++;
+        resources.pages.set(id, page), page.on("close", () => resources.pages.delete(id)), page.on("dialog", (dialog) => {
+          dialog.dismiss().catch(() => {
+          });
+        }), page.on("download", (download) => {
+          download.cancel().catch(() => {
+          });
+        });
+      }), resources;
+    } catch (error) {
+      await browser?.close().catch(() => {
+      }), await proxy.close();
+      let message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Browser launch failed. Matching Chromium may be missing after --ignore-scripts or offline installation. Ask the user to run lunr browser install when online. Nothing was installed by this call. ${message}`);
+    }
+  }
+  async perform(resources, input) {
+    let text = (value) => [{ type: "text", text: boundedBrowserText(value) }], page = resources.pages.get(input.tab ?? resources.selected ?? -1);
+    if (input.action === "tabs") {
+      if (!input.operation)
+        throw new Error("tabs requires operation list/create/select/close.");
+      if (input.operation === "list")
+        return text(JSON.stringify([...resources.pages].map(([id, tab]) => ({
+          id,
+          selected: id === resources.selected,
+          url: tab.url()
+        }))));
+      if (input.operation === "select") {
+        if (!page || input.tab === void 0)
+          throw new Error("Select requires an existing tab id from tabs/list.");
+        return resources.selected = input.tab, text(`Selected tab ${input.tab}.`);
+      }
+      if (input.operation === "close") {
+        if (!page)
+          throw new Error("No matching tab. Use tabs/list.");
+        return await page.close(), resources.pages.has(resources.selected ?? -1) || (resources.selected = resources.pages.keys().next().value), text("Tab closed.");
+      }
+    }
+    if (input.action === "navigate" || input.action === "tabs" && input.operation === "create") {
+      if (input.action === "navigate" && !input.url)
+        throw new Error("navigate requires url.");
+      let url = input.url ? browserUrl(input.url) : void 0;
+      if (url && await resolveBrowserHost(url.hostname, this.allowPrivate), input.tab !== void 0 && !page && input.action === "navigate")
+        throw new Error("Unknown tab. Use tabs/list.");
+      if (!page || input.action === "tabs") {
+        if (resources.pages.size >= 4)
+          throw new Error("Maximum 4 tabs. Close a tab first.");
+        page = await resources.context.newPage();
+      }
+      return resources.selected = [...resources.pages].find(([, candidate]) => candidate === page)?.[0], url && await page.goto(url.href, { waitUntil: "domcontentloaded" }), text(`Tab ${resources.selected}: ${page.url()}
+Use inspect for rendered content.${resources.proxy.blockedReason() ? `
+Network warning: ${resources.proxy.blockedReason()}` : ""}`);
+    }
+    if (!page)
+      throw new Error("No selected tab. Use tabs/list or navigate.");
+    if (input.action === "inspect") {
+      let locator = input.role || input.label !== void 0 ? await uniqueTarget(page, input) : page.locator("body");
+      return text(`Untrusted page content at ${page.url()}:
+${await locator.ariaSnapshot()}`);
+    }
+    if (input.action === "screenshot") {
+      let image = await page.screenshot({ type: "jpeg", quality: 70, fullPage: !1, timeout: 1e4 });
+      if (image.length > 2 * 1024 * 1024)
+        throw new Error("Screenshot exceeds 2MB limit.");
+      return [
+        ...text(`Untrusted viewport screenshot at ${page.url()}`),
+        { type: "image", mimeType: "image/jpeg", data: image.toString("base64") }
+      ];
+    }
+    if (input.action === "act") {
+      let locator = await uniqueTarget(page, input);
+      switch (input.interaction) {
+        case "click":
+          await locator.click();
+          break;
+        case "fill":
+          if (input.value === void 0)
+            throw new Error("fill requires value.");
+          await locator.fill(input.value);
+          break;
+        case "select":
+          if (input.value === void 0)
+            throw new Error("select requires option value.");
+          await locator.selectOption(input.value);
+          break;
+        case "check":
+          if (input.checked === void 0)
+            throw new Error("check requires checked.");
+          await locator.setChecked(input.checked);
+          break;
+        case "press":
+          if (!input.value || !/^(Enter|Tab|Escape|Space|Backspace|Delete|ArrowUp|ArrowDown|ArrowLeft|ArrowRight|Home|End|PageUp|PageDown)$/.test(input.value))
+            throw new Error("press accepts Enter/Tab/Escape/Space/Backspace/Delete/arrows/Home/End/PageUp/PageDown only. Use fill for text.");
+          await locator.press(input.value);
+          break;
+        default:
+          throw new Error("act requires interaction click/fill/select/check/press.");
+      }
+      return text(`Interaction completed at ${page.url()}. Inspect to verify the result. External effects cannot be undone by /undo.`);
+    }
+    throw new Error("Unsupported browser action.");
+  }
+};
+export {
+  BrowserSession,
+  boundedBrowserText
+};

package/dist/node-runtime/{runtime-bridges-NJQERQ72.js → runtime-bridges-3XUQ46XW.js}

@@ -1,11 +1,12 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 import {
   bindRuntimeBridges
-} from "./chunk-AOFXZQKA.js";
-import "./chunk-W3CVH5RX.js";
-import "./chunk-LTYWTR3V.js";
-import "./chunk-HQCKFM2O.js";
-import "./chunk-AY6CAJSL.js";
+} from "./chunk-GMHJCCEN.js";
+import "./chunk-4EULYYR4.js";
+import "./chunk-UJOCPOMX.js";
+import "./chunk-2TKODGBZ.js";
+import "./chunk-2MI5OPMN.js";
+import "./chunk-IMLCWLPI.js";
 import "./chunk-BRJX2PRC.js";
 export {
   bindRuntimeBridges