smooth-operator-mcp 3.0.5 → 3.0.6

package/dist/smooth-operator.mjs

@@ -397,7 +397,7 @@ var SERVER_VERSION;
 var init_version = __esm({
   "src/server/version.ts"() {
     "use strict";
-    SERVER_VERSION = "3.0.5";
+    SERVER_VERSION = "3.0.6";
   }
 });
 
@@ -406,17 +406,39 @@ var discovery_exports = {};
 __export(discovery_exports, {
   chromeExecutableSearchPaths: () => chromeExecutableSearchPaths,
   findChromeExecutable: () => findChromeExecutable,
-  findChromiumExecutables: () => findChromiumExecutables
+  findChromiumExecutables: () => findChromiumExecutables,
+  isExecutableReady: () => isExecutableReady
 });
 import * as nodeFs from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { delimiter, join as join3, win32 } from "node:path";
 import { env as env2 } from "node:process";
 function findChromeExecutable(fs = nodeFs) {
-  return dedupeCandidates(chromeExecutableCandidates()).find((candidate) => fs.existsSync(candidate.path)) ?? null;
+  return dedupeCandidates(chromeExecutableCandidates()).find((candidate) => isExecutableReady(candidate.path, fs)) ?? null;
 }
 function findChromiumExecutables(fs = nodeFs) {
-  return dedupeCandidates(chromeExecutableCandidates()).filter((candidate) => fs.existsSync(candidate.path));
+  return dedupeCandidates(chromeExecutableCandidates()).filter((candidate) => isExecutableReady(candidate.path, fs));
+}
+function isExecutableReady(path, fs = nodeFs, platformName = process.platform) {
+  if (typeof path !== "string" || path.length === 0) {
+    return false;
+  }
+  try {
+    const stats = fs.statSync(path);
+    if (!stats.isFile()) {
+      return false;
+    }
+    if (platformName === "win32") {
+      return true;
+    }
+    if ((stats.mode & 73) === 0) {
+      return false;
+    }
+    fs.accessSync(path, nodeFs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
 }
 function chromeExecutableSearchPaths() {
   return dedupeCandidates(chromeExecutableCandidates()).map((candidate) => candidate.path);
@@ -510,7 +532,7 @@ var init_discovery = __esm({
 });
 
 // src/server/installer.ts
-import { constants as constants2, accessSync, existsSync } from "node:fs";
+import { constants as constants3, accessSync, existsSync } from "node:fs";
 import { chmod as chmod2, lstat as lstat3, mkdir as mkdir3, open as open3, rename as rename3, unlink as unlink3, writeFile } from "node:fs/promises";
 import { execFile } from "node:child_process";
 import { randomUUID as randomUUID3 } from "node:crypto";
@@ -596,7 +618,7 @@ function resolveStableNodeExecutable() {
   const candidates = platform2() === "darwin" ? ["/opt/homebrew/bin/node", "/usr/local/bin/node"] : ["/usr/local/bin/node", "/usr/bin/node"];
   for (const candidate of candidates) {
     try {
-      accessSync(candidate, constants2.X_OK);
+      accessSync(candidate, constants3.X_OK);
       return candidate;
     } catch {
     }
@@ -731,20 +753,20 @@ async function installJsonConfig(target, plannedPath, options, allowOpenCodeJson
   }
 }
 async function readSecureConfigFile(path) {
-  const noFollow = typeof constants2.O_NOFOLLOW === "number" ? constants2.O_NOFOLLOW : 0;
+  const noFollow = typeof constants3.O_NOFOLLOW === "number" ? constants3.O_NOFOLLOW : 0;
   if (!noFollow) {
     await rejectSymlink2(path, "configuration file");
   }
   let handle;
   try {
-    handle = await open3(path, constants2.O_RDONLY | noFollow);
+    handle = await open3(path, constants3.O_RDONLY | noFollow);
   } catch (error) {
     if (isMissingFile2(error)) {
       return void 0;
     }
     if (noFollow && (isErrorCode2(error, "EINVAL") || isErrorCode2(error, "ENOTSUP") || isErrorCode2(error, "EOPNOTSUPP"))) {
       await rejectSymlink2(path, "configuration file");
-      handle = await open3(path, constants2.O_RDONLY);
+      handle = await open3(path, constants3.O_RDONLY);
     } else {
       if (isErrorCode2(error, "ELOOP") || isErrorCode2(error, "EFTYPE")) {
         throw new AppError("INSTALL_CONFIG_FAILED", `The configuration file '${path}' must not be a symbolic link.`);
@@ -1238,7 +1260,7 @@ __export(installer_wizard_exports, {
   runWizard: () => runWizard
 });
 import { dirname as dirname5, isAbsolute as isAbsolute4, join as join7, parse as parse4, resolve as resolve6, win32 as win323 } from "node:path";
-import { accessSync as accessSync2, constants as constants3, statSync } from "node:fs";
+import { accessSync as accessSync2, constants as constants4, statSync } from "node:fs";
 import { chmod as chmod3, lstat as lstat4, rename as rename4, unlink as unlink4, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
 import { isIP as isIP3 } from "node:net";
@@ -1261,7 +1283,7 @@ function isExecutableFile(path) {
       return false;
     }
     if (process.platform !== "win32") {
-      accessSync2(path, constants3.X_OK);
+      accessSync2(path, constants4.X_OK);
     }
     return true;
   } catch {
@@ -2294,6 +2316,7 @@ var SecurityPolicy = class _SecurityPolicy {
 // src/server/config.ts
 var TransportSchema = z.enum(["stdio", "http"]);
 var BrowserModeSchema = z.enum(["disabled", "connect", "launch", "managed"]);
+var BrowserIdleTimeoutSchema = z.number().int().min(0).max(864e5);
 var ConfigPathSchema = z.string().trim().min(1).max(4096);
 var DomainPatternSchema = z.string().trim().min(1).max(253).refine(isValidDomainPattern2, "Domain patterns must be exact hostnames or *.-prefixed suffixes.");
 var HostPatternSchema = z.string().trim().min(1).max(255).refine(isValidHostPattern, "Host allowlists must contain hostnames or bracketed IPv6 addresses without ports.");
@@ -2326,7 +2349,8 @@ var RawConfigSchema = z.object({
     connectTimeoutMs: z.number().int().min(1e3).max(18e4).optional(),
     cdpTimeoutMs: z.number().int().min(100).max(12e4).optional(),
     maxScreenshotBytes: z.number().int().min(1e5).max(2e7).optional(),
-    maxHtmlChars: z.number().int().min(1e3).max(5e5).optional()
+    maxHtmlChars: z.number().int().min(1e3).max(5e5).optional(),
+    idleTimeoutMs: BrowserIdleTimeoutSchema.optional()
   }).strict().optional(),
   security: z.object({
     allowedDomains: ConfigList(DomainPatternSchema).optional(),
@@ -2647,6 +2671,9 @@ function validateConfig(config) {
   if (config.browser.maxHtmlChars < 1e3 || config.browser.maxHtmlChars > 5e5) {
     throw new AppError("CONFIG_INVALID", "Maximum HTML characters must be between 1000 and 500000.");
   }
+  if (!Number.isSafeInteger(config.browser.idleTimeoutMs) || config.browser.idleTimeoutMs < 0 || config.browser.idleTimeoutMs > 864e5) {
+    throw new AppError("CONFIG_INVALID", "Browser idle timeout must be between 0ms and 86400000ms.");
+  }
   validateBrowserEndpoint(config.browser.url, ["http:", "https:"], "Browser DevTools URL");
   validateBrowserEndpoint(config.browser.wsEndpoint, ["ws:", "wss:"], "Browser WebSocket endpoint");
   if (config.stealth && config.stealth.profile !== "balanced" && config.stealth.profile !== "max") {
@@ -2729,7 +2756,8 @@ function loadServerConfig(args = [], environment = env, homeDirectory = homedir(
       connectTimeoutMs: parseInteger(environment.SMOOTH_OPERATOR_BROWSER_CONNECT_TIMEOUT_MS, nestedBrowser.connectTimeoutMs ?? 3e4),
       cdpTimeoutMs: parseInteger(environment.SMOOTH_OPERATOR_BROWSER_CDP_TIMEOUT_MS, nestedBrowser.cdpTimeoutMs ?? 3e4),
       maxScreenshotBytes: parseInteger(environment.SMOOTH_OPERATOR_MAX_SCREENSHOT_BYTES, nestedBrowser.maxScreenshotBytes ?? 8e6),
-      maxHtmlChars: parseInteger(environment.SMOOTH_OPERATOR_MAX_HTML_CHARS, nestedBrowser.maxHtmlChars ?? 2e5)
+      maxHtmlChars: parseInteger(environment.SMOOTH_OPERATOR_MAX_HTML_CHARS, nestedBrowser.maxHtmlChars ?? 2e5),
+      idleTimeoutMs: parseInteger(environment.SMOOTH_OPERATOR_BROWSER_IDLE_TIMEOUT_MS, nestedBrowser.idleTimeoutMs ?? 0)
     },
     security: {
       allowedDomains: normalizeDomainList(parseList(environment.SMOOTH_OPERATOR_ALLOWED_DOMAINS, nestedSecurity.allowedDomains ?? [])),
@@ -2795,6 +2823,9 @@ var RESEARCH_QUERY_MAX_CHARS = 4e3;
 var RESEARCH_MIN_CHARS = 500;
 var RESEARCH_MAX_CHARS = 4e3;
 var RESEARCH_MAX_RESULTS = 10;
+var RESOURCE_BLOCKING_TYPES = ["image", "stylesheet", "font", "media", "script"];
+var ResourceBlockingTypeSchema = z2.enum(RESOURCE_BLOCKING_TYPES);
+var ResourceBlockingOperationSchema = z2.enum(["get", "set", "clear"]);
 var isHttpUrl = (value) => {
   try {
     const url = new URL(value);
@@ -2831,6 +2862,8 @@ var BrowserActionNames = [
   "enable_network_log",
   "disable_network_log",
   "get_network_log",
+  "search_network_log",
+  "resource_blocking",
   "clear_network_log",
   "getclear_network_log",
   // canonical action spelling of the read_and_clear operation
@@ -2851,6 +2884,7 @@ var BrowserActionNames = [
   "page_next",
   "search_page",
   "find_elements",
+  "inspect_element",
   "list_interactive",
   "list_frames",
   "accessibility_snapshot",
@@ -2920,15 +2954,25 @@ var BrowserActionFieldsSchema = z2.object({
   state: z2.enum(["visible", "hidden", "attached", "detached"]).optional(),
   waitUntil: z2.enum(["load", "domcontentloaded", "networkidle0", "networkidle2"]).optional(),
   filePath: BoundedString(4e3).optional(),
+  filePaths: z2.array(BoundedString(4e3)).min(1).max(20).optional(),
   outputPath: BoundedString(4e3).optional(),
   code: z2.string().trim().min(1).max(4e4).optional(),
   script: z2.string().trim().min(1).max(4e4).optional(),
   expression: z2.string().trim().min(1).max(4e4).optional(),
   query: BoundedString(4e3).optional(),
+  requestId: BoundedString(256).optional(),
+  method: BoundedString(32).optional(),
+  status: z2.number().int().min(0).max(999).optional(),
+  resourceType: BoundedString(64).optional(),
+  operation: ResourceBlockingOperationSchema.optional(),
+  resourceTypes: z2.array(ResourceBlockingTypeSchema).min(1).max(RESOURCE_BLOCKING_TYPES.length).optional(),
+  limit: z2.number().int().min(1).max(200).optional(),
   includeLinks: z2.boolean().optional(),
   includeSnapshot: z2.boolean().optional(),
   maxChars: z2.number().int().min(100).max(MCP_PAGE_TEXT_MAX_CHARS).optional(),
   maxNodes: z2.number().int().min(1).max(2e3).optional(),
+  maxDepth: z2.number().int().min(0).max(3).optional(),
+  maxChildren: z2.number().int().min(1).max(100).optional(),
   interestingOnly: z2.boolean().optional(),
   maxBytes: z2.number().int().min(1e5).max(2e7).optional(),
   format: z2.enum(["png", "jpeg"]).optional(),
@@ -2958,6 +3002,7 @@ var BrowserActionFieldsSchema = z2.object({
   cookiePath: BoundedString(2e3).optional(),
   cookieSecure: z2.boolean().optional(),
   cookieHttpOnly: z2.boolean().optional(),
+  cookieSameSite: z2.enum(["Strict", "Lax", "None"]).optional(),
   storageArea: z2.enum(["local", "session"]).optional(),
   storageKey: BoundedString(1e3).optional(),
   storageValue: z2.string().max(2e4).optional(),
@@ -3050,13 +3095,54 @@ var BrowserActionSchema = BrowserActionFieldsSchema.extend({ action: ActionNameS
   if (input.cookieValue !== void 0 && input.value !== void 0 && input.action === "set_cookie") {
     context.addIssue({ code: "custom", message: "Provide cookieValue or value, not both." });
   }
+  if (input.cookieSameSite !== void 0 && input.action !== "set_cookie") {
+    context.addIssue({ code: "custom", message: "cookieSameSite is only valid for set_cookie." });
+  }
   if (input.storageValue !== void 0 && input.value !== void 0 && input.action === "set_storage") {
     context.addIssue({ code: "custom", message: "Provide storageValue or value, not both." });
   }
   if (input.outputPath !== void 0 && input.filePath !== void 0 && input.action === "save_as_pdf") {
     context.addIssue({ code: "custom", message: "Provide outputPath or filePath, not both." });
   }
-  if (["navigate", "set_cookie"].includes(input.action) && input.url !== void 0 && !isHttpUrl(input.url)) {
+  if (input.action === "upload_file") {
+    const hasFilePath = input.filePath !== void 0;
+    const hasFilePaths = input.filePaths !== void 0;
+    if (hasFilePath && hasFilePaths) {
+      context.addIssue({ code: "custom", message: "Provide filePath or filePaths, not both." });
+    }
+    if (!hasFilePath && !hasFilePaths) {
+      context.addIssue({ code: "custom", message: "Upload requires filePath or filePaths." });
+    }
+  } else if (input.filePaths !== void 0) {
+    context.addIssue({ code: "custom", message: "filePaths is only valid for upload_file." });
+  }
+  if (input.action === "resource_blocking") {
+    if (input.operation === void 0) {
+      context.addIssue({ code: "custom", message: "Resource blocking requires operation." });
+    } else if (input.operation === "set") {
+      if (input.resourceTypes === void 0) {
+        context.addIssue({ code: "custom", message: "Resource blocking set requires resourceTypes." });
+      } else if (new Set(input.resourceTypes).size !== input.resourceTypes.length) {
+        context.addIssue({ code: "custom", message: "Resource blocking resourceTypes must be de-duplicated." });
+      }
+    } else if (input.resourceTypes !== void 0) {
+      context.addIssue({ code: "custom", message: `Resource blocking ${input.operation} does not accept resourceTypes.` });
+    }
+  } else {
+    if (input.operation !== void 0) {
+      context.addIssue({ code: "custom", message: "operation is only valid for resource blocking." });
+    }
+    if (input.resourceTypes !== void 0) {
+      context.addIssue({ code: "custom", message: "resourceTypes is only valid for resource blocking." });
+    }
+  }
+  if (input.action !== "inspect_element" && input.maxDepth !== void 0) {
+    context.addIssue({ code: "custom", message: "maxDepth is only valid for inspect_element." });
+  }
+  if (input.action !== "inspect_element" && input.maxChildren !== void 0) {
+    context.addIssue({ code: "custom", message: "maxChildren is only valid for inspect_element." });
+  }
+  if (["navigate", "get_cookies", "set_cookie", "delete_cookies"].includes(input.action) && input.url !== void 0 && !isHttpUrl(input.url)) {
     context.addIssue({ code: "custom", message: "Navigation and cookie URLs must be absolute HTTP(S) URLs." });
   }
   if (input.action === "click") {
@@ -3113,6 +3199,7 @@ var BrowserActionSchema = BrowserActionFieldsSchema.extend({ action: ActionNameS
     case "wait_for_element":
     case "dropdown_options":
     case "find_elements":
+    case "inspect_element":
     case "get_computed_style":
     case "hover":
     case "press_and_hold":
@@ -3127,7 +3214,7 @@ var BrowserActionSchema = BrowserActionFieldsSchema.extend({ action: ActionNameS
       break;
     case "upload_file":
       requireOne([input.target, input.ref, input.selector, input.index], "Upload requires target, ref, selector, or index.");
-      requireOne([input.filePath], "Upload requires filePath.");
+      requireOne([input.filePath, input.filePaths], "Upload requires filePath or filePaths.");
       break;
     case "save_as_pdf":
       requireOne([input.outputPath, input.filePath], "PDF export requires outputPath.");
@@ -3215,6 +3302,7 @@ function normalizeBrowserActionInput(value) {
         moveActionField(output, "cookiePath", "path", issues);
         moveActionField(output, "cookieSecure", "secure", issues);
         moveActionField(output, "cookieHttpOnly", "httpOnly", issues);
+        moveActionField(output, "cookieSameSite", "sameSite", issues);
       } else if (rawAction === "storage") {
         moveActionField(output, "storageArea", "area", issues);
         moveActionField(output, "storageKey", "key", issues);
@@ -3373,6 +3461,21 @@ var TargetRequestSchema = TargetFormSchema.superRefine((input, context) => {
   }
 });
 var SelectorRequestSchema = z2.object({ selector: BoundedString(2e3), ...PageInput }).strict();
+var InspectElementTargetFieldsSchema = z2.object({
+  target: BoundedString(2e3).optional(),
+  ref: z2.string().trim().min(1).max(200).regex(/^(?:ref:)?e[1-9]\d*$/, "ref must be an element reference such as e5.").optional(),
+  selector: BoundedString(2e3).optional(),
+  index: z2.number().int().min(0).max(1e3).optional(),
+  maxDepth: z2.number().int().min(0).max(3).optional(),
+  maxChildren: z2.number().int().min(1).max(100).optional(),
+  ...PageInput
+}).strict();
+var InspectElementRequestSchema = InspectElementTargetFieldsSchema.superRefine((input, context) => {
+  const targetCount = [input.target, input.ref, input.selector, input.index].filter((value) => value !== void 0).length;
+  if (targetCount !== 1) {
+    context.addIssue({ code: "custom", message: "Provide exactly one of target, ref, selector, or index." });
+  }
+});
 var WaitRequestSchema = z2.object({ milliseconds: z2.number().int().min(0).max(12e4).default(500), ...PageInput }).strict();
 var WaitForTextRequestSchema = z2.object({ text: BoundedString(2e4), timeoutMs: z2.number().int().min(100).max(12e4).optional(), ...PageInput }).strict();
 var WaitForUrlRequestSchema = z2.object({ url: BoundedString(8e3), timeoutMs: z2.number().int().min(100).max(12e4).optional(), ...PageInput }).strict();
@@ -3420,7 +3523,16 @@ var ScreenshotRequestSchema = z2.object({ fullPage: z2.boolean().optional(), ful
   }
 });
 var PdfRequestSchema = z2.object({ outputPath: BoundedString(4e3), ...PageInput }).strict();
-var UploadRequestSchema = z2.object({ selector: BoundedString(2e3), filePath: BoundedString(4e3), ...PageInput }).strict();
+var UploadRequestSchema = z2.object({ selector: BoundedString(2e3), filePath: BoundedString(4e3).optional(), filePaths: z2.array(BoundedString(4e3)).min(1).max(20).optional(), ...PageInput }).strict().superRefine((input, context) => {
+  const hasFilePath = input.filePath !== void 0;
+  const hasFilePaths = input.filePaths !== void 0;
+  if (hasFilePath && hasFilePaths) {
+    context.addIssue({ code: "custom", message: "Provide filePath or filePaths, not both." });
+  }
+  if (!hasFilePath && !hasFilePaths) {
+    context.addIssue({ code: "custom", message: "Upload requires filePath or filePaths." });
+  }
+});
 var EvaluateRequestSchema = z2.object({
   code: z2.string().trim().min(1).max(4e4).optional(),
   expression: z2.string().trim().min(1).max(4e4).optional(),
@@ -3434,6 +3546,32 @@ var EvaluateRequestSchema = z2.object({
   }
 });
 var NetworkLogRequestSchema = z2.object({ operation: z2.enum(["enable", "disable", "read", "clear", "read_and_clear"]), ...PageInput }).strict();
+var NetworkSearchRequestSchema = z2.object({
+  query: BoundedString(4e3).optional(),
+  requestId: BoundedString(256).optional(),
+  url: BoundedString(8e3).optional(),
+  method: BoundedString(32).optional(),
+  status: z2.number().int().min(0).max(999).optional(),
+  resourceType: BoundedString(64).optional(),
+  offset: z2.number().int().min(0).max(1e6).optional(),
+  limit: z2.number().int().min(1).max(200).optional(),
+  pageId: BoundedString(200).optional()
+}).strict();
+var ResourceBlockingRequestSchema = z2.object({
+  operation: ResourceBlockingOperationSchema,
+  resourceTypes: z2.array(ResourceBlockingTypeSchema).min(1).max(RESOURCE_BLOCKING_TYPES.length).optional(),
+  ...PageInput
+}).strict().superRefine((input, context) => {
+  if (input.operation === "set") {
+    if (input.resourceTypes === void 0) {
+      context.addIssue({ code: "custom", message: "Resource blocking set requires resourceTypes." });
+    } else if (new Set(input.resourceTypes).size !== input.resourceTypes.length) {
+      context.addIssue({ code: "custom", message: "Resource blocking resourceTypes must be de-duplicated." });
+    }
+  } else if (input.resourceTypes !== void 0) {
+    context.addIssue({ code: "custom", message: `Resource blocking ${input.operation} does not accept resourceTypes.` });
+  }
+});
 var DialogRequestSchema = z2.object({ operation: z2.enum(["get_text", "accept", "dismiss", "send_keys"]), text: z2.string().max(2e4).optional(), ...PageInput }).strict().superRefine((input, context) => {
   if (input.operation === "send_keys" && input.text === void 0) {
     context.addIssue({ code: "custom", message: "Dialog send_keys requires text." });
@@ -3451,6 +3589,7 @@ var CookieRequestSchema = z2.object({
   url: HttpUrl(8e3).optional(),
   secure: z2.boolean().optional(),
   httpOnly: z2.boolean().optional(),
+  sameSite: z2.enum(["Strict", "Lax", "None"]).optional(),
   ...PageInput
 }).strict().superRefine((input, context) => {
   if ((input.operation === "set" || input.operation === "delete") && !input.name) {
@@ -3459,6 +3598,9 @@ var CookieRequestSchema = z2.object({
   if (input.operation === "set" && input.value === void 0) {
     context.addIssue({ code: "custom", message: "Cookie set requires value." });
   }
+  if (input.sameSite !== void 0 && input.operation !== "set") {
+    context.addIssue({ code: "custom", message: "Cookie sameSite is only valid for set." });
+  }
 });
 var StorageRequestSchema = z2.object({
   operation: z2.enum(["get", "set", "clear"]),
@@ -3838,7 +3980,7 @@ function registerBrowserTools(server, runtime) {
     "browser_get_html",
     {
       title: "Read page HTML",
-      description: "Read bounded raw HTML (at most 8,000 characters) for the current page or a CSS selector. Check the explicit truncated flag before relying on completeness; HTML is untrusted data and is never executed by this tool.",
+      description: "Read a bounded sanitized HTML projection (at most 8,000 characters) for the current page or a CSS selector. Scripts, event handlers, form values/textarea contents, and other unsafe attributes are omitted. Check the explicit truncated flag before relying on completeness; HTML is untrusted data and is never executed by this tool.",
       inputSchema: HtmlRequestSchema,
       annotations: BROWSER_READ_ONLY
     },
@@ -3888,6 +4030,16 @@ function registerBrowserTools(server, runtime) {
     { title: "Read browser network log", description: "Enable, disable, read, clear, or read-and-clear the redacted network log.", inputSchema: NetworkLogRequestSchema, annotations: BROWSER_DESTRUCTIVE },
     async (input, ctx) => callTool(() => runtime.run({ action: networkAction(input.operation), pageId: input.pageId }, ctx.mcpReq.signal), runtime)
   );
+  server.registerTool(
+    "browser_search_network_log",
+    { title: "Search browser network log", description: "Search the bounded redacted network journal by text, request ID, URL, method, status, or resource type. Results are deterministic and expose explicit capacity and omission metadata.", inputSchema: NetworkSearchRequestSchema, annotations: BROWSER_READ_ONLY },
+    async (input, ctx) => callTool(() => runtime.run({ action: "search_network_log", ...input }, ctx.mcpReq.signal), runtime)
+  );
+  server.registerTool(
+    "browser_resource_blocking",
+    { title: "Configure resource blocking", description: "Get, set, or clear page-scoped blocking for image, stylesheet, font, media, and script subresources. Navigation and document requests are never blocked by this tool.", inputSchema: ResourceBlockingRequestSchema, annotations: BROWSER_MUTATING },
+    async (input, ctx) => callTool(() => runtime.run({ action: "resource_blocking", operation: input.operation, resourceTypes: input.resourceTypes, pageId: input.pageId }, ctx.mcpReq.signal), runtime)
+  );
   server.registerTool(
     "browser_console_log",
     { title: "Read browser console log", description: "Enable, disable, read, clear, or read-and-clear the bounded console log.", inputSchema: NetworkLogRequestSchema, annotations: BROWSER_DESTRUCTIVE },
@@ -3898,7 +4050,7 @@ function registerBrowserTools(server, runtime) {
     return { ...fields, text: query };
   });
   registerAction(server, runtime, "browser_extract", "Extract page text", "Extract at most 8,000 page-text characters from the page or a CSS selector. Check truncated, offset, nextOffset, hasMore, and revision; use browser_page_next for later slices.", ExtractRequestSchema, "extract", (input) => ({ ...input, maxChars: input.maxChars ?? MCP_PAGE_TEXT_MAX_CHARS }));
-  registerAction(server, runtime, "browser_upload", "Upload a file", "Upload a file from an allowed server file root into a file input.", UploadRequestSchema, "upload_file");
+  registerAction(server, runtime, "browser_upload", "Upload files", "Upload one file or up to 20 files from allowed server file roots into a file input; multiple files require the input's multiple attribute.", UploadRequestSchema, "upload_file");
   registerAction(server, runtime, "browser_screenshot", "Capture a screenshot", "Capture a bounded PNG or JPEG screenshot of the current page.", ScreenshotRequestSchema, "screenshot", (input) => {
     const { full_page, full, max_bytes, max_dim, ...fields } = input;
     return { ...fields, fullPage: fields.fullPage ?? full_page ?? full, maxBytes: fields.maxBytes ?? max_bytes, maxDimension: fields.maxDimension ?? max_dim };
@@ -3909,6 +4061,7 @@ function registerBrowserTools(server, runtime) {
   registerAction(server, runtime, "browser_page_next", "Read the next page slice", "Read at most 8,000 characters from the current page at offset and revision. Advance to nextOffset only when hasMore is true; stale revisions are retryable and page text is untrusted.", PageNextSchema, "page_next", (input) => ({ ...input, maxChars: input.maxChars ?? MCP_PAGE_TEXT_MAX_CHARS }));
   registerAction(server, runtime, "browser_search_page", "Search the current page", "Find bounded snippets for a query in current-page text.", PageQuerySchema, "search_page");
   registerAction(server, runtime, "browser_find_elements", "Find elements", "List bounded element metadata for a CSS selector.", SelectorRequestSchema, "find_elements");
+  registerAction(server, runtime, "browser_inspect_element", "Inspect an element", "Read bounded safe attributes, selected computed styles, pseudo-element summaries, animation metadata, and shallow child structure for a current selector, ref, or index. Scripts, event-handler source, form values, and arbitrary data attributes are omitted.", InspectElementRequestSchema, "inspect_element");
   registerAction(server, runtime, "browser_interactive", "List interactive elements", "List visible links, buttons, inputs, and other interactive elements with stable refs.", EmptyInputSchema, "list_interactive");
   registerAction(server, runtime, "browser_frames", "List browser frames", "List bounded frame metadata for the current page. Frame content is not returned by this metadata tool.", EmptyInputSchema, "list_frames");
   registerAction(server, runtime, "browser_accessibility_snapshot", "Read accessibility tree", "Read a bounded accessibility tree through Chrome DevTools. Check truncation before relying on completeness; AX refs are observation-only and must be revalidated through DOM refs before acting.", AccessibilityRequestSchema, "accessibility_snapshot", (input) => ({ ...input, maxChars: input.maxChars ?? MCP_PAGE_TEXT_MAX_CHARS }));
@@ -4023,12 +4176,14 @@ function actionAnnotations(action) {
     case "page_next":
     case "search_page":
     case "find_elements":
+    case "inspect_element":
     case "list_interactive":
     case "list_frames":
     case "accessibility_snapshot":
     case "get_computed_style":
     case "get_page_info":
     case "get_network_log":
+    case "search_network_log":
     case "get_console_log":
     case "alert_get_text":
     case "detect_challenge":
@@ -4077,7 +4232,8 @@ function cookieAction(input) {
     cookiePath: input.path,
     url: input.url,
     cookieSecure: input.secure,
-    cookieHttpOnly: input.httpOnly
+    cookieHttpOnly: input.httpOnly,
+    cookieSameSite: input.sameSite
   };
 }
 function storageAction(input) {
@@ -4384,6 +4540,13 @@ function boundMcpOutput(value, options = {}) {
         if (typeof output.warning !== "string") {
           output.warning = "Some search results were omitted by the MCP output limit; use a narrower request or a paginated tool.";
         }
+      } else if (key === "entries") {
+        output.hasMore = true;
+        if (typeof output.returnedCount === "number" && Number.isFinite(output.returnedCount)) {
+          output.returnedCount = Math.min(Math.max(0, Math.trunc(output.returnedCount)), limit);
+        }
+        const previousOmittedCount = typeof output.omittedCount === "number" && Number.isSafeInteger(output.omittedCount) ? Math.max(0, output.omittedCount) : 0;
+        output.omittedCount = previousOmittedCount + omitted;
       }
       markOutputTruncated();
     }
@@ -5078,6 +5241,294 @@ function globMatches(value, glob) {
   return compiled.test(value);
 }
 
+// src/server/browser/network.ts
+var DEFAULT_CAPACITY = 500;
+var MAX_CAPACITY = 1e4;
+var DEFAULT_MAX_PAGES = 128;
+var MAX_MAX_PAGES = 1024;
+var DEFAULT_LIMIT = 50;
+var MAX_LIMIT = 200;
+var MAX_PAGE_ID_CHARS = 200;
+var MAX_REQUEST_ID_CHARS = 256;
+var MAX_METHOD_CHARS = 32;
+var MAX_RESOURCE_TYPE_CHARS = 64;
+var NetworkJournal = class {
+  capacity;
+  maxPages;
+  pages = /* @__PURE__ */ new Map();
+  generatedRequestSequence = 0;
+  evictedPageCount = 0;
+  constructor(options = {}) {
+    this.capacity = boundedPositiveInteger(options.capacity ?? DEFAULT_CAPACITY, MAX_CAPACITY, "capacity");
+    this.maxPages = boundedPositiveInteger(options.maxPages ?? DEFAULT_MAX_PAGES, MAX_MAX_PAGES, "maxPages");
+  }
+  /** Record or update request metadata and return an immutable snapshot. */
+  recordRequest(event) {
+    const pageId = normalizeRequiredIdentifier(event?.pageId, "pageId", MAX_PAGE_ID_CHARS);
+    const page = this.ensurePage(pageId);
+    const requestId = this.resolveRequestId(pageId, event?.requestId);
+    const existing = page.entries.get(requestId);
+    const timestamp = normalizeTimestamp(event?.timestamp);
+    const resourceType = normalizeOptionalText(event?.resourceType, MAX_RESOURCE_TYPE_CHARS) ?? existing?.entry.resourceType;
+    const entry = {
+      pageId,
+      requestId,
+      url: safeNetworkUrl(event?.url),
+      method: normalizeMethod(event?.method),
+      ...resourceType ? { resourceType } : {},
+      ...existing?.entry.status !== void 0 ? { status: existing.entry.status } : {},
+      requestTimestamp: existing?.entry.requestTimestamp ?? timestamp,
+      ...existing?.entry.responseTimestamp ? { responseTimestamp: existing.entry.responseTimestamp } : {}
+    };
+    page.entries.set(requestId, this.stored(entry));
+    this.enforcePageCapacity(page);
+    return cloneEntry(page.entries.get(requestId)?.entry ?? entry);
+  }
+  /** Record or update response metadata and correlate it to its request. */
+  recordResponse(event) {
+    const pageId = normalizeRequiredIdentifier(event?.pageId, "pageId", MAX_PAGE_ID_CHARS);
+    const page = this.ensurePage(pageId);
+    const requestId = normalizeRequiredIdentifier(event?.requestId, "requestId", MAX_REQUEST_ID_CHARS);
+    const existing = page.entries.get(requestId);
+    const timestamp = normalizeTimestamp(event?.timestamp);
+    const entry = existing ? {
+      ...existing.entry,
+      ...event.url !== void 0 ? { url: safeNetworkUrl(event.url) } : {},
+      ...event.resourceType !== void 0 ? { resourceType: normalizeOptionalText(event.resourceType, MAX_RESOURCE_TYPE_CHARS) } : {},
+      ...isValidStatus(event.status) ? { status: event.status } : {},
+      responseTimestamp: timestamp
+    } : {
+      pageId,
+      requestId,
+      url: event.url === void 0 ? "[URL_UNAVAILABLE]" : safeNetworkUrl(event.url),
+      method: "UNKNOWN",
+      ...normalizeOptionalText(event.resourceType, MAX_RESOURCE_TYPE_CHARS) ? { resourceType: normalizeOptionalText(event.resourceType, MAX_RESOURCE_TYPE_CHARS) } : {},
+      ...isValidStatus(event.status) ? { status: event.status } : {},
+      requestTimestamp: timestamp,
+      responseTimestamp: timestamp
+    };
+    page.entries.set(requestId, this.stored(entry));
+    this.enforcePageCapacity(page);
+    return cloneEntry(page.entries.get(requestId)?.entry ?? entry);
+  }
+  /** Query retained records using deterministic metadata filters and paging. */
+  query(query = {}) {
+    const normalized = normalizeQuery(query);
+    const selectedPages = normalized.pageId === void 0 ? [...this.pages.entries()] : [[normalized.pageId, this.pages.get(normalized.pageId)]];
+    const retainedCount = selectedPages.reduce((total, [, page]) => total + (page?.entries.size ?? 0), 0);
+    const evictedCount = selectedPages.reduce((total, [, page]) => total + (page?.evictedCount ?? 0), 0) + (normalized.pageId === void 0 ? this.evictedPageCount : 0);
+    const capacityReached = selectedPages.some(([, page]) => (page?.entries.size ?? 0) >= this.capacity || (page?.evictedCount ?? 0) > 0);
+    const matches = [];
+    for (const [, page] of selectedPages) {
+      if (!page) continue;
+      for (const stored of page.entries.values()) {
+        if (matchesFilter(stored.entry, normalized)) {
+          matches.push(stored.entry);
+        }
+      }
+    }
+    const entries = matches.slice(normalized.offset, normalized.offset + normalized.limit).map(cloneEntry);
+    return {
+      entries,
+      offset: normalized.offset,
+      limit: normalized.limit,
+      total: matches.length,
+      returnedCount: entries.length,
+      omittedCount: Math.max(0, matches.length - entries.length),
+      hasMore: normalized.offset + entries.length < matches.length,
+      retainedCount,
+      capacity: this.capacity,
+      evictedCount,
+      capacityReached
+    };
+  }
+  /** Search all safe metadata fields using one bounded case-insensitive scan. */
+  search(searchText, options = {}) {
+    const query = normalizeSearchText(searchText);
+    if (!query) {
+      throw new RangeError("searchText must be a non-empty string.");
+    }
+    const normalized = normalizeQuery(options);
+    const selectedPages = normalized.pageId === void 0 ? [...this.pages.entries()] : [[normalized.pageId, this.pages.get(normalized.pageId)]];
+    const matches = [];
+    for (const [, page] of selectedPages) {
+      if (!page) continue;
+      for (const stored of page.entries.values()) {
+        if (stored.searchText.includes(query) && matchesFilter(stored.entry, normalized)) {
+          matches.push(stored.entry);
+        }
+      }
+    }
+    return this.pageFromMatches(matches, normalized, selectedPages);
+  }
+  /** Remove all records, or only records associated with one page. */
+  clear(pageId) {
+    if (pageId === void 0) {
+      const clearedCount2 = [...this.pages.values()].reduce((total, page2) => total + page2.entries.size, 0);
+      this.pages.clear();
+      this.evictedPageCount = 0;
+      return { clearedCount: clearedCount2, retainedCount: 0 };
+    }
+    const normalizedPageId = normalizeRequiredIdentifier(pageId, "pageId", MAX_PAGE_ID_CHARS);
+    const page = this.pages.get(normalizedPageId);
+    const clearedCount = page?.entries.size ?? 0;
+    this.pages.delete(normalizedPageId);
+    return { clearedCount, retainedCount: this.retainedCount() };
+  }
+  /** Return bounded journal counts without exposing records. */
+  stats(pageId) {
+    const result = this.query(pageId === void 0 ? {} : { pageId, limit: 1 });
+    return {
+      retainedCount: result.retainedCount,
+      capacity: result.capacity,
+      evictedCount: result.evictedCount,
+      capacityReached: result.capacityReached
+    };
+  }
+  pageFromMatches(matches, query, selectedPages) {
+    const entries = matches.slice(query.offset, query.offset + query.limit).map(cloneEntry);
+    const retainedCount = selectedPages.reduce((total, [, page]) => total + (page?.entries.size ?? 0), 0);
+    const evictedCount = selectedPages.reduce((total, [, page]) => total + (page?.evictedCount ?? 0), 0) + (query.pageId === void 0 ? this.evictedPageCount : 0);
+    return {
+      entries,
+      offset: query.offset,
+      limit: query.limit,
+      total: matches.length,
+      returnedCount: entries.length,
+      omittedCount: Math.max(0, matches.length - entries.length),
+      hasMore: query.offset + entries.length < matches.length,
+      retainedCount,
+      capacity: this.capacity,
+      evictedCount,
+      capacityReached: selectedPages.some(([, page]) => (page?.entries.size ?? 0) >= this.capacity || (page?.evictedCount ?? 0) > 0)
+    };
+  }
+  ensurePage(pageId) {
+    const existing = this.pages.get(pageId);
+    if (existing) return existing;
+    while (this.pages.size >= this.maxPages) {
+      const oldestPageId = this.pages.keys().next().value;
+      if (oldestPageId === void 0) break;
+      const oldest = this.pages.get(oldestPageId);
+      this.evictedPageCount += oldest?.entries.size ?? 0;
+      this.pages.delete(oldestPageId);
+    }
+    const page = { entries: /* @__PURE__ */ new Map(), evictedCount: 0 };
+    this.pages.set(pageId, page);
+    return page;
+  }
+  resolveRequestId(pageId, rawRequestId) {
+    const normalized = normalizeOptionalIdentifier(rawRequestId, MAX_REQUEST_ID_CHARS);
+    if (normalized) return normalized;
+    this.generatedRequestSequence += 1;
+    return `${pageId}:request-${this.generatedRequestSequence}`.slice(0, MAX_REQUEST_ID_CHARS);
+  }
+  stored(entry) {
+    const searchParts = [entry.pageId, entry.requestId, entry.url, entry.method, entry.resourceType ?? "", entry.status === void 0 ? "" : String(entry.status)];
+    return { entry, searchText: searchParts.join(" ").toLocaleLowerCase("en-US") };
+  }
+  enforcePageCapacity(page) {
+    while (page.entries.size > this.capacity) {
+      const oldestRequestId = page.entries.keys().next().value;
+      if (oldestRequestId === void 0) break;
+      page.entries.delete(oldestRequestId);
+      page.evictedCount += 1;
+    }
+  }
+  retainedCount() {
+    return [...this.pages.values()].reduce((total, page) => total + page.entries.size, 0);
+  }
+};
+function normalizeQuery(query) {
+  if (query === null || typeof query !== "object") {
+    throw new TypeError("query must be an object.");
+  }
+  const offset = boundedNonnegativeInteger(query.offset ?? 0, "offset");
+  const limit = boundedPositiveInteger(query.limit ?? DEFAULT_LIMIT, MAX_LIMIT, "limit");
+  return {
+    ...query.pageId === void 0 ? {} : { pageId: normalizeRequiredIdentifier(query.pageId, "pageId", MAX_PAGE_ID_CHARS) },
+    ...query.requestId === void 0 ? {} : { requestId: normalizeOptionalText(query.requestId, MAX_REQUEST_ID_CHARS) },
+    ...query.url === void 0 ? {} : { url: normalizeSearchText(query.url) },
+    ...query.method === void 0 ? {} : { method: normalizeMethod(query.method) },
+    ...query.status === void 0 ? {} : { status: normalizeStatus(query.status) },
+    ...query.resourceType === void 0 ? {} : { resourceType: normalizeOptionalText(query.resourceType, MAX_RESOURCE_TYPE_CHARS) },
+    offset,
+    limit
+  };
+}
+function matchesFilter(entry, filter) {
+  if (filter.pageId !== void 0 && entry.pageId !== filter.pageId) return false;
+  if (filter.requestId !== void 0 && !entry.requestId.toLocaleLowerCase("en-US").includes(filter.requestId.toLocaleLowerCase("en-US"))) return false;
+  if (filter.url !== void 0 && !entry.url.toLocaleLowerCase("en-US").includes(filter.url.toLocaleLowerCase("en-US"))) return false;
+  if (filter.method !== void 0 && entry.method !== filter.method) return false;
+  if (filter.status !== void 0 && entry.status !== filter.status) return false;
+  if (filter.resourceType !== void 0 && entry.resourceType?.toLocaleLowerCase("en-US") !== filter.resourceType.toLocaleLowerCase("en-US")) return false;
+  return true;
+}
+function cloneEntry(entry) {
+  return { ...entry };
+}
+function safeNetworkUrl(rawUrl) {
+  if (typeof rawUrl !== "string" || !rawUrl.trim()) return "[URL_UNAVAILABLE]";
+  const trimmed = rawUrl.trim();
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    return "[INVALID_URL]";
+  }
+  if (!["http:", "https:", "ws:", "wss:"].includes(parsed.protocol)) {
+    return "[NON_HTTP_URL]";
+  }
+  return redactSecretPlaceholders(sanitizeUrl(trimmed));
+}
+function normalizeRequiredIdentifier(value, name, maxChars) {
+  const normalized = normalizeOptionalIdentifier(value, maxChars);
+  if (!normalized) throw new TypeError(`${name} must be a non-empty string or number.`);
+  return normalized;
+}
+function normalizeOptionalIdentifier(value, maxChars) {
+  if (typeof value !== "string" && typeof value !== "number") return void 0;
+  if (typeof value === "number" && !Number.isSafeInteger(value)) return void 0;
+  return normalizeOptionalText(String(value), maxChars);
+}
+function normalizeOptionalText(value, maxChars) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.normalize("NFKC").replace(/[\u0000-\u001f\u007f\u200b-\u200d\u2060\ufeff]/g, "").trim();
+  return normalized ? normalized.slice(0, maxChars) : void 0;
+}
+function normalizeMethod(value) {
+  return (normalizeOptionalText(value, MAX_METHOD_CHARS) ?? "UNKNOWN").toUpperCase();
+}
+function normalizeSearchText(value) {
+  const normalized = normalizeOptionalText(value, 512);
+  if (!normalized) throw new TypeError("search and filter values must be non-empty strings.");
+  return normalized.toLocaleLowerCase("en-US");
+}
+function normalizeTimestamp(value) {
+  const date = value instanceof Date ? value : typeof value === "number" && Number.isFinite(value) ? new Date(value) : typeof value === "string" && value.trim() ? new Date(value) : /* @__PURE__ */ new Date();
+  return Number.isNaN(date.getTime()) ? (/* @__PURE__ */ new Date()).toISOString() : date.toISOString();
+}
+function isValidStatus(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= 999;
+}
+function normalizeStatus(value) {
+  if (!isValidStatus(value)) throw new TypeError("status must be an integer between 0 and 999.");
+  return value;
+}
+function boundedPositiveInteger(value, maximum, name) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1 || value > maximum) {
+    throw new RangeError(`${name} must be an integer between 1 and ${maximum}.`);
+  }
+  return value;
+}
+function boundedNonnegativeInteger(value, name) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new RangeError(`${name} must be a non-negative integer.`);
+  }
+  return value;
+}
+
 // src/server/browser/service.ts
 var puppeteerModulePromise;
 function loadPuppeteer() {
@@ -5092,6 +5543,52 @@ var POPUP_POST_CLICK_SETTLE_TIMEOUT_MS = 300;
 var MAX_DOM_TRAVERSAL_NODES = 2e4;
 var MAX_TEXT_SCAN_CHARS = 5e5;
 var MAX_MARKUP_EVIDENCE_CHARS = 12e4;
+var MAX_INSPECT_NODES = 512;
+var MAX_INSPECT_STRING_CHARS = 500;
+var SAFE_ELEMENT_ATTRIBUTE_NAMES = [
+  "id",
+  "class",
+  "role",
+  "type",
+  "name",
+  "placeholder",
+  "title",
+  "tabindex",
+  "style",
+  "fill",
+  "stroke",
+  "x",
+  "y",
+  "x1",
+  "x2",
+  "y1",
+  "y2",
+  "r",
+  "cx",
+  "cy",
+  "width",
+  "height",
+  "points",
+  "transform",
+  "font-size"
+];
+var SAFE_ELEMENT_DATA_ATTRIBUTE_NAMES = [
+  "data-color",
+  "data-index",
+  "data-sides",
+  "data-result",
+  "data-key",
+  "data-type",
+  "data-item",
+  "data-id",
+  "data-start",
+  "data-end",
+  "data-duration",
+  "data-output",
+  "data-value",
+  "data-position",
+  "data-price"
+];
 var CHALLENGE_AI_GUIDANCE = "Use normal browser click, input, scroll, or key tools on the visible challenge controls, then call solve_challenge again to verify that the challenge is cleared.";
 var CHALLENGE_DEFAULT_MAX_ATTEMPTS = 32;
 var CHALLENGE_MAX_ATTEMPTS = 100;
@@ -5104,6 +5601,11 @@ var NAVIGATION_CLICK_SETTLE_TIMEOUT_MS = 50;
 var NAVIGATION_CLICK_EVENT_TIMEOUT_MS = 250;
 var NAVIGATION_CLICK_READY_TIMEOUT_MS = 250;
 var SHUTDOWN_CONNECTION_SETTLE_TIMEOUT_MS = 1e3;
+var MIN_IDLE_SWEEP_INTERVAL_MS = 250;
+var MAX_IDLE_SWEEP_INTERVAL_MS = 6e4;
+var MAX_DEVTOOLS_PROBE_RESPONSE_BYTES = 64 * 1024;
+var MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
+var MAX_UPLOAD_TOTAL_BYTES = 100 * 1024 * 1024;
 var COMMON_KEY_ALIASES = {
   ALT: "Alt",
   ARROWDOWN: "ArrowDown",
@@ -5190,13 +5692,15 @@ var PARALLEL_READ_ACTIONS = /* @__PURE__ */ new Set([
   "page_next",
   "search_page",
   "find_elements",
+  "inspect_element",
   "list_frames",
   "accessibility_snapshot",
   "get_computed_style",
   "get_page_info",
   "get_cookies",
   "get_storage",
-  "list_downloads"
+  "list_downloads",
+  "search_network_log"
 ]);
 var BrowserService = class {
   constructor(config, policy, logger, dependencies = {}) {
@@ -5204,6 +5708,7 @@ var BrowserService = class {
     this.policy = policy;
     this.logger = logger;
     this.dependencies = dependencies;
+    this.startIdleSweep();
   }
   config;
   policy;
@@ -5234,6 +5739,7 @@ var BrowserService = class {
   currentPageId;
   sessionGeneration = 0;
   states = /* @__PURE__ */ new Map();
+  networkJournal = new NetworkJournal();
   configuredDownloadContexts = /* @__PURE__ */ new WeakSet();
   // The download directory is process/session scoped, while page setup is
   // page scoped. Share the mkdir promise across pages so opening a tab does
@@ -5241,9 +5747,11 @@ var BrowserService = class {
   // so a later page can retry after a transient filesystem failure.
   downloadDirectoryPromise;
   ids = /* @__PURE__ */ new WeakMap();
+  networkRequestIds = /* @__PURE__ */ new WeakMap();
   targetGuardSessions = /* @__PURE__ */ new Map();
   targetGuardNavigationErrors = /* @__PURE__ */ new Map();
   unguardedTargetSessions = /* @__PURE__ */ new Set();
+  handledTargetGuardSessions = /* @__PURE__ */ new Set();
   pendingTargetGuardSessions = /* @__PURE__ */ new Map();
   pendingTargetGuardInfos = /* @__PURE__ */ new Map();
   targetGuardUnavailable = false;
@@ -5251,11 +5759,134 @@ var BrowserService = class {
   targetGuardConnectionListener;
   targetGuardRawConnectionListener;
   targetGuardDetachedListener;
+  targetGuardReadinessPromise;
   targetGuardOriginalEmit;
   targetGuardWrappedEmit;
   operationTail = Promise.resolve();
   queuedOperations = 0;
   benchmarkCounters = process.env.SMOOTH_OPERATOR_BENCHMARK_COUNTERS === "true" ? { browserOperations: 0, pageLookups: 0, pageEnumerations: 0, pageEvaluations: 0, cdpCommands: 0 } : void 0;
+  idleSweepTimer;
+  idleSweepPromise;
+  idleSweepStopped = false;
+  pendingTargetPreparations = /* @__PURE__ */ new Set();
+  startIdleSweep() {
+    const idleTimeoutMs = this.config.browser.idleTimeoutMs;
+    if (this.config.browser.mode === "disabled" || idleTimeoutMs <= 0) {
+      return;
+    }
+    const intervalMs = Math.min(
+      MAX_IDLE_SWEEP_INTERVAL_MS,
+      Math.max(MIN_IDLE_SWEEP_INTERVAL_MS, Math.floor(idleTimeoutMs / 2))
+    );
+    const timer = setInterval(() => this.scheduleIdleSweep(), intervalMs);
+    timer.unref?.();
+    this.idleSweepTimer = timer;
+  }
+  stopIdleSweep() {
+    this.idleSweepStopped = true;
+    if (this.idleSweepTimer) {
+      clearInterval(this.idleSweepTimer);
+      this.idleSweepTimer = void 0;
+    }
+  }
+  scheduleIdleSweep() {
+    if (this.idleSweepStopped || this.idleSweepPromise || !this.browser || this.browser.connected === false) {
+      return;
+    }
+    if (this.queuedOperations > 0 || this.activeOperationControllers.size > 0) {
+      return;
+    }
+    if (this.connectionPromise || this.connectionSettlementPromise || this.browserClosePromise || this.interruptedBrowserShutdown || this.recoveryPromise || this.failedBrowserShutdown || this.browserShutdownFailure || this.pendingTargetPreparations.size > 0) {
+      return;
+    }
+    const observedActivityAt = this.lastActivityAt;
+    const intervalMs = this.idleSweepIntervalMs();
+    const sweep = this.withOperationLock(
+      void 0,
+      (signal) => this.sweepIdleBrowser(observedActivityAt, signal),
+      intervalMs,
+      intervalMs,
+      "exclusive",
+      false
+    );
+    this.idleSweepPromise = sweep;
+    void sweep.then(
+      () => {
+        if (this.idleSweepPromise === sweep) {
+          this.idleSweepPromise = void 0;
+        }
+      },
+      (error) => {
+        if (this.idleSweepPromise === sweep) {
+          this.idleSweepPromise = void 0;
+        }
+        this.logger.debug("Idle browser sweep did not complete", { error: safeErrorDiagnostic(error) });
+      }
+    );
+  }
+  idleSweepIntervalMs() {
+    const idleTimeoutMs = this.config.browser.idleTimeoutMs;
+    return Math.min(
+      MAX_IDLE_SWEEP_INTERVAL_MS,
+      Math.max(MIN_IDLE_SWEEP_INTERVAL_MS, Math.floor(idleTimeoutMs / 2))
+    );
+  }
+  async sweepIdleBrowser(observedActivityAt, signal) {
+    throwIfAborted(signal);
+    if (this.idleSweepStopped || this.shuttingDown || this.config.browser.idleTimeoutMs <= 0) {
+      return;
+    }
+    const browser = this.browser;
+    if (!browser || browser.connected === false) {
+      return;
+    }
+    if (this.queuedOperations !== 1 || this.activeOperationControllers.size !== 1) {
+      return;
+    }
+    if (this.connectionPromise || this.connectionSettlementPromise || this.browserClosePromise || this.interruptedBrowserShutdown || this.recoveryPromise || this.failedBrowserShutdown || this.browserShutdownFailure || this.pendingTargetPreparations.size > 0) {
+      return;
+    }
+    if ([...this.states.values()].some((state) => !state.disposed && state.dialogs.length > 0)) {
+      return;
+    }
+    if (typeof browser.pages === "function") {
+      const pagesResult = await this.enumerateIdlePages(browser);
+      if (!pagesResult) {
+        return;
+      }
+      const livePages = pagesResult.filter((page) => !isPageClosed(page));
+      for (const page of livePages) {
+        const state = [...this.states.values()].find((candidate) => candidate.page === page);
+        if (!state || state.disposed || state.lifecycleGeneration !== this.lifecycleGeneration || state.configurationPromise || !state.navigationGuardInstalled) {
+          return;
+        }
+        if (state.dialogs.length > 0) {
+          return;
+        }
+      }
+    }
+    if (this.queuedOperations !== 1 || this.activeOperationControllers.size !== 1 || this.pendingTargetPreparations.size > 0) {
+      return;
+    }
+    if (this.lastActivityAt !== observedActivityAt || Date.now() - this.lastActivityAt < this.config.browser.idleTimeoutMs) {
+      return;
+    }
+    await this.closeBrowser();
+  }
+  async enumerateIdlePages(browser) {
+    const pagesPromise = Promise.resolve().then(() => browser.pages());
+    const result = await settleWithTimeout(
+      pagesPromise.then(
+        (pages) => ({ pages }),
+        (error) => ({ error })
+      ),
+      Math.min(this.idleSweepIntervalMs(), SHUTDOWN_CONNECTION_SETTLE_TIMEOUT_MS)
+    );
+    if (!result || "error" in result || !Array.isArray(result.pages)) {
+      return void 0;
+    }
+    return result.pages;
+  }
   async close() {
     if (this.closePromise) {
       return this.closePromise;
@@ -5276,6 +5907,7 @@ var BrowserService = class {
     if (this.shuttingDown) {
       return { closed: false, owned: false, succeeded: true };
     }
+    this.stopIdleSweep();
     this.shuttingDown = true;
     this.lifecycleGeneration += 1;
     this.shutdownController.abort();
@@ -5286,6 +5918,7 @@ var BrowserService = class {
     const lateConnectionSettled = await settlesWithinTimeout(this.connectionSettlementPromise, SHUTDOWN_CONNECTION_SETTLE_TIMEOUT_MS);
     const interruptedShutdown = this.interruptedBrowserShutdown;
     const interruptedSucceeded = interruptedShutdown ? await settleWithTimeout(interruptedShutdown, SHUTDOWN_CONNECTION_SETTLE_TIMEOUT_MS).catch(() => void 0) === true : true;
+    await settleWithTimeout(this.idleSweepPromise, SHUTDOWN_CONNECTION_SETTLE_TIMEOUT_MS).catch(() => void 0);
     const browserResult = await this.closeBrowser();
     return { ...browserResult, succeeded: browserResult.succeeded && connectionSettled && lateConnectionSettled && interruptedSucceeded };
   }
@@ -5297,21 +5930,25 @@ var BrowserService = class {
       queuedOperations: this.queuedOperations,
       currentPageId: this.currentPageId ?? null,
       recoveryRequired: this.recoveryRequired,
+      idleTimeoutMs: this.config.browser.idleTimeoutMs,
       ...this.benchmarkCounters ? { benchmarkCounters: { ...this.benchmarkCounters } } : {}
     };
   }
   sessionSummary() {
     const status = this.connectionStatus();
-    return { session_id: this.sessionId, active: status.connected, owned: status.owned, trackedPages: status.trackedPages, queuedOperations: status.queuedOperations, currentPageId: status.currentPageId, recoveryRequired: this.recoveryRequired, lastActivityAt: new Date(this.lastActivityAt).toISOString() };
+    return { session_id: this.sessionId, active: status.connected, owned: status.owned, trackedPages: status.trackedPages, queuedOperations: status.queuedOperations, currentPageId: status.currentPageId, recoveryRequired: this.recoveryRequired, idleTimeoutMs: this.config.browser.idleTimeoutMs, lastActivityAt: new Date(this.lastActivityAt).toISOString() };
   }
   async doctor() {
     const discovered = this.config.browser.executablePath ? void 0 : findChromeExecutable();
-    const executablePath = this.config.browser.executablePath ?? discovered?.path;
+    const configuredExecutablePath = this.config.browser.executablePath;
+    const executablePath = configuredExecutablePath ?? discovered?.path;
+    const executable = configuredExecutablePath ? { source: "configured", ready: isExecutableReady(configuredExecutablePath) } : discovered ? { source: "discovered", ready: isExecutableReady(discovered.path), label: discovered.label, channel: discovered.channel } : { source: "missing", ready: false };
     const endpoint = await this.probeManagedEndpoint();
     const browser = endpoint.version?.Browser;
     return {
       mode: this.config.browser.mode,
       executablePath: executablePath ?? null,
+      executable,
       ...executablePath ? {} : { searchedPaths: chromeExecutableSearchPaths().slice(0, 128) },
       userDataDir: this.config.browser.userDataDir ?? null,
       endpoint: {
@@ -5400,18 +6037,7 @@ var BrowserService = class {
       this.recoveryRequired = !succeeded2;
       return { closed: false, owned: false, succeeded: succeeded2 };
     }
-    let succeeded = true;
-    if (owned) {
-      await Promise.resolve().then(() => browser.close()).catch((error) => {
-        succeeded = false;
-        this.logger.warn("Browser close failed", { error: String(error) });
-      });
-    } else {
-      await Promise.resolve().then(() => browser.disconnect()).catch((error) => {
-        succeeded = false;
-        this.logger.warn("Browser disconnect failed", { error: String(error) });
-      });
-    }
+    const succeeded = await closeConnectedBrowser(browser, owned, this.logger);
     if (!succeeded) {
       this.browserShutdownFailure = true;
       this.failedBrowserShutdown = { browser, owned };
@@ -6349,12 +6975,56 @@ var BrowserService = class {
         return { enabled: false };
       case "get_network_log":
         return { entries: untrustedLogEntries(state.network.slice(-MAX_LOG_ENTRIES)) };
+      case "search_network_log": {
+        const result = action.query ? this.networkJournal.search(action.query, {
+          pageId: state.id,
+          requestId: action.requestId,
+          url: action.url,
+          method: action.method,
+          status: action.status,
+          resourceType: action.resourceType,
+          offset: action.offset,
+          limit: action.limit
+        }) : this.networkJournal.query({
+          pageId: state.id,
+          requestId: action.requestId,
+          url: action.url,
+          method: action.method,
+          status: action.status,
+          resourceType: action.resourceType,
+          offset: action.offset,
+          limit: action.limit
+        });
+        return {
+          ...result,
+          entries: result.entries.map((entry) => ({
+            ...entry,
+            url: wrapUntrustedText("network_log_url", redactSecretPlaceholders(entry.url), 4096)
+          }))
+        };
+      }
+      case "resource_blocking": {
+        const operation = requireField(action.operation, "operation");
+        if (operation === "set") {
+          const resourceTypes2 = action.resourceTypes ?? [];
+          if (resourceTypes2.length === 0 || new Set(resourceTypes2).size !== resourceTypes2.length || resourceTypes2.some((resourceType) => !RESOURCE_BLOCKING_TYPES.includes(resourceType))) {
+            throw new AppError("INVALID_ACTION", "Resource blocking set requires a non-empty de-duplicated list of supported resourceTypes.");
+          }
+          state.blockedResourceTypes = new Set(resourceTypes2);
+        } else if (operation === "clear") {
+          state.blockedResourceTypes.clear();
+        }
+        const resourceTypes = RESOURCE_BLOCKING_TYPES.filter((resourceType) => state.blockedResourceTypes.has(resourceType));
+        return { pageId: state.id, operation, resourceTypes };
+      }
       case "clear_network_log":
         state.network = [];
+        this.networkJournal.clear(state.id);
         return { cleared: true };
       case "getclear_network_log": {
         const entries = untrustedLogEntries(state.network.slice(-MAX_LOG_ENTRIES));
         state.network = [];
+        this.networkJournal.clear(state.id);
         return { entries, cleared: true };
       }
       case "enable_console_log":
@@ -6911,27 +7581,53 @@ var BrowserService = class {
       case "upload_file": {
         throwIfAborted(signal);
         const selector = await this.selectorFor(state, targetForAction(action, "selector"), action.frameId);
-        throwIfAborted(signal);
-        const staged = await this.stageUploadFile(requireField(action.filePath, "filePath"), signal);
-        throwIfAborted(signal);
-        let input;
+        const stagedFiles = [];
+        let input = null;
         try {
+          if (action.filePath !== void 0 && action.filePaths !== void 0) {
+            throw new AppError("INVALID_ACTION", "Provide filePath or filePaths, not both.");
+          }
+          const rawPaths = action.filePaths ?? (action.filePath !== void 0 ? [action.filePath] : []);
+          if (rawPaths.length === 0 || rawPaths.length > 20) {
+            throw new AppError("INVALID_ACTION", "Upload requires one to 20 paths in filePath or filePaths.");
+          }
+          let totalBytes = 0;
+          for (const rawPath of rawPaths) {
+            throwIfAborted(signal);
+            const staged = await this.stageUploadFile(rawPath, signal);
+            stagedFiles.push(staged);
+            totalBytes += staged.size;
+            if (totalBytes > MAX_UPLOAD_TOTAL_BYTES) {
+              throw new AppError("FILE_TOO_LARGE", "The combined upload sources exceed the 100 MiB size limit.");
+            }
+          }
+          throwIfAborted(signal);
           input = await frame.$(selector);
-        } catch (error) {
-          await unlinkIfPresent(staged.path);
-          throw error;
-        }
-        if (!input) {
-          await unlinkIfPresent(staged.path);
-          throw new AppError("ELEMENT_NOT_FOUND", `No element matched '${selector}'.`);
-        }
-        try {
-          await input.uploadFile(staged.path);
+          if (!input) {
+            throw new AppError("ELEMENT_NOT_FOUND", `No element matched '${selector}'.`);
+          }
+          if (stagedFiles.length > 1) {
+            const supportsMultiple = typeof input.evaluate === "function" && await input.evaluate((element) => element instanceof HTMLInputElement && element.type === "file" && element.multiple);
+            if (!supportsMultiple) {
+              throw new AppError("MULTIPLE_FILES_UNSUPPORTED", "Multiple uploads require a file input with the multiple attribute.");
+            }
+          }
+          await input.uploadFile(...stagedFiles.map((staged) => staged.path));
           throwIfAborted(signal);
-          return { uploaded: wrapUntrustedText("uploaded_file_name", redactSecretPlaceholders(basename2(staged.displayName)), 512), bytes: Math.min(staged.size, Number.MAX_SAFE_INTEGER) };
+          const names = stagedFiles.map((staged) => wrapUntrustedText("uploaded_file_name", redactSecretPlaceholders(basename2(staged.displayName)), 512));
+          const bytes = Math.min(totalBytes, Number.MAX_SAFE_INTEGER);
+          if (names.length === 1) {
+            return { uploaded: names[0], bytes };
+          }
+          return { uploaded: names, files: names, count: names.length, bytes };
         } finally {
-          await input.dispose().catch(() => void 0);
-          await unlinkIfPresent(staged.path);
+          try {
+            await input?.dispose();
+          } catch {
+          }
+          for (const staged of stagedFiles) {
+            await unlinkIfPresent(staged.path).catch(() => void 0);
+          }
         }
       }
       case "screenshot": {
@@ -7127,8 +7823,282 @@ var BrowserService = class {
         }, query, { maxNodes: MAX_DOM_TRAVERSAL_NODES, maxChars: MAX_TEXT_SCAN_CHARS });
         return { query, matches: matches.matches.map((match) => wrapUntrustedText("page_match", redactSecretPlaceholders(match), 500)), totalMatches: matches.totalMatches, matchesTruncated: matches.totalMatches > matches.matches.length || matches.scanTruncated };
       }
+      case "inspect_element": {
+        const selector = await this.selectorFor(state, targetForAction(action, "target"), action.frameId, frame);
+        const maxDepth = Number.isSafeInteger(action.maxDepth) ? Math.max(0, Math.min(3, action.maxDepth)) : 1;
+        const maxChildren = Number.isSafeInteger(action.maxChildren) ? Math.max(1, Math.min(100, action.maxChildren)) : 20;
+        const inspected = await frame.$eval(selector, (element, options) => {
+          const excludedTags = /* @__PURE__ */ new Set(["script", "style", "template", "noscript"]);
+          const safeAttributes = new Set(options.safeAttributeNames);
+          const safeDataAttributes = new Set(options.safeDataAttributeNames);
+          const styleNames = [
+            "display",
+            "visibility",
+            "position",
+            "color",
+            "backgroundColor",
+            "width",
+            "height",
+            "zIndex",
+            "fontFamily",
+            "fontSize",
+            "fontWeight",
+            "lineHeight",
+            "opacity",
+            "transform"
+          ];
+          const animationNames = [
+            "animationName",
+            "animationDuration",
+            "animationTimingFunction",
+            "animationDelay",
+            "animationIterationCount",
+            "animationDirection",
+            "animationFillMode",
+            "animationPlayState",
+            "transitionProperty",
+            "transitionDuration",
+            "transitionTimingFunction",
+            "transitionDelay",
+            "transform"
+          ];
+          let visitedNodes = 0;
+          const boundedString = (value, limit = options.maxStringChars) => typeof value === "string" ? value.slice(0, limit) : "";
+          const boundedRect = (target) => {
+            const rect = target.getBoundingClientRect();
+            const bound = (value, minimum = -1e7) => Number.isFinite(value) ? Math.max(minimum, Math.min(1e7, Math.round(value))) : 0;
+            return { x: bound(rect.x), y: bound(rect.y), width: bound(rect.width, 0), height: bound(rect.height, 0) };
+          };
+          const collectAttributes = (target) => {
+            const attributes = {};
+            let omittedAttributes = 0;
+            const attributeCount = target.attributes.length;
+            const inspectedAttributes = Math.min(attributeCount, 40);
+            for (let index = 0; index < inspectedAttributes; index += 1) {
+              const attribute = target.attributes[index];
+              if (!attribute) continue;
+              const name = attribute.name.toLowerCase();
+              const allowed = safeAttributes.has(name) || safeDataAttributes.has(name) || /^aria-[a-z0-9_-]+$/i.test(name);
+              if (!allowed) {
+                omittedAttributes += 1;
+                continue;
+              }
+              const value = boundedString(attribute.value, 200);
+              attributes[name.slice(0, 100)] = value;
+              if (value.length < attribute.value.length) omittedAttributes += 1;
+            }
+            omittedAttributes += Math.max(0, attributeCount - inspectedAttributes);
+            return { attributes, omittedAttributes };
+          };
+          const readSafeText = (target) => {
+            const tag = target.tagName.toLowerCase();
+            if (["input", "textarea", "select", "option"].includes(tag)) {
+              return { text: "", truncated: false };
+            }
+            const stack = [target];
+            let text = "";
+            let truncated = false;
+            let visited = 0;
+            while (stack.length > 0) {
+              const node = stack.pop();
+              if (!node) break;
+              visited += 1;
+              if (visited > options.maxNodes) {
+                truncated = true;
+                break;
+              }
+              if (node.nodeType === 3) {
+                const raw = node.nodeValue ?? "";
+                const remaining = options.maxStringChars - text.length;
+                if (remaining <= 0) {
+                  truncated = true;
+                  break;
+                }
+                text += raw.slice(0, remaining);
+                if (raw.length > remaining) truncated = true;
+                continue;
+              }
+              if (node.nodeType !== 1) continue;
+              const childElement = node;
+              if (excludedTags.has(childElement.tagName.toLowerCase())) continue;
+              const children = childElement.childNodes;
+              for (let index = children.length - 1; index >= 0; index -= 1) {
+                const child = children[index];
+                if (child) stack.push(child);
+              }
+            }
+            return { text: text.replace(/\s+/g, " ").trim().slice(0, options.maxStringChars), truncated };
+          };
+          const readStyle = (target, pseudo = "") => {
+            let style;
+            try {
+              style = getComputedStyle(target, pseudo);
+            } catch {
+              return {};
+            }
+            const output = {};
+            for (const name of styleNames) {
+              output[name] = boundedString(style[name]);
+            }
+            return output;
+          };
+          const readPseudo = (target, pseudo) => {
+            let style;
+            try {
+              style = getComputedStyle(target, pseudo);
+            } catch {
+              return { content: "", styles: {} };
+            }
+            const styles = {};
+            for (const name of styleNames) {
+              styles[name] = boundedString(style[name]);
+            }
+            return { content: boundedString(style.content), styles };
+          };
+          const readAnimations = (target) => {
+            let style;
+            try {
+              style = getComputedStyle(target);
+            } catch {
+              return {};
+            }
+            const output = {};
+            for (const name of animationNames) {
+              output[name] = boundedString(style[name]);
+            }
+            return output;
+          };
+          const collectChildren = (parent, depth) => {
+            const children = [];
+            let childrenTruncated = false;
+            let omittedChildren = 0;
+            const childElements = Array.from(parent.children);
+            if (depth >= options.maxDepth) {
+              return {
+                children,
+                childrenTruncated: childElements.length > 0,
+                omittedChildren: childElements.length
+              };
+            }
+            for (let index = 0; index < childElements.length; index += 1) {
+              const child = childElements[index];
+              if (!child) continue;
+              if (excludedTags.has(child.tagName.toLowerCase())) {
+                omittedChildren += 1;
+                continue;
+              }
+              if (children.length >= options.maxChildren) {
+                childrenTruncated = true;
+                omittedChildren += childElements.length - index;
+                break;
+              }
+              if (visitedNodes >= options.maxNodes) {
+                childrenTruncated = true;
+                omittedChildren += childElements.length - index;
+                break;
+              }
+              visitedNodes += 1;
+              const childAttributes = collectAttributes(child);
+              const childText = readSafeText(child);
+              const nested = collectChildren(child, depth + 1);
+              children.push({
+                tag: child.tagName.toLowerCase(),
+                rect: boundedRect(child),
+                text: childText.text,
+                textTruncated: childText.truncated,
+                attributes: childAttributes.attributes,
+                omittedAttributes: childAttributes.omittedAttributes,
+                children: nested.children,
+                childrenTruncated: nested.childrenTruncated,
+                omittedChildren: nested.omittedChildren
+              });
+              if (nested.childrenTruncated) childrenTruncated = true;
+              omittedChildren += nested.omittedChildren;
+            }
+            return { children, childrenTruncated, omittedChildren };
+          };
+          const rootAttributes = collectAttributes(element);
+          const rootText = readSafeText(element);
+          const childResult = collectChildren(element, 0);
+          const contentOmitted = excludedTags.has(element.tagName.toLowerCase());
+          return {
+            tag: element.tagName.toLowerCase(),
+            rect: boundedRect(element),
+            text: rootText.text,
+            textTruncated: rootText.truncated,
+            attributes: rootAttributes.attributes,
+            omittedAttributes: rootAttributes.omittedAttributes,
+            computedStyles: readStyle(element),
+            pseudoElements: {
+              before: readPseudo(element, "::before"),
+              after: readPseudo(element, "::after")
+            },
+            animations: readAnimations(element),
+            children: childResult.children,
+            childrenTruncated: childResult.childrenTruncated,
+            omittedChildren: childResult.omittedChildren,
+            contentOmitted,
+            omittedContent: contentOmitted ? 1 : 0,
+            truncated: contentOmitted || rootText.truncated || rootAttributes.omittedAttributes > 0 || childResult.childrenTruncated || childResult.omittedChildren > 0
+          };
+        }, {
+          maxDepth,
+          maxChildren,
+          maxNodes: MAX_INSPECT_NODES,
+          maxStringChars: MAX_INSPECT_STRING_CHARS,
+          safeAttributeNames: [...SAFE_ELEMENT_ATTRIBUTE_NAMES],
+          safeDataAttributeNames: [...SAFE_ELEMENT_DATA_ATTRIBUTE_NAMES]
+        });
+        const wrap = (value, kind, max = MAX_INSPECT_STRING_CHARS) => wrapUntrustedText(kind, redactSecretPlaceholders(value), max);
+        const wrapAttributes = (attributes) => Object.fromEntries(
+          // Attribute names are restricted to the fixed allowlist or the
+          // bounded aria-* grammar in the page callback. Keep those names as
+          // keys for ergonomic parity with find_elements; values are still
+          // untrusted and wrapped below.
+          Object.entries(attributes).map(([name, value]) => [name, wrap(value, "inspect_attribute", 200)])
+        );
+        const wrapChild = (child) => ({
+          tag: wrap(child.tag, "inspect_child_tag", 100),
+          rect: child.rect,
+          text: wrap(child.text, "inspect_child_text"),
+          textTruncated: child.textTruncated,
+          attributes: wrapAttributes(child.attributes),
+          omittedAttributes: child.omittedAttributes,
+          children: child.children.map(wrapChild),
+          childrenTruncated: child.childrenTruncated,
+          omittedChildren: child.omittedChildren
+        });
+        const wrapStyleMap = (styles) => Object.fromEntries(
+          Object.entries(styles).map(([name, value]) => [name, wrap(value, "inspect_style")])
+        );
+        const wrapPseudo = (pseudo) => ({
+          content: wrap(pseudo.content, "inspect_pseudo_content"),
+          styles: wrapStyleMap(pseudo.styles)
+        });
+        return {
+          tag: wrap(inspected.tag, "inspect_tag", 100),
+          selector: wrap(selector, "inspect_selector"),
+          rect: inspected.rect,
+          text: wrap(inspected.text, "inspect_text"),
+          textTruncated: inspected.textTruncated,
+          attributes: wrapAttributes(inspected.attributes),
+          omittedAttributes: inspected.omittedAttributes,
+          computedStyles: wrapStyleMap(inspected.computedStyles),
+          pseudoElements: {
+            before: wrapPseudo(inspected.pseudoElements.before),
+            after: wrapPseudo(inspected.pseudoElements.after)
+          },
+          animations: wrapStyleMap(inspected.animations),
+          children: inspected.children.map(wrapChild),
+          childrenTruncated: inspected.childrenTruncated,
+          omittedChildren: inspected.omittedChildren,
+          contentOmitted: inspected.contentOmitted,
+          omittedContent: inspected.omittedContent,
+          truncated: inspected.truncated
+        };
+      }
       case "find_elements": {
-        let collectFindElements2 = function(matches, fallbackSelector) {
+        let collectFindElements2 = function(matches, fallbackSelector, safeAttributeNames, safeDataAttributeNames) {
           const boundedText = (root) => {
             const maybeChildNodes = root.childNodes;
             if (!maybeChildNodes) {
@@ -7202,8 +8172,8 @@ var BrowserService = class {
             const boundedHeight = Number.isFinite(rect.height) ? Math.max(-1e7, Math.min(1e7, Math.round(rect.height))) : 0;
             const attributes = {};
             let omittedAttributes = 0;
-            const safeAttributes = /* @__PURE__ */ new Set(["id", "class", "role", "type", "name", "placeholder", "title", "tabindex", "style", "fill", "stroke", "x", "y", "x1", "x2", "y1", "y2", "r", "cx", "cy", "width", "height", "points", "transform", "font-size"]);
-            const safeDataAttributes = /* @__PURE__ */ new Set(["data-color", "data-index", "data-sides", "data-result", "data-key", "data-type", "data-item", "data-id", "data-start", "data-end", "data-duration", "data-output", "data-value", "data-position", "data-price"]);
+            const safeAttributes = new Set(safeAttributeNames);
+            const safeDataAttributes = new Set(safeDataAttributeNames);
             const attributeCount = element.attributes.length;
             const inspectedAttributes = Math.min(attributeCount, 40);
             for (let index = 0; index < inspectedAttributes; index += 1) {
@@ -7232,7 +8202,7 @@ var BrowserService = class {
         var collectFindElements = collectFindElements2;
         const selector = targetForAction(action, "selector");
         const safeSelector = await this.selectorFor(state, selector, action.frameId, frame);
-        const elements = await frame.$$eval(safeSelector, collectFindElements2, safeSelector);
+        const elements = await frame.$$eval(safeSelector, collectFindElements2, safeSelector, [...SAFE_ELEMENT_ATTRIBUTE_NAMES], [...SAFE_ELEMENT_DATA_ATTRIBUTE_NAMES]);
         return elements.map((element) => ({
           tag: element.tag,
           selector: wrapUntrustedText("element_selector", redactSecretPlaceholders(element.selector), 500),
@@ -7409,7 +8379,8 @@ var BrowserService = class {
       case "solve_challenge":
         return this.solveChallenge(state, action, signal);
       case "get_cookies": {
-        const cookies = await page.cookies();
+        const scopedUrl = action.url ? await this.policy.assertNavigationAllowedAsync(action.url) : void 0;
+        const cookies = scopedUrl ? await page.cookies(scopedUrl.toString()) : await page.cookies();
         return cookies.slice(0, 200).map((cookie) => ({
           name: wrapUntrustedText("cookie_name", redactSecretPlaceholders(cookie.name), 256),
           domain: wrapUntrustedText("cookie_domain", redactSecretPlaceholders(cookie.domain), 512),
@@ -7427,15 +8398,16 @@ var BrowserService = class {
         if (action.cookieDomain) {
           await this.policy.assertNavigationAllowedAsync(`https://${action.cookieDomain.replace(/^\.+/, "")}`);
         }
-        await page.setCookie({ name: cookieName, value: action.cookieValue ?? action.value ?? "", url: url.toString(), domain: action.cookieDomain, path: action.cookiePath ?? "/", secure: action.cookieSecure, httpOnly: action.cookieHttpOnly });
+        await page.setCookie({ name: cookieName, value: action.cookieValue ?? action.value ?? "", url: url.toString(), domain: action.cookieDomain, path: action.cookiePath ?? "/", secure: action.cookieSecure, httpOnly: action.cookieHttpOnly, sameSite: action.cookieSameSite });
         return { set: wrapUntrustedText("cookie_name", redactSecretPlaceholders(cookieName), 256) };
       }
       case "delete_cookies": {
         const cookieName = requireField(action.cookieName, "cookieName");
+        const scopedUrl = action.url ? await this.policy.assertNavigationAllowedAsync(action.url) : void 0;
         if (action.cookieDomain) {
           await this.policy.assertNavigationAllowedAsync(`https://${action.cookieDomain.replace(/^\.+/, "")}`);
         }
-        await page.deleteCookie({ name: cookieName, domain: action.cookieDomain, path: action.cookiePath ?? "/" });
+        await page.deleteCookie({ name: cookieName, ...scopedUrl ? { url: scopedUrl.toString() } : {}, domain: action.cookieDomain, path: action.cookiePath ?? "/" });
         return { deleted: wrapUntrustedText("cookie_name", redactSecretPlaceholders(cookieName), 256) };
       }
       case "get_storage": {
@@ -7680,6 +8652,7 @@ var BrowserService = class {
           if (!executablePath) {
             throw new AppError("BROWSER_NOT_CONFIGURED", `Managed browser mode could not find Chrome. Checked: ${chromeExecutableSearchPaths().join(", ")}. Install Chrome or set SMOOTH_OPERATOR_BROWSER_EXECUTABLE.`);
           }
+          this.assertExecutableReady(executablePath);
           connection = this.launch({
             headless: this.config.browser.headless,
             executablePath,
@@ -7697,6 +8670,7 @@ var BrowserService = class {
         if (!this.config.browser.executablePath) {
           throw new AppError("BROWSER_NOT_CONFIGURED", "Launch mode requires SMOOTH_OPERATOR_BROWSER_EXECUTABLE.");
         }
+        this.assertExecutableReady(this.config.browser.executablePath);
         ownsBrowser = true;
         connection = this.launch({
           headless: this.config.browser.headless,
@@ -7724,6 +8698,13 @@ var BrowserService = class {
         await closeConnectedBrowser(lateBrowser, ownsBrowser, this.logger);
         throw new AppError("SERVER_CLOSING", "The browser runtime is shutting down.", { retryable: true });
       }
+      await this.installTargetGuard(browser);
+      if (this.shuttingDown || generation !== this.lifecycleGeneration || this.shutdownController.signal.aborted) {
+        const lateBrowser = browser;
+        browser = void 0;
+        await closeConnectedBrowser(lateBrowser, ownsBrowser, this.logger);
+        throw new AppError("SERVER_CLOSING", "The browser runtime is shutting down.", { retryable: true });
+      }
       this.browser = browser;
       this.ownsBrowser = ownsBrowser;
       const connectedBrowser = browser;
@@ -7738,9 +8719,8 @@ var BrowserService = class {
         this.lifecycleGeneration += 1;
         this.retireAllStates();
       });
-      this.installTargetGuard(browser);
       browser.on("targetcreated", (target) => {
-        void this.prepareTarget(target);
+        void this.trackTargetPreparation(target);
       });
       return browser;
     } catch (error) {
@@ -7786,6 +8766,17 @@ var BrowserService = class {
     }
     return (await loadPuppeteer()).launch(options);
   }
+  assertExecutableReady(executablePath) {
+    let ready = false;
+    try {
+      ready = this.dependencies.isExecutableReady?.(executablePath) ?? isExecutableReady(executablePath);
+    } catch {
+      ready = false;
+    }
+    if (!ready) {
+      throw new AppError("BROWSER_NOT_CONFIGURED", "Configured browser executable is not ready.", { retryable: true });
+    }
+  }
   async connect(options) {
     if (this.dependencies.connect) {
       return this.dependencies.connect(options);
@@ -7802,7 +8793,9 @@ var BrowserService = class {
     try {
       const info = await lstat(activePortPath);
       if (!info.isFile() || info.size > 4096) {
-        this.logger.debug("Managed browser DevTools endpoint file is invalid", { path: activePortPath });
+        this.logger.debug("Managed browser DevTools endpoint file is invalid", {
+          endpointFile: { kind: "devtools-active-port", regular: info.isFile(), bounded: info.size <= 4096 }
+        });
         return { state: "stale-probe-failed" };
       }
       raw = await readFile(activePortPath, "utf8");
@@ -7810,19 +8803,24 @@ var BrowserService = class {
       if (isMissingFile(error)) {
         return { state: "no-file" };
       }
-      this.logger.debug("Managed browser DevTools endpoint file could not be read", { path: activePortPath, error: String(error) });
+      this.logger.debug("Managed browser DevTools endpoint file could not be read", {
+        endpointFile: { kind: "devtools-active-port", available: false },
+        error: safeErrorDiagnostic(error)
+      });
       return { state: "stale-probe-failed" };
     }
     const browserURL = parseDevToolsActivePort(raw);
     if (!browserURL) {
-      this.logger.debug("Managed browser DevTools endpoint file is malformed", { path: activePortPath });
+      this.logger.debug("Managed browser DevTools endpoint file is malformed", {
+        endpointFile: { kind: "devtools-active-port", available: true, valid: false }
+      });
       return { state: "stale-probe-failed" };
     }
     try {
       const version = await (this.dependencies.probeEndpoint ?? probeDevToolsEndpoint)(browserURL, 2e3);
       return { state: "live", browserURL, version };
     } catch (error) {
-      this.logger.debug("Managed browser DevTools endpoint probe failed", { browserURL, error: String(error) });
+      this.logger.debug("Managed browser DevTools endpoint probe failed", { browserURL, error: safeErrorDiagnostic(error) });
       return { state: "stale-probe-failed" };
     }
   }
@@ -7966,14 +8964,18 @@ var BrowserService = class {
     return matches[0]?.id;
   }
   /** Install a Fetch guard at the CDP boundary to policy-check new targets while paused. */
-  installTargetGuard(browser) {
+  async installTargetGuard(browser) {
     if (this.targetGuardConnection) {
+      if (this.targetGuardReadinessPromise) {
+        await this.targetGuardReadinessPromise;
+      }
       return;
     }
     const connection = browser._connection;
     if (!connection || typeof connection.on !== "function") {
       this.targetGuardUnavailable = true;
       this.logger.warn("Browser target guard is unavailable; popup actions will be blocked");
+      this.targetGuardReadinessPromise = Promise.resolve();
       return;
     }
     this.targetGuardUnavailable = false;
@@ -7981,6 +8983,7 @@ var BrowserService = class {
     if (typeof targetConnection.isAutoAttached !== "function") {
       this.targetGuardUnavailable = true;
       this.logger.warn("Browser target guard is unavailable; attachment ownership cannot be determined");
+      this.targetGuardReadinessPromise = Promise.resolve();
       return;
     }
     const sessionListener = (value) => {
@@ -7994,6 +8997,10 @@ var BrowserService = class {
       if (!event) {
         return;
       }
+      if (this.handledTargetGuardSessions.has(event.sessionId)) {
+        return;
+      }
+      this.handledTargetGuardSessions.add(event.sessionId);
       const session = this.pendingTargetGuardSessions.get(event.sessionId) ?? getCdpSession(targetConnection, event.sessionId);
       this.pendingTargetGuardSessions.delete(event.sessionId);
       this.pendingTargetGuardInfos.delete(event.sessionId);
@@ -8012,6 +9019,16 @@ var BrowserService = class {
         }
         return;
       }
+      if (!this.targetGuardOriginalEmit || !this.targetGuardWrappedEmit) {
+        this.targetGuardUnavailable = true;
+        this.unguardedTargetSessions.add(event.sessionId);
+        if (targetConnection.send) {
+          void targetConnection.send("Target.closeTarget", { targetId: event.targetInfo.targetId }).catch(() => void 0);
+        }
+        void sendSessionCommand(session, "Page.close").catch(() => void 0);
+        this.logger.warn("New browser target guard cannot safely gate debugger resume");
+        return;
+      }
       if (!session) {
         this.unguardedTargetSessions.add(event.sessionId);
         if (targetConnection.send) {
@@ -8021,7 +9038,7 @@ var BrowserService = class {
         return;
       }
       void this.guardTargetSession(session, event.targetInfo).catch((error) => {
-        this.logger.warn("New browser target guard failed", { error: String(error) });
+        this.logger.warn("New browser target guard failed", { error: safeErrorDiagnostic(error) });
       });
     };
     const detachedListener = (value) => {
@@ -8038,12 +9055,14 @@ var BrowserService = class {
       }
       this.pendingTargetGuardSessions.delete(value.sessionId);
       this.pendingTargetGuardInfos.delete(value.sessionId);
+      this.handledTargetGuardSessions.delete(value.sessionId);
     };
     targetConnection.on("sessionattached", sessionListener);
     targetConnection.on("Target.attachedToTarget", rawListener);
     targetConnection.on("Target.detachedFromTarget", detachedListener);
     const originalEmit = targetConnection.emit;
-    if (originalEmit) {
+    let emitGuardInstalled = false;
+    if (typeof originalEmit === "function") {
       const wrappedEmit = (event, value) => {
         if (event === "Target.attachedToTarget") {
           rawListener(value);
@@ -8052,8 +9071,12 @@ var BrowserService = class {
       };
       try {
         targetConnection.emit = wrappedEmit;
+        if (targetConnection.emit !== wrappedEmit) {
+          throw new Error("Connection emit wrapper was not installed.");
+        }
         this.targetGuardOriginalEmit = originalEmit;
         this.targetGuardWrappedEmit = wrappedEmit;
+        emitGuardInstalled = true;
       } catch {
         this.targetGuardOriginalEmit = void 0;
         this.targetGuardWrappedEmit = void 0;
@@ -8063,12 +9086,33 @@ var BrowserService = class {
     this.targetGuardConnectionListener = sessionListener;
     this.targetGuardRawConnectionListener = rawListener;
     this.targetGuardDetachedListener = detachedListener;
+    if (!emitGuardInstalled) {
+      this.targetGuardUnavailable = true;
+      this.targetGuardReadinessPromise = Promise.resolve();
+      this.logger.warn("Browser target guard is unavailable; debugger resume cannot be gated");
+      return;
+    }
     if (targetConnection.send) {
-      void targetConnection.send("Target.setAutoAttach", { autoAttach: true, waitForDebuggerOnStart: true, flatten: true }).catch((error) => {
-        this.targetGuardUnavailable = true;
-        this.logger.warn("Browser target auto-attachment could not be enabled", { error: String(error) });
-      });
+      const readiness = Promise.resolve().then(() => targetConnection.send?.("Target.setAutoAttach", { autoAttach: true, waitForDebuggerOnStart: true, flatten: true })).then(
+        () => {
+          if (this.targetGuardConnection === targetConnection) {
+            this.targetGuardUnavailable = false;
+          }
+        },
+        (error) => {
+          if (this.targetGuardConnection === targetConnection) {
+            this.targetGuardUnavailable = true;
+            this.logger.warn("Browser target auto-attachment could not be enabled", { error: safeErrorDiagnostic(error) });
+          }
+        }
+      ).then(() => void 0);
+      this.targetGuardReadinessPromise = readiness;
+      await readiness;
+      return;
     }
+    this.targetGuardUnavailable = true;
+    this.targetGuardReadinessPromise = Promise.resolve();
+    this.logger.warn("Browser target guard is unavailable; auto-attachment cannot be enabled");
   }
   detachTargetGuard() {
     const connection = this.targetGuardConnection;
@@ -8097,11 +9141,13 @@ var BrowserService = class {
     this.targetGuardConnectionListener = void 0;
     this.targetGuardRawConnectionListener = void 0;
     this.targetGuardDetachedListener = void 0;
+    this.targetGuardReadinessPromise = void 0;
     this.targetGuardOriginalEmit = void 0;
     this.targetGuardWrappedEmit = void 0;
     this.targetGuardUnavailable = false;
     this.pendingTargetGuardSessions.clear();
     this.pendingTargetGuardInfos.clear();
+    this.handledTargetGuardSessions.clear();
     for (const guard of this.targetGuardSessions.values()) {
       guard.released = true;
       removeCdpListener(guard.session, "Fetch.requestPaused", guard.requestPausedListener);
@@ -8131,7 +9177,7 @@ var BrowserService = class {
     };
     guard.requestPausedListener = (event) => {
       const pending = this.handleTargetGuardRequest(guard, event).catch((error) => {
-        this.logger.debug("New target request guard callback failed", { error: String(error) });
+        this.logger.debug("New target request guard callback failed", { error: safeErrorDiagnostic(error) });
       });
       guard.pendingRequests.add(pending);
       void pending.finally(() => guard.pendingRequests.delete(pending)).catch(() => void 0);
@@ -8191,7 +9237,7 @@ var BrowserService = class {
       this.targetGuardSessions.delete(sessionId);
       this.unguardedTargetSessions.add(sessionId);
       await this.closeGuardedTarget(guard);
-      this.logger.warn("New browser target could not be guarded", { error: String(error) });
+      this.logger.warn("New browser target could not be guarded", { error: safeErrorDiagnostic(error) });
       throw error;
     }
   }
@@ -8248,7 +9294,7 @@ var BrowserService = class {
         await guard.session.send("Fetch.failRequest", { requestId, errorReason: "BlockedByClient" });
       }
     } catch (error) {
-      this.logger.debug("New target request could not be resolved", { error: String(error) });
+      this.logger.debug("New target request could not be resolved", { error: safeErrorDiagnostic(error) });
     } finally {
       guard.requestIds.delete(requestId);
     }
@@ -8327,9 +9373,15 @@ var BrowserService = class {
         throw error;
       }
     } catch (error) {
-      this.logger.warn("New browser tab could not be prepared", { error: String(error) });
+      this.logger.warn("New browser tab could not be prepared", { error: safeErrorDiagnostic(error) });
     }
   }
+  trackTargetPreparation(target) {
+    const preparation = this.prepareTarget(target);
+    this.pendingTargetPreparations.add(preparation);
+    void preparation.finally(() => this.pendingTargetPreparations.delete(preparation)).catch(() => void 0);
+    return preparation;
+  }
   isUnguardedTargetPage(page) {
     const identity = pageTargetIdentity(page);
     return Boolean(identity.sessionId && this.unguardedTargetSessions.has(identity.sessionId));
@@ -8384,7 +9436,7 @@ var BrowserService = class {
       state.challengeStatus = void 0;
       state.challengeAttempts = 0;
     } catch (error) {
-      this.logger.debug("Blocked navigation recovery could not restore a blank page", { pageId: state.id, error: String(error) });
+      this.logger.debug("Blocked navigation recovery could not restore a blank page", { pageId: state.id, error: safeErrorDiagnostic(error) });
     }
   }
   async disposePageState(state) {
@@ -8409,6 +9461,7 @@ var BrowserService = class {
     state.snapshotInteractive = void 0;
     state.snapshotId = void 0;
     state.policyVerifiedUrls?.clear();
+    this.networkJournal.clear(state.id);
     state.dialogs.length = 0;
     state.navigationError = void 0;
     state.activeNavigationGeneration = void 0;
@@ -8581,7 +9634,7 @@ var BrowserService = class {
         throwIfAborted(signal);
         const classified = error instanceof AppError && error.code === "DOWNLOAD_CONFIGURATION_FAILED" ? error : new AppError("DOWNLOAD_CONFIGURATION_FAILED", "The browser download directory could not be configured. Retry after reconnecting the browser.", { retryable: true, cause: error });
         state.downloadConfigurationError = classified;
-        this.logger.warn("Browser download behavior could not be configured", { pageId: state.id, error: String(error) });
+        this.logger.warn("Browser download behavior could not be configured", { pageId: state.id, error: safeErrorDiagnostic(error) });
       }
     }
     this.assertStateLive(state);
@@ -8661,6 +9714,18 @@ var BrowserService = class {
         state.policyVerifiedUrls?.clear();
       }
       requestUrl = request.url();
+      const resourceType = typeof request.resourceType === "function" ? request.resourceType()?.toLowerCase() : void 0;
+      if (!navigationRequest && resourceType && state.blockedResourceTypes.has(resourceType)) {
+        let handled = true;
+        try {
+          handled = request.isInterceptResolutionHandled();
+        } catch {
+        }
+        if (!handled) {
+          await request.abort("blockedbyclient").catch(() => void 0);
+        }
+        return;
+      }
       if (/^about:blank(?:#.*)?$/i.test(requestUrl)) {
         await request.continue();
         return;
@@ -8704,6 +9769,35 @@ var BrowserService = class {
       }
     }
   }
+  networkRequestId(request) {
+    const existing = this.networkRequestIds.get(request);
+    if (existing) {
+      return existing;
+    }
+    try {
+      const raw = request.id;
+      if (typeof raw === "string" || typeof raw === "number") {
+        return String(raw);
+      }
+    } catch {
+    }
+    return void 0;
+  }
+  networkRequestIdForResponse(pageId, request, url, resourceType, timestamp) {
+    const known = this.networkRequestId(request);
+    if (known) {
+      return known;
+    }
+    const recorded = this.networkJournal.recordRequest({
+      pageId,
+      url,
+      method: "UNKNOWN",
+      ...resourceType ? { resourceType } : {},
+      timestamp
+    });
+    this.networkRequestIds.set(request, recorded.requestId);
+    return recorded.requestId;
+  }
   stateFor(page) {
     const existingId = this.ids.get(page);
     if (existingId) {
@@ -8713,7 +9807,7 @@ var BrowserService = class {
       }
       this.ids.delete(page);
     }
-    const state = { id: randomUUID(), page, lifecycleGeneration: this.lifecycleGeneration, disposed: false, refs: /* @__PURE__ */ new Map(), domRevision: 0, networkEnabled: false, consoleEnabled: false, network: [], console: [], dialogs: [], listenersInstalled: false, timeoutsConfigured: false, viewportConfigured: false, downloadConfigured: false, navigationGuardInstalled: false, stealthInjected: false, navigationGeneration: 0, policyVerifiedUrls: /* @__PURE__ */ new Set() };
+    const state = { id: randomUUID(), page, lifecycleGeneration: this.lifecycleGeneration, disposed: false, refs: /* @__PURE__ */ new Map(), domRevision: 0, networkEnabled: false, consoleEnabled: false, network: [], console: [], dialogs: [], listenersInstalled: false, timeoutsConfigured: false, viewportConfigured: false, downloadConfigured: false, navigationGuardInstalled: false, stealthInjected: false, navigationGeneration: 0, policyVerifiedUrls: /* @__PURE__ */ new Set(), blockedResourceTypes: /* @__PURE__ */ new Set() };
     this.ids.set(page, state.id);
     this.states.set(state.id, state);
     this.installListeners(state);
@@ -8729,10 +9823,23 @@ var BrowserService = class {
         return;
       }
       try {
-        state.network.push({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), type: "request", url: sanitizeUrl(request.url()), method: request.method() });
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const url = request.url();
+        const method = request.method();
+        const resourceType = request.resourceType?.();
+        const recorded = this.networkJournal.recordRequest({
+          pageId: state.id,
+          requestId: this.networkRequestId(request),
+          url,
+          method,
+          ...typeof resourceType === "string" ? { resourceType } : {},
+          timestamp
+        });
+        this.networkRequestIds.set(request, recorded.requestId);
+        state.network.push({ timestamp, type: "request", url: sanitizeUrl(url), method });
         trimLog(state.network);
       } catch (error) {
-        this.logger.debug("Browser request log entry was unavailable after page disposal", { pageId: state.id, error: String(error) });
+        this.logger.debug("Browser request log entry was unavailable after page disposal", { pageId: state.id, error: safeErrorDiagnostic(error) });
       }
     };
     state.networkRequestListener = networkRequestListener;
@@ -8746,11 +9853,24 @@ var BrowserService = class {
           state.mainFrameStatus = response.status();
         }
         if (state.networkEnabled) {
-          state.network.push({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), type: "response", url: sanitizeUrl(response.url()), status: response.status() });
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+          const request = response.request();
+          const url = response.url();
+          const resourceType = request.resourceType?.();
+          const requestId = this.networkRequestIdForResponse(state.id, request, url, resourceType, timestamp);
+          this.networkJournal.recordResponse({
+            pageId: state.id,
+            requestId,
+            url,
+            status: response.status(),
+            ...typeof resourceType === "string" ? { resourceType } : {},
+            timestamp
+          });
+          state.network.push({ timestamp, type: "response", url: sanitizeUrl(url), status: response.status() });
           trimLog(state.network);
         }
       } catch (error) {
-        this.logger.debug("Browser response log entry was unavailable after page disposal", { pageId: state.id, error: String(error) });
+        this.logger.debug("Browser response log entry was unavailable after page disposal", { pageId: state.id, error: safeErrorDiagnostic(error) });
       }
     };
     state.networkResponseListener = networkResponseListener;
@@ -8763,7 +9883,7 @@ var BrowserService = class {
         state.console.push({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), type: "console", level: message.type(), text: message.text().slice(0, 2e3) });
         trimLog(state.console);
       } catch (error) {
-        this.logger.debug("Browser console log entry was unavailable after page disposal", { pageId: state.id, error: String(error) });
+        this.logger.debug("Browser console log entry was unavailable after page disposal", { pageId: state.id, error: safeErrorDiagnostic(error) });
       }
     };
     state.consoleListener = consoleListener;
@@ -8778,7 +9898,7 @@ var BrowserService = class {
         this.currentPageId = state.id;
         this.logger.info("Browser dialog opened", { pageId: state.id, type });
       } catch (error) {
-        this.logger.debug("Browser dialog event was unavailable after page disposal", { pageId: state.id, error: String(error) });
+        this.logger.debug("Browser dialog event was unavailable after page disposal", { pageId: state.id, error: safeErrorDiagnostic(error) });
       }
     };
     state.dialogListener = dialogListener;
@@ -8799,7 +9919,7 @@ var BrowserService = class {
           state.challengeAttempts = 0;
         }
       } catch (error) {
-        this.logger.debug("Browser frame navigation event was unavailable after page disposal", { pageId: state.id, error: String(error) });
+        this.logger.debug("Browser frame navigation event was unavailable after page disposal", { pageId: state.id, error: safeErrorDiagnostic(error) });
       }
     };
     state.frameNavigatedListener = frameNavigatedListener;
@@ -9824,7 +10944,7 @@ var BrowserService = class {
     removeDialogListener?.();
     if (openedDialog === null) {
       void click.catch((error) => {
-        this.logger.debug("Browser click completed after dialog resolution", { pageId: state.id, error: String(error) });
+        this.logger.debug("Browser click completed after dialog resolution", { pageId: state.id, error: safeErrorDiagnostic(error) });
       });
       throwIfAborted(signal);
       return { navigated: false, urlChanged: false };
@@ -10569,6 +11689,9 @@ var BrowserService = class {
     if (before.isSymbolicLink()) {
       throw new AppError("FILE_PATH_BLOCKED", "The upload source must not be a symbolic link.");
     }
+    if (before.size > MAX_UPLOAD_BYTES) {
+      throw new AppError("FILE_TOO_LARGE", "The upload source exceeds the 50 MiB size limit.");
+    }
     const noFollow = typeof fsConstants.O_NOFOLLOW === "number" ? fsConstants.O_NOFOLLOW : 0;
     let sourceHandle;
     let stagingPath;
@@ -10578,6 +11701,9 @@ var BrowserService = class {
       if (!opened.isFile()) {
         throw new AppError("FILE_PATH_BLOCKED", "The upload source must be a regular file.");
       }
+      if (opened.size > MAX_UPLOAD_BYTES) {
+        throw new AppError("FILE_TOO_LARGE", "The upload source exceeds the 50 MiB size limit.");
+      }
       const after = await lstat(candidate);
       if (after.isSymbolicLink() || !sameFileIdentity(opened, after)) {
         throw new AppError("FILE_PATH_BLOCKED", "The upload source changed while it was being opened.", { retryable: true });
@@ -10587,10 +11713,15 @@ var BrowserService = class {
       await mkdir(stagingDirectory, { recursive: true, mode: 448 });
       stagingPath = join4(stagingDirectory, `.upload-${randomUUID()}`);
       const stagingHandle = await open(stagingPath, "wx", 384);
+      let copiedBytes = 0;
       try {
         for await (const chunk of sourceHandle.createReadStream({ autoClose: false })) {
           throwIfAborted(signal);
           const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+          copiedBytes += buffer.byteLength;
+          if (copiedBytes > MAX_UPLOAD_BYTES) {
+            throw new AppError("FILE_TOO_LARGE", "The upload source exceeds the 50 MiB size limit.");
+          }
           let offset = 0;
           while (offset < buffer.byteLength) {
             const written = await stagingHandle.write(buffer, offset, buffer.byteLength - offset, null);
@@ -10605,7 +11736,7 @@ var BrowserService = class {
         await stagingHandle.close().catch(() => void 0);
       }
       throwIfAborted(signal);
-      return { path: stagingPath, displayName: basename2(candidate), size: opened.size };
+      return { path: stagingPath, displayName: basename2(candidate), size: copiedBytes };
     } catch (error) {
       if (stagingPath) {
         await unlinkIfPresent(stagingPath);
@@ -10686,7 +11817,7 @@ var BrowserService = class {
     }).catch(() => void 0);
     return recovery;
   }
-  async withOperationLock(signal, operation, queueTimeoutMs = this.config.browser.actionTimeoutMs, operationTimeoutMs, mode = "exclusive") {
+  async withOperationLock(signal, operation, queueTimeoutMs = this.config.browser.actionTimeoutMs, operationTimeoutMs, mode = "exclusive", touchActivity = true) {
     if (this.queuedOperations >= MAX_QUEUED_OPERATIONS) {
       throw new AppError("BROWSER_QUEUE_FULL", "The browser action queue is full; wait for an active operation to finish and retry.", { retryable: true, details: { hint: "Wait for the active browser operation to finish, then retry." } });
     }
@@ -10767,7 +11898,9 @@ var BrowserService = class {
           }
         }
       }, operationBudgetMs);
-      this.lastActivityAt = Date.now();
+      if (touchActivity) {
+        this.lastActivityAt = Date.now();
+      }
       operationPromise = Promise.resolve().then(() => operation(operationSignal));
       void operationPromise.catch(() => void 0);
       if (abortRequested) {
@@ -10894,17 +12027,20 @@ function isBrowserConnectTimeout(error) {
   return error instanceof AppError && error.code === "BROWSER_CONNECT_TIMEOUT";
 }
 async function closeConnectedBrowser(browser, owned, logger) {
-  let succeeded = true;
-  if (owned) {
-    await Promise.resolve().then(() => browser.close()).catch((error) => {
-      succeeded = false;
-      logger.warn("Late browser close failed", { error: String(error) });
-    });
-  } else {
-    await Promise.resolve().then(() => browser.disconnect()).catch((error) => {
-      succeeded = false;
-      logger.warn("Late browser disconnect failed", { error: String(error) });
-    });
+  const closing = Promise.resolve().then(() => owned ? browser.close() : browser.disconnect());
+  const succeeded = await settleWithTimeout(
+    closing.then(
+      () => true,
+      (error) => {
+        logger.warn(owned ? "Browser close failed" : "Browser disconnect failed", { error: safeErrorDiagnostic(error) });
+        return false;
+      }
+    ),
+    SHUTDOWN_CONNECTION_SETTLE_TIMEOUT_MS
+  );
+  if (succeeded === void 0) {
+    logger.warn(owned ? "Browser close timed out" : "Browser disconnect timed out");
+    return false;
   }
   return succeeded;
 }
@@ -11474,7 +12610,16 @@ async function probeDevToolsEndpoint(browserURL, timeoutMs) {
     if (!response.ok) {
       throw new Error(`DevTools endpoint returned HTTP ${response.status}.`);
     }
-    const value = await response.json();
+    const declaredLength = response.headers.get("content-length");
+    if (declaredLength !== null) {
+      const parsedLength = Number(declaredLength);
+      if (Number.isFinite(parsedLength) && parsedLength > MAX_DEVTOOLS_PROBE_RESPONSE_BYTES) {
+        cancelDevToolsProbeBody(response);
+        throw new Error("DevTools endpoint response exceeded the safety limit.");
+      }
+    }
+    const body = await readBoundedDevToolsResponse(response, MAX_DEVTOOLS_PROBE_RESPONSE_BYTES);
+    const value = JSON.parse(body);
     if (!isRecordValue(value)) {
       throw new Error("DevTools endpoint returned an invalid version payload.");
     }
@@ -11487,6 +12632,39 @@ async function probeDevToolsEndpoint(browserURL, timeoutMs) {
     clearTimeout(timer);
   }
 }
+async function readBoundedDevToolsResponse(response, maxBytes) {
+  if (!response.body) {
+    throw new Error("DevTools endpoint returned an empty response body.");
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const next = await reader.read();
+      if (next.done) {
+        break;
+      }
+      const value = next.value;
+      if (!(value instanceof Uint8Array) || value.byteLength > maxBytes - total) {
+        void reader.cancel().catch(() => void 0);
+        throw new Error("DevTools endpoint response exceeded the safety limit.");
+      }
+      const chunk = Buffer.from(value);
+      total += chunk.byteLength;
+      chunks.push(chunk);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks, total).toString("utf8");
+}
+function cancelDevToolsProbeBody(response) {
+  try {
+    void response.body?.cancel().catch(() => void 0);
+  } catch {
+  }
+}
 function boundedEndpointField(value) {
   return typeof value === "string" ? value.slice(0, 4096) : void 0;
 }
@@ -11598,6 +12776,8 @@ var MAX_RESULT_SNIPPET_CHARS = 4e3;
 var MAX_ATTEMPTS = 3;
 var RETRY_BASE_DELAY_MS = 250;
 var RETRY_MAX_DELAY_MS = 2e3;
+var MAX_CONCURRENT_RESEARCH = 4;
+var MAX_RESEARCH_QUEUE = 16;
 var ZERO_WIDTH_PATTERN2 = /[\u200B-\u200D\u2060\uFEFF]/g;
 var CONTROL_CHARACTER_PATTERN = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g;
 var ANTI_BOT_PATTERN = /(?:captcha|challenge|unusual\s+traffic|automated\s+(?:queries|requests)|access\s+denied|temporarily\s+blocked|too\s+many\s+requests)/i;
@@ -11606,6 +12786,70 @@ var RESULT_CLASS_ATTRIBUTE_PATTERN = /\bclass\s*=\s*(["'])([^"']*)\1/i;
 var RESULT_HREF_ATTRIBUTE_PATTERN = /\bhref\s*=\s*(["'])([^"']*)\1/i;
 var NEXT_RESULT_PATTERN = /<a\b[^>]*\bclass\s*=\s*(["'])[^"']*\bresult__a\b[^"']*\1/i;
 var RESULT_SNIPPET_PATTERN = /\bclass\s*=\s*(["'])[^"']*\bresult__snippet\b[^"']*\1[^>]*>([\s\S]*?)<\/[^>]+>/i;
+var ResearchAdmission = class {
+  active = 0;
+  queue = [];
+  acquire(signal, abortError = cancelledResearchError) {
+    if (signal?.aborted) {
+      return Promise.reject(abortError());
+    }
+    if (this.active < MAX_CONCURRENT_RESEARCH) {
+      this.active += 1;
+      return Promise.resolve(this.createRelease());
+    }
+    if (this.queue.length >= MAX_RESEARCH_QUEUE) {
+      return Promise.reject(new AppError("RESEARCH_BUSY", "The research service is busy; retry later.", {
+        retryable: true,
+        status: 503,
+        details: { classification: "overloaded" }
+      }));
+    }
+    return new Promise((resolve7, reject) => {
+      const waiter = { resolve: resolve7, reject, signal, abortError };
+      const onAbort = () => {
+        const index = this.queue.indexOf(waiter);
+        if (index < 0) {
+          return;
+        }
+        this.queue.splice(index, 1);
+        signal?.removeEventListener("abort", onAbort);
+        reject(abortError());
+      };
+      waiter.onAbort = onAbort;
+      signal?.addEventListener("abort", onAbort, { once: true });
+      this.queue.push(waiter);
+      if (signal?.aborted) {
+        onAbort();
+      }
+    });
+  }
+  createRelease() {
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      this.active -= 1;
+      this.drain();
+    };
+  }
+  drain() {
+    while (this.active < MAX_CONCURRENT_RESEARCH && this.queue.length > 0) {
+      const waiter = this.queue.shift();
+      if (!waiter) {
+        return;
+      }
+      waiter.signal?.removeEventListener("abort", waiter.onAbort);
+      if (waiter.signal?.aborted) {
+        waiter.reject(waiter.abortError());
+        continue;
+      }
+      this.active += 1;
+      waiter.resolve(this.createRelease());
+    }
+  }
+};
 var ResearchService = class {
   constructor(policy, logger) {
     this.policy = policy;
@@ -11613,6 +12857,7 @@ var ResearchService = class {
   }
   policy;
   logger;
+  admission = new ResearchAdmission();
   async research(query, options = {}, signal) {
     if (typeof query !== "string") {
       throw new AppError("RESEARCH_INVALID", "A non-empty research query is required.");
@@ -11651,7 +12896,17 @@ var ResearchService = class {
     }, REQUEST_TIMEOUT_MS);
     const abort = () => controller.abort();
     signal?.addEventListener("abort", abort, { once: true });
+    let release;
     try {
+      const abortError = () => signal?.aborted ? new AppError("CANCELLED", "The research request was cancelled.") : new AppError("RESEARCH_TIMEOUT", `The research request exceeded its ${REQUEST_TIMEOUT_MS / 1e3}-second timeout.`, {
+        retryable: true,
+        details: { classification: "timeout", timeoutMs: REQUEST_TIMEOUT_MS }
+      });
+      release = await this.admission.acquire(controller.signal, abortError);
+      if (controller.signal.aborted) {
+        controller.abort();
+        throw abortError();
+      }
       const url = await awaitWithAbort2(
         this.policy.assertNavigationAllowedAsync(`https://html.duckduckgo.com/html/?q=${encodedQuery}`),
         controller.signal
@@ -11722,9 +12977,13 @@ var ResearchService = class {
     } finally {
       clearTimeout(timeout);
       signal?.removeEventListener("abort", abort);
+      release?.();
     }
   }
 };
+function cancelledResearchError() {
+  return new AppError("CANCELLED", "The research request was cancelled.");
+}
 async function fetchWithRetry(url, signal) {
   for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
     if (signal.aborted) {
@@ -12254,10 +13513,11 @@ var ServerRuntime = class _ServerRuntime {
         mode: this.config.browser.mode,
         configured: managedBrowser || !browserDisabled && (usesExecutable ? Boolean(this.config.browser.executablePath) : Boolean(this.config.browser.wsEndpoint || this.config.browser.url)),
         connection: browserDisabled ? "disabled" : managedBrowser ? "managed" : usesExecutable ? "executable" : this.config.browser.wsEndpoint ? "websocket" : "devtools-http",
-        runtime: browserDisabled ? { connected: false, owned: false, trackedPages: 0, queuedOperations: 0, currentPageId: null, recoveryRequired: false } : this.browser.connectionStatus(),
+        runtime: browserDisabled ? { connected: false, owned: false, trackedPages: 0, queuedOperations: 0, currentPageId: null, recoveryRequired: false, idleTimeoutMs: this.config.browser.idleTimeoutMs } : this.browser.connectionStatus(),
         actionTimeoutMs: this.config.browser.actionTimeoutMs,
         connectTimeoutMs: this.config.browser.connectTimeoutMs,
         cdpTimeoutMs: this.config.browser.cdpTimeoutMs,
+        idleTimeoutMs: this.config.browser.idleTimeoutMs,
         maxScreenshotBytes: this.config.browser.maxScreenshotBytes,
         maxHtmlChars: this.config.browser.maxHtmlChars
       },
@@ -12747,6 +14007,7 @@ async function serveHttp(runtime, shutdown) {
     response.on("error", (error) => runtime.logger.error("MCP HTTP response error", safeErrorDiagnostic(error)));
     request.on("error", (error) => runtime.logger.error("MCP HTTP request error", safeErrorDiagnostic(error)));
     if (!accepting) {
+      closeIncompleteRequestAfterResponse(request, response);
       response.writeHead(503, { "content-type": "application/json", "retry-after": "1" });
       response.end(HTTP_SHUTTING_DOWN_BODY);
       return;
@@ -12759,11 +14020,13 @@ async function serveHttp(runtime, shutdown) {
     }
     setCorsHeaders(request, response);
     if (!requestPathMatches(request, config.http.path)) {
+      closeIncompleteRequestAfterResponse(request, response);
       response.writeHead(404, { "content-type": "application/json" });
       response.end(HTTP_NOT_FOUND_BODY);
       return;
     }
     if (request.method === "OPTIONS") {
+      closeIncompleteRequestAfterResponse(request, response);
       response.writeHead(204, {
         "access-control-allow-methods": "GET, POST, DELETE, OPTIONS",
         "access-control-allow-headers": request.headers["access-control-request-headers"] ?? "authorization, content-type, accept, mcp-protocol-version, mcp-session-id, last-event-id",
@@ -12774,6 +14037,7 @@ async function serveHttp(runtime, shutdown) {
       return;
     }
     if (!authorized(request, expectedAuthDigest)) {
+      closeIncompleteRequestAfterResponse(request, response);
       response.writeHead(401, { "content-type": "application/json", "www-authenticate": "Bearer" });
       response.end(HTTP_UNAUTHORIZED_BODY);
       return;
@@ -12781,6 +14045,7 @@ async function serveHttp(runtime, shutdown) {
     let streamPool = isPotentialHttpStream(request) ? activeHttpStreams : activeHttpRequests;
     const poolLimit = streamPool === activeHttpStreams ? MAX_HTTP_STREAM_CONCURRENCY : MAX_HTTP_CONCURRENCY;
     if (streamPool.size >= poolLimit) {
+      closeIncompleteRequestAfterResponse(request, response);
       response.writeHead(503, { "content-type": "application/json", "retry-after": "1" });
       response.end(HTTP_BUSY_BODY);
       return;