smooth-operator-mcp 2.3.0 → 2.4.0

package/dist/smooth-operator.mjs

@@ -388,11 +388,11 @@ __export(installer_exports, {
   supportedHarnessTargets: () => supportedHarnessTargets
 });
 import { constants as constants2, accessSync, existsSync } from "node:fs";
-import { chmod as chmod2, lstat as lstat3, mkdir as mkdir3, open as open2, rename as rename3, unlink as unlink3, writeFile } from "node:fs/promises";
+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";
 import { homedir as homedir3, platform as platform2 } from "node:os";
-import { basename as basename4, dirname as dirname4, join as join6, parse, resolve as resolve5, sep as sep3 } from "node:path";
+import { basename as basename4, dirname as dirname4, isAbsolute as isAbsolute3, join as join6, parse, resolve as resolve5, sep as sep3, win32 as win322 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 function supportedHarnessTargets() {
@@ -602,14 +602,14 @@ async function readConfigFile2(path) {
   }
   let handle;
   try {
-    handle = await open2(path, constants2.O_RDONLY | noFollow);
+    handle = await open3(path, constants2.O_RDONLY | noFollow);
   } catch (error) {
     if (isMissingFile2(error)) {
       return void 0;
     }
     if (noFollow && (isErrorCode(error, "EINVAL") || isErrorCode(error, "ENOTSUP") || isErrorCode(error, "EOPNOTSUPP"))) {
       await rejectSymlink2(path, "configuration file");
-      handle = await open2(path, constants2.O_RDONLY);
+      handle = await open3(path, constants2.O_RDONLY);
     } else {
       if (isErrorCode(error, "ELOOP") || isErrorCode(error, "EFTYPE")) {
         throw new AppError("INSTALL_CONFIG_FAILED", `The configuration file '${path}' must not be a symbolic link.`);
@@ -647,7 +647,7 @@ async function chooseExistingOpenCodePath(plannedPath) {
   return plannedPath;
 }
 function isStaleEmbeddedCommand(command) {
-  if (typeof command !== "string" || !command.includes("/")) {
+  if (typeof command !== "string" || !isAbsoluteEmbeddedPath(command)) {
     return false;
   }
   return !existsSync(command);
@@ -657,7 +657,10 @@ function isStaleEmbeddedCommandArray(command) {
     return false;
   }
   const interpreter = command[0];
-  return typeof interpreter === "string" && interpreter.includes("/") && !existsSync(interpreter);
+  return typeof interpreter === "string" && isAbsoluteEmbeddedPath(interpreter) && !existsSync(interpreter);
+}
+function isAbsoluteEmbeddedPath(value) {
+  return isAbsolute3(value) || win322.isAbsolute(value);
 }
 function isRepairableStdioEntry(existing, entry) {
   return isStaleEmbeddedCommand(existing.command) && Array.isArray(existing.args) && existing.args.length === entry.args.length && existing.args.every((arg, index) => arg === entry.args[index]);
@@ -794,7 +797,7 @@ async function createUniqueBackup(path, reviewedBytes) {
     await rejectSymlink2(candidate, "configuration backup");
     let handle;
     try {
-      handle = await open2(candidate, "wx", 384);
+      handle = await open3(candidate, "wx", 384);
       await handle.writeFile(reviewedBytes);
       await handle.chmod(384);
       await handle.sync();
@@ -1057,7 +1060,7 @@ __export(installer_wizard_exports, {
   promptForHarness: () => promptForHarness,
   runWizard: () => runWizard
 });
-import { join as join7 } from "node:path";
+import { isAbsolute as isAbsolute4, join as join7, parse as parse2, win32 as win323 } from "node:path";
 import { existsSync as existsSync2 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 function isRecord4(value) {
@@ -1066,6 +1069,12 @@ function isRecord4(value) {
 function isMissingPathError2(error) {
   return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
 }
+function isAbsolutePath(value) {
+  return isAbsolute4(value) || win323.isAbsolute(value);
+}
+function isFilesystemRoot(value) {
+  return isAbsolute4(value) && parse2(value).root === value || win323.isAbsolute(value) && win323.parse(value).root === value;
+}
 function isInteractive() {
   return Boolean(process.stdin.isTTY && process.stdout.isTTY && !process.env.CI);
 }
@@ -1134,14 +1143,14 @@ async function askBrowser(session, ui) {
         return detected[numeric - 1].path;
       }
       if (/^\d+$/.test(answer)) continue;
-      if (answer.startsWith("/") && existsSync2(answer)) return answer;
+      if (isAbsolutePath(answer) && existsSync2(answer)) return answer;
       ui.failure("Enter a listed number or an existing absolute path.");
     }
   }
   while (true) {
     const answer = (await session.question("Browser executable path (Enter = auto-detect): ")).trim();
     if (!answer) return void 0;
-    if (!answer.startsWith("/")) {
+    if (!isAbsolutePath(answer)) {
       ui.failure("Enter an absolute path.");
       continue;
     }
@@ -1201,7 +1210,7 @@ async function runWizard(harness, opts) {
   });
   const session = tolerantQuestion(rl);
   try {
-    ui.banner("SmoothOperator Setup", `Give ${harness} a real Chrome it can drive`, opts.version ?? "2.2.0");
+    ui.banner("SmoothOperator Setup", `Give ${harness} a real Chrome it can drive`, opts.version ?? "2.4.0");
     ui.note(`Configuring: ${harness}`);
     ui.note("Answer each question, or press Enter to accept the recommended default.");
     ui.note(`You can re-run \`smooth-operator install ${harness}\` at any time to change these.`);
@@ -1298,7 +1307,7 @@ async function runWizard(harness, opts) {
       while (dataDir === defaults.dataDir) {
         const answer = (await session.question(`Data directory [${defaults.dataDir}]: `)).trim();
         if (!answer) break;
-        if (!answer.startsWith("/") || answer.replace(/\/+$/, "") === "") {
+        if (!isAbsolutePath(answer) || isFilesystemRoot(answer)) {
           ui.failure("Enter an absolute path other than the filesystem root.");
           continue;
         }
@@ -1485,7 +1494,7 @@ var init_installer_wizard = __esm({
 
 // src/server/main.ts
 import { createServer } from "node:http";
-import { timingSafeEqual } from "node:crypto";
+import { createHash, timingSafeEqual } from "node:crypto";
 import { realpathSync as realpathSync2 } from "node:fs";
 import process4 from "node:process";
 import { Readable } from "node:stream";
@@ -1799,7 +1808,8 @@ var HttpUrl = (max) => BoundedString(max).refine(isHttpUrl, "URL must be an abso
 var PageInput = {
   pageId: BoundedString(200).optional(),
   snapshotId: BoundedString(200).optional(),
-  frameId: BoundedString(200).optional()
+  frameId: BoundedString(200).optional(),
+  includeSnapshot: z2.boolean().optional()
 };
 var BrowserActionNames = [
   "click",
@@ -1900,6 +1910,7 @@ var BrowserActionFieldsSchema = z2.object({
   expression: z2.string().trim().min(1).max(4e4).optional(),
   query: BoundedString(4e3).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(),
   interestingOnly: z2.boolean().optional(),
@@ -1933,7 +1944,8 @@ var BrowserActionFieldsSchema = z2.object({
   storageValue: z2.string().max(2e4).optional(),
   storageAll: z2.boolean().optional(),
   includeValues: z2.boolean().optional(),
-  confirmDestructive: z2.boolean().optional()
+  confirmDestructive: z2.boolean().optional(),
+  revision: z2.number().int().min(0).max(1e9).optional()
 }).strict();
 var BrowserActionSchema = BrowserActionFieldsSchema.extend({ action: ActionNameSchema }).superRefine((input, context) => {
   const targetForms = [input.target !== void 0, input.ref !== void 0, input.selector !== void 0, input.index !== void 0].filter(Boolean).length;
@@ -2087,6 +2099,82 @@ var BrowserActionSchema = BrowserActionFieldsSchema.extend({ action: ActionNameS
       break;
   }
 });
+var ACTION_ALIASES = {
+  key: "send_keys",
+  select: "select_dropdown",
+  back: "go_back",
+  forward: "go_forward",
+  page_info: "get_page_info",
+  challenge: "detect_challenge",
+  interactive: "list_interactive",
+  frames: "list_frames",
+  downloads: "list_downloads",
+  upload: "upload_file",
+  pdf: "save_as_pdf"
+};
+var GROUPED_ACTION_ALIASES = {
+  cookie: { get: "get_cookies", set: "set_cookie", delete: "delete_cookies" },
+  cookies: { get: "get_cookies", set: "set_cookie", delete: "delete_cookies" },
+  storage: { get: "get_storage", set: "set_storage", clear: "clear_storage" },
+  dialog: { get_text: "alert_get_text", accept: "alert_accept", dismiss: "alert_dismiss", send_keys: "alert_send_keys" },
+  network: { enable: "enable_network_log", disable: "disable_network_log", read: "get_network_log", clear: "clear_network_log", read_and_clear: "getclear_network_log" },
+  network_log: { enable: "enable_network_log", disable: "disable_network_log", read: "get_network_log", clear: "clear_network_log", read_and_clear: "getclear_network_log" },
+  console: { enable: "enable_console_log", disable: "disable_console_log", read: "get_console_log", clear: "clear_console_log", read_and_clear: "getclear_console_log" },
+  console_log: { enable: "enable_console_log", disable: "disable_console_log", read: "get_console_log", clear: "clear_console_log", read_and_clear: "getclear_console_log" }
+};
+function moveActionField(output, canonical, alias, issues) {
+  const hasCanonical = Object.hasOwn(output, canonical);
+  const hasAlias = Object.hasOwn(output, alias);
+  if (hasCanonical && hasAlias) {
+    issues.push({ fields: [canonical, alias], message: `Conflicting fields '${canonical}' and '${alias}' were provided.` });
+    return;
+  }
+  if (hasAlias) {
+    output[canonical] = output[alias];
+    delete output[alias];
+  }
+}
+function normalizeBrowserActionInput(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return { value, issues: [] };
+  }
+  const output = { ...value };
+  const issues = [];
+  const rawAction = typeof output.action === "string" ? output.action : void 0;
+  const grouped = rawAction ? GROUPED_ACTION_ALIASES[rawAction] : void 0;
+  if (grouped) {
+    const operation = typeof output.operation === "string" ? output.operation : "";
+    const mappedAction = grouped[operation];
+    if (mappedAction) {
+      output.action = mappedAction;
+      delete output.operation;
+      if (rawAction === "cookie" || rawAction === "cookies") {
+        moveActionField(output, "cookieName", "name", issues);
+        moveActionField(output, "cookieValue", "value", issues);
+        moveActionField(output, "cookieDomain", "domain", issues);
+        moveActionField(output, "cookiePath", "path", issues);
+        moveActionField(output, "cookieSecure", "secure", issues);
+        moveActionField(output, "cookieHttpOnly", "httpOnly", issues);
+      } else if (rawAction === "storage") {
+        moveActionField(output, "storageArea", "area", issues);
+        moveActionField(output, "storageKey", "key", issues);
+        moveActionField(output, "storageValue", "value", issues);
+        moveActionField(output, "storageAll", "all", issues);
+      }
+    }
+  } else if (rawAction && ACTION_ALIASES[rawAction]) {
+    output.action = ACTION_ALIASES[rawAction];
+  }
+  moveActionField(output, "pageId", "tab_id", issues);
+  return { value: output, issues };
+}
+var BrowserActionInputSchema = z2.preprocess((value, context) => {
+  const normalized = normalizeBrowserActionInput(value);
+  for (const issue of normalized.issues) {
+    context.addIssue({ code: "custom", path: issue.fields, message: issue.message });
+  }
+  return normalized.value;
+}, BrowserActionSchema);
 var SnapshotRequestSchema = z2.object({
   pageId: BoundedString(200).optional(),
   frameId: BoundedString(200).optional(),
@@ -2113,6 +2201,7 @@ var SnapshotRequestSchema = z2.object({
 var NavigateRequestSchema = z2.object({
   url: HttpUrl(8e3),
   pageId: BoundedString(200).optional(),
+  includeSnapshot: z2.boolean().optional(),
   newTab: z2.boolean().optional(),
   new_tab: z2.boolean().optional(),
   waitUntil: z2.enum(["load", "domcontentloaded", "networkidle0", "networkidle2"]).optional(),
@@ -2230,7 +2319,7 @@ var WaitForHumanRequestSchema = z2.object({ timeoutMs: z2.number().int().min(500
 var KeyRequestSchema = z2.object({ keys: z2.array(BoundedString(100)).min(1).max(32), ...PageInput }).strict();
 var ScrollRequestSchema = z2.object({ direction: z2.enum(["up", "down", "left", "right"]).default("down"), amount: z2.number().finite().min(1).max(1e5).default(600), ...PageInput }).strict();
 var ScrollToBottomRequestSchema = z2.object({ maxScrolls: z2.number().int().min(1).max(50).optional(), timeoutMs: z2.number().int().min(100).max(12e4).optional(), restoreTop: z2.boolean().optional(), ...PageInput }).strict();
-var ExtractRequestSchema = z2.object({ selector: BoundedString(2e3).optional(), query: BoundedString(4e3).optional(), includeLinks: z2.boolean().optional(), maxChars: z2.number().int().min(100).max(8e3).optional(), ...PageInput }).strict().superRefine((input, context) => {
+var ExtractRequestSchema = z2.object({ selector: BoundedString(2e3).optional(), query: BoundedString(4e3).optional(), includeLinks: z2.boolean().optional(), offset: z2.number().int().min(0).max(1e6).optional(), maxChars: z2.number().int().min(100).max(8e3).optional(), ...PageInput }).strict().superRefine((input, context) => {
   if (input.selector !== void 0 && input.query !== void 0) {
     context.addIssue({ code: "custom", message: "Provide selector or query, not both." });
   }
@@ -2301,8 +2390,9 @@ var StorageRequestSchema = z2.object({
   }
 });
 var BatchRequestSchema = z2.object({
-  actions: z2.array(BrowserActionSchema).min(1).max(50).superRefine(validateActionPlan),
-  confirmDestructive: z2.boolean().optional()
+  actions: z2.array(BrowserActionInputSchema).min(1).max(50).superRefine(validateActionPlan),
+  confirmDestructive: z2.boolean().optional(),
+  includeSnapshot: z2.boolean().optional()
 }).strict().superRefine((input, context) => {
   if (!input.confirmDestructive && input.actions.some((action) => isDestructiveBatchAction(action.action))) {
     context.addIssue({ code: "custom", message: "This batch contains destructive actions. Set confirmDestructive=true to execute them." });
@@ -2326,7 +2416,7 @@ function validateActionPlan(actions, context) {
     }
   }
 }
-var BrowserActionPlanSchema = z2.array(BrowserActionSchema).min(1).max(100).superRefine(validateActionPlan);
+var BrowserActionPlanSchema = z2.array(BrowserActionInputSchema).min(1).max(100).superRefine(validateActionPlan);
 var DESTRUCTIVE_BATCH_ACTIONS = /* @__PURE__ */ new Set([
   "close_tab",
   "close_browser",
@@ -2352,10 +2442,11 @@ init_errors();
 init_logger();
 
 // src/server/version.ts
-var SERVER_VERSION = "2.3.0";
+var SERVER_VERSION = "2.4.0";
 
 // src/server/mcp.ts
 var EmptyInputSchema = z3.object({}).strict();
+var ActionEmptyInputSchema = z3.object({ includeSnapshot: z3.boolean().optional() }).strict();
 var MCP_OUTPUT_MAX_BYTES = 28e3;
 var MCP_IMAGE_MAX_BYTES = 8e6;
 var MCP_OUTPUT_TEXT_MAX_BYTES = 2e4;
@@ -2396,6 +2487,7 @@ var PageQuerySchema = z3.object({
 }).strict();
 var PageNextSchema = z3.object({
   offset: z3.number().int().min(0).max(1e6).default(0),
+  revision: z3.number().int().min(0).max(1e9).optional(),
   maxChars: z3.number().int().min(100).max(MCP_PAGE_TEXT_MAX_CHARS).optional(),
   pageId: z3.string().trim().min(1).max(200).optional(),
   frameId: z3.string().trim().min(1).max(200).optional()
@@ -2466,7 +2558,8 @@ var BrowserUseTypeSchema = z3.object({
   text: z3.string().max(2e4),
   pageId: z3.string().trim().min(1).max(200).optional(),
   snapshotId: z3.string().trim().min(1).max(200).optional(),
-  frameId: z3.string().trim().min(1).max(200).optional()
+  frameId: z3.string().trim().min(1).max(200).optional(),
+  includeSnapshot: z3.boolean().optional()
 }).strict();
 var BrowserUseExtractSchema = z3.object({
   query: z3.string().trim().min(1).max(4e3),
@@ -2567,7 +2660,7 @@ function registerBrowserTools(server, runtime) {
       inputSchema: BrowserUseTypeSchema,
       annotations: BROWSER_MUTATING
     },
-    async (input, ctx) => callVisualTool(() => runtime.run({ action: "input", index: input.index, text: input.text, pageId: input.pageId, snapshotId: input.snapshotId, frameId: input.frameId }, ctx.mcpReq.signal), runtime)
+    async (input, ctx) => callVisualTool(() => runtime.run({ action: "input", index: input.index, text: input.text, pageId: input.pageId, snapshotId: input.snapshotId, frameId: input.frameId, includeSnapshot: input.includeSnapshot }, ctx.mcpReq.signal), runtime)
   );
   server.registerTool(
     "browser_get_html",
@@ -2589,25 +2682,25 @@ function registerBrowserTools(server, runtime) {
     },
     async (input, ctx) => callTool2(() => runtime.run({ action: "extract", query: input.query, includeLinks: input.extract_links, pageId: input.pageId, frameId: input.frameId, maxChars: MCP_PAGE_TEXT_MAX_CHARS }, ctx.mcpReq.signal), runtime)
   );
-  registerAction(server, runtime, "browser_navigate", "Navigate the browser", "Open an HTTP(S) URL after domain and private-network policy validation. DNS is checked before navigation but the browser resolver is not pinned.", NavigateRequestSchema, "navigate", (input) => {
+  registerAction(server, runtime, "browser_navigate", "Navigate the browser", "Open an HTTP(S) URL after domain and private-network policy validation. DNS is checked before navigation but the browser resolver is not pinned. Set includeSnapshot=true for one trailing snapshot.", NavigateRequestSchema, "navigate", (input) => {
     const { new_tab, ...fields } = input;
     return { ...fields, newTab: fields.newTab ?? new_tab };
   });
-  registerAction(server, runtime, "browser_click", "Click an element", "Click a current snapshot ref (including browser-use ref:'e5' or 'e5'), CSS selector, exact visible text, or viewport coordinates.", ClickRequestSchema, "click", (input) => {
+  registerAction(server, runtime, "browser_click", "Click an element", "Click a current snapshot ref (including browser-use ref:'e5' or 'e5'), CSS selector, exact visible text, or viewport coordinates. Set includeSnapshot=true for one trailing snapshot.", ClickRequestSchema, "click", (input) => {
     const { coordinate_x, coordinate_y, new_tab, ref, ...fields } = input;
     return { ...fields, target: fields.target ?? ref, coordinateX: fields.coordinateX ?? coordinate_x, coordinateY: fields.coordinateY ?? coordinate_y, newTab: fields.newTab ?? new_tab };
   });
-  registerAction(server, runtime, "browser_input", "Enter text", "Replace the current value and type text into an input or textarea. Accepts a current snapshot ref, CSS selector, or index.", InputRequestSchema, "input");
-  registerAction(server, runtime, "browser_select", "Select an option", "Select an option in a native HTML select element.", SelectRequestSchema, "select_dropdown");
-  registerAction(server, runtime, "browser_scroll", "Scroll the page", "Scroll the current page by a bounded amount.", ScrollRequestSchema, "scroll");
+  registerAction(server, runtime, "browser_input", "Enter text", "Replace the current value and type text into an input or textarea. Accepts a current snapshot ref, CSS selector, or index. Set includeSnapshot=true for one trailing snapshot.", InputRequestSchema, "input");
+  registerAction(server, runtime, "browser_select", "Select an option", "Select an option in a native HTML select element. Set includeSnapshot=true for one trailing snapshot.", SelectRequestSchema, "select_dropdown");
+  registerAction(server, runtime, "browser_scroll", "Scroll the page", "Scroll the current page by a bounded amount. Set includeSnapshot=true for one trailing snapshot.", ScrollRequestSchema, "scroll");
   registerAction(server, runtime, "browser_scroll_to_bottom", "Scroll to the bottom", "Scroll repeatedly to the document bottom, allowing bounded lazy-loaded content to settle.", ScrollToBottomRequestSchema, "scroll_to_bottom");
-  registerAction(server, runtime, "browser_key", "Send keyboard keys", "Send bounded keyboard keys or modifier combinations to the current page.", KeyRequestSchema, "send_keys");
+  registerAction(server, runtime, "browser_key", "Send keyboard keys", "Send bounded keyboard keys or modifier combinations to the current page. Set includeSnapshot=true for one trailing snapshot.", KeyRequestSchema, "send_keys");
   registerAction(server, runtime, "browser_switch_tab", "Switch browser tab", "Make a connected tab the active target.", TabRequestSchema, "switch_tab", (input) => ({ pageId: input.pageId ?? input.tab_id }));
   registerAction(server, runtime, "browser_close_tab", "Close browser tab", "Close a connected browser tab by its stable pageId.", TabRequestSchema, "close_tab", (input) => ({ pageId: input.pageId ?? input.tab_id }));
-  registerAction(server, runtime, "browser_back", "Go back", "Navigate the current tab one history entry backward.", EmptyInputSchema, "go_back");
-  registerAction(server, runtime, "browser_go_back", "Go back", "Browser-use-compatible alias for browser_back.", EmptyInputSchema, "go_back");
-  registerAction(server, runtime, "browser_forward", "Go forward", "Navigate the current tab one history entry forward.", EmptyInputSchema, "go_forward");
-  registerAction(server, runtime, "browser_reload", "Reload the page", "Reload the current tab and re-apply navigation policy to the final URL.", EmptyInputSchema, "reload");
+  registerAction(server, runtime, "browser_back", "Go back", "Navigate the current tab one history entry backward. Optionally return a trailing snapshot.", ActionEmptyInputSchema, "go_back");
+  registerAction(server, runtime, "browser_go_back", "Go back", "Browser-use-compatible alias for browser_back. Optionally return a trailing snapshot.", ActionEmptyInputSchema, "go_back");
+  registerAction(server, runtime, "browser_forward", "Go forward", "Navigate the current tab one history entry forward. Optionally return a trailing snapshot.", ActionEmptyInputSchema, "go_forward");
+  registerAction(server, runtime, "browser_reload", "Reload the page", "Reload the current tab and re-apply navigation policy to the final URL. Optionally return a trailing snapshot.", ActionEmptyInputSchema, "reload");
   registerAction(server, runtime, "browser_close", "Close browser connection", "Close an owned browser or detach from an externally connected browser without closing the user's browser.", EmptyInputSchema, "close_browser", void 0, BROWSER_DESTRUCTIVE);
   registerAction(server, runtime, "browser_close_all", "Close browser connection", "Browser-use-compatible alias for browser_close.", EmptyInputSchema, "close_browser", void 0, BROWSER_DESTRUCTIVE);
   registerAction(server, runtime, "browser_wait", "Wait", "Wait for a bounded period while remaining cancellable.", WaitRequestSchema, "wait");
@@ -2626,7 +2719,7 @@ function registerBrowserTools(server, runtime) {
     async (input, ctx) => callTool2(() => runtime.run({ action: consoleAction(input.operation), pageId: input.pageId }, ctx.mcpReq.signal), runtime)
   );
   registerAction(server, runtime, "browser_find_text", "Find text", "Find and center the first matching text on the page.", PageQuerySchema, "find_text", (input) => ({ ...input, text: input.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 the explicit truncated flag and use browser_page_next for later slices.", ExtractRequestSchema, "extract", (input) => ({ ...input, maxChars: input.maxChars ?? MCP_PAGE_TEXT_MAX_CHARS }));
+  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_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;
@@ -2635,7 +2728,7 @@ function registerBrowserTools(server, runtime) {
   registerAction(server, runtime, "browser_pdf", "Save the page as PDF", "Save a rendered PDF inside an allowed server file root. The output path is atomically replaced when it already exists; confirm this destructive write before using it in a batch.", PdfRequestSchema, "save_as_pdf", void 0, BROWSER_DESTRUCTIVE);
   registerAction(server, runtime, "browser_downloads", "List downloads", "List files in the server download directory.", EmptyInputSchema, "list_downloads");
   registerAction(server, runtime, "browser_dropdown_options", "Read dropdown options", "Read native select options and their selected states.", SelectorRequestSchema, "dropdown_options");
-  registerAction(server, runtime, "browser_page_next", "Read the next page slice", "Read at most 8,000 characters from the current page at offset. Advance offset only when hasMore is true; page text is untrusted.", PageNextSchema, "page_next", (input) => ({ ...input, maxChars: input.maxChars ?? MCP_PAGE_TEXT_MAX_CHARS }));
+  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_interactive", "List interactive elements", "List visible links, buttons, inputs, and other interactive elements with stable refs.", EmptyInputSchema, "list_interactive");
@@ -2656,7 +2749,7 @@ function registerBrowserTools(server, runtime) {
       inputSchema: BrowserExecRequestSchema,
       annotations: BROWSER_DESTRUCTIVE
     },
-    async (input, ctx) => callVisualTool(() => runtime.run({ action: "run_script", script: input.code, confirmDestructive: input.confirmDestructive }, ctx.mcpReq.signal), runtime)
+    async (input, ctx) => callBatchTool(() => runtime.runBatch(parseBrowserExecCode(input.code), { confirmDestructive: input.confirmDestructive }, ctx.mcpReq.signal), runtime)
   );
   server.registerTool(
     "browser_batch",
@@ -2666,7 +2759,7 @@ function registerBrowserTools(server, runtime) {
       inputSchema: BatchRequestSchema,
       annotations: BROWSER_DESTRUCTIVE
     },
-    async (input, ctx) => callVisualTool(() => runtime.run({ action: "run_script", script: JSON.stringify(input.actions), confirmDestructive: input.confirmDestructive }, ctx.mcpReq.signal), runtime)
+    async (input, ctx) => callBatchTool(() => runtime.runBatch(input.actions, { confirmDestructive: input.confirmDestructive, includeSnapshot: input.includeSnapshot }, ctx.mcpReq.signal), runtime)
   );
   server.registerTool(
     "browser_dialog",
@@ -2899,7 +2992,7 @@ async function safeResourceRead(operation, runtime) {
     return await operation();
   } catch (error) {
     runtime?.logger.warn("MCP resource operation failed", safeErrorDiagnostic(error));
-    const normalized = error instanceof AppError ? error : new AppError("RESOURCE_READ_FAILED", "The requested MCP resource could not be read.", { cause: error });
+    const normalized = error instanceof AppError ? error : new AppError("RESOURCE_READ_FAILED", "The requested MCP resource could not be read.", { status: 500, cause: error });
     throw new AppError(normalized.code, truncateMcpText(normalized.message, MCP_ERROR_MESSAGE_MAX_BYTES).value, {
       retryable: normalized.retryable,
       status: normalized.status,
@@ -2919,9 +3012,82 @@ function jsonByteLength(value) {
     return Number.POSITIVE_INFINITY;
   }
 }
+function boundErrorDetails(value) {
+  const safe = redactValue(value);
+  if (jsonByteLength(safe) <= MCP_ERROR_DETAILS_MAX_BYTES) {
+    return safe;
+  }
+  if (!isRecord2(safe)) {
+    return { truncated: true, mcpOutputTruncated: true, warning: "Error details were omitted because they exceeded the MCP response budget." };
+  }
+  const bounded = {};
+  const copyScalar = (key) => {
+    const item = safe[key];
+    if (typeof item === "string") {
+      bounded[key] = truncateUtf8(item, 1e3);
+    } else if (typeof item === "number" || typeof item === "boolean" || item === null) {
+      bounded[key] = item;
+    }
+  };
+  for (const key of ["failedIndex", "failedAction", "completedActions", "hint", "resultsTruncated", "omittedResults"]) {
+    copyScalar(key);
+  }
+  const sourceResults = Array.isArray(safe.completedResults) ? safe.completedResults : void 0;
+  if (sourceResults) {
+    const retained = [];
+    for (const item of sourceResults) {
+      const boundedItem = typeof item === "string" ? truncateMcpText(item, 1e3).value : boundMcpOutput(item);
+      const candidate = { ...bounded, completedResults: [...retained, boundedItem] };
+      if (jsonByteLength(candidate) > MCP_ERROR_DETAILS_MAX_BYTES - 256) {
+        break;
+      }
+      retained.push(boundedItem);
+    }
+    bounded.completedResults = retained;
+    if (retained.length < sourceResults.length) {
+      bounded.resultsTruncated = true;
+      bounded.omittedResults = sourceResults.length - retained.length;
+    }
+  }
+  if (isRecord2(safe.batch)) {
+    const batch = {};
+    for (const key of ["failedIndex", "failedAction", "completedActions"]) {
+      const item = safe.batch[key];
+      if (typeof item === "string" || typeof item === "number" || typeof item === "boolean" || item === null) {
+        batch[key] = typeof item === "string" ? truncateUtf8(item, 1e3) : item;
+      }
+    }
+    bounded.batch = batch;
+  }
+  if (jsonByteLength(bounded) <= MCP_ERROR_DETAILS_MAX_BYTES) {
+    return bounded;
+  }
+  delete bounded.batch;
+  while (jsonByteLength(bounded) > MCP_ERROR_DETAILS_MAX_BYTES && Array.isArray(bounded.completedResults) && bounded.completedResults.length > 0) {
+    bounded.completedResults = bounded.completedResults.slice(0, -1);
+    bounded.resultsTruncated = true;
+    bounded.omittedResults = sourceResults ? sourceResults.length - bounded.completedResults.length : void 0;
+  }
+  return jsonByteLength(bounded) <= MCP_ERROR_DETAILS_MAX_BYTES ? bounded : { truncated: true, mcpOutputTruncated: true, warning: "Error details were omitted because they exceeded the MCP response budget." };
+}
 function jsonText(value) {
   return JSON.stringify(value) ?? "null";
 }
+function parseBrowserExecCode(code) {
+  let parsed;
+  try {
+    parsed = JSON.parse(code);
+  } catch (error) {
+    throw new AppError("SCRIPT_INVALID", "code must be a JSON array of validated browser actions.", { cause: error });
+  }
+  const result = BrowserActionPlanSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new AppError("SCRIPT_INVALID", "code must be a non-empty JSON array of validated browser actions.", {
+      details: { issues: result.error.issues.map((issue) => ({ path: issue.path, message: issue.message })) }
+    });
+  }
+  return result.data;
+}
 function truncateUtf8(value, maxBytes) {
   const bytes = UTF8_ENCODER.encode(value);
   if (bytes.byteLength <= maxBytes) {
@@ -2992,7 +3158,7 @@ function boundMcpArray(value) {
     warning: "The MCP result exceeded the client record budget; use a narrower selector or a paginated tool."
   };
 }
-function boundMcpOutput(value) {
+function boundMcpOutput(value, options = {}) {
   if (typeof value === "string") {
     return truncateMcpText(value, MCP_OUTPUT_MAX_BYTES).value;
   }
@@ -3002,7 +3168,7 @@ function boundMcpOutput(value) {
   if (!isRecord2(value)) {
     return value;
   }
-  const output = { ...value };
+  let output = { ...value };
   const markOutputTruncated = () => {
     output.mcpOutputTruncated = true;
   };
@@ -3032,7 +3198,9 @@ function boundMcpOutput(value) {
     output.truncated = true;
   }
   capArray("links", MCP_OUTPUT_LINK_LIMIT, "linksTruncated");
-  capArray("results", MCP_OUTPUT_RESULT_LIMIT, "resultsTruncated");
+  if (!options.preserveBatchResults) {
+    capArray("results", MCP_OUTPUT_RESULT_LIMIT, "resultsTruncated");
+  }
   capArray("entries", MCP_OUTPUT_ENTRY_LIMIT, "entriesTruncated");
   capArray("interactive", MCP_OUTPUT_INTERACTIVE_LIMIT, "interactiveTruncated");
   capArray("nodes", MCP_OUTPUT_NODE_LIMIT, "nodesTruncated");
@@ -3066,6 +3234,28 @@ function boundMcpOutput(value) {
   if (jsonByteLength(output) <= MCP_OUTPUT_MAX_BYTES) {
     return output;
   }
+  if (options.preserveBatchResults && Array.isArray(output.results)) {
+    const allResults = output.results;
+    const base = { ...output };
+    delete base.results;
+    const retained = [];
+    for (const item of allResults) {
+      const candidate = { ...base, results: [...retained, item] };
+      if (jsonByteLength(candidate) > MCP_OUTPUT_MAX_BYTES - 256) {
+        break;
+      }
+      retained.push(item);
+    }
+    output = {
+      ...base,
+      results: retained,
+      ...retained.length < allResults.length ? { resultsTruncated: true, omittedResults: allResults.length - retained.length } : {},
+      ...retained.length < allResults.length ? { mcpOutputTruncated: true } : {}
+    };
+    if (jsonByteLength(output) <= MCP_OUTPUT_MAX_BYTES) {
+      return output;
+    }
+  }
   for (const key of ["text", "html"]) {
     while (jsonByteLength(output) > MCP_OUTPUT_MAX_BYTES && typeof output[key] === "string" && UTF8_ENCODER.encode(output[key]).byteLength > 4e3) {
       const current = output[key];
@@ -3075,7 +3265,11 @@ function boundMcpOutput(value) {
       markOutputTruncated();
     }
   }
-  for (const [key, flag] of [["links", "linksTruncated"], ["results", "resultsTruncated"], ["entries", "entriesTruncated"], ["interactive", "interactiveTruncated"], ["nodes", "nodesTruncated"], ["matches", "matchesTruncated"], ["frames", "framesTruncated"]]) {
+  const arrayBounds = [["links", "linksTruncated"], ["entries", "entriesTruncated"], ["interactive", "interactiveTruncated"], ["nodes", "nodesTruncated"], ["matches", "matchesTruncated"], ["frames", "framesTruncated"]];
+  if (!options.preserveBatchResults) {
+    arrayBounds.push(["results", "resultsTruncated"]);
+  }
+  for (const [key, flag] of arrayBounds) {
     while (jsonByteLength(output) > MCP_OUTPUT_MAX_BYTES && Array.isArray(output[key]) && output[key].length > 1) {
       output[key] = output[key].slice(0, Math.max(1, Math.floor(output[key].length / 2)));
       output[flag] = true;
@@ -3086,7 +3280,7 @@ function boundMcpOutput(value) {
     return output;
   }
   const preserved = {};
-  for (const key of ["pageId", "frameId", "snapshotId", "domRevision", "url", "title", "selector", "query", "offset", "hasMore"]) {
+  for (const key of ["pageId", "frameId", "snapshotId", "domRevision", "url", "untrustedUrl", "title", "selector", "query", "offset", "nextOffset", "revision", "hasMore", "totalMatches", "matchesTruncated", "resultsTruncated", "omittedResults"]) {
     const item = output[key];
     if (typeof item === "string") {
       preserved[key] = truncateUtf8(item, 1e3);
@@ -3102,10 +3296,10 @@ function boundMcpOutput(value) {
     warning: "The MCP result exceeded the client record budget; use a narrower selector or a paginated tool."
   };
 }
-function sanitizeMcpOutput(value) {
-  const bounded = boundMcpOutput(value);
+function sanitizeMcpOutput(value, options = {}) {
+  const bounded = boundMcpOutput(value, options);
   const redacted = redactValue(bounded);
-  return jsonByteLength(redacted) > MCP_OUTPUT_MAX_BYTES ? boundMcpOutput(redacted) : redacted;
+  return jsonByteLength(redacted) > MCP_OUTPUT_MAX_BYTES ? boundMcpOutput(redacted, options) : redacted;
 }
 async function callTool2(operation, logger) {
   return boundToolError(await callTool(
@@ -3113,6 +3307,14 @@ async function callTool2(operation, logger) {
     (error) => logger?.logger.warn("MCP tool operation failed", safeErrorDiagnostic(error))
   ));
 }
+async function callBatchTool(operation, logger) {
+  try {
+    return toolResult(sanitizeMcpOutput(await operation(), { preserveBatchResults: true }) ?? null);
+  } catch (error) {
+    logger?.logger.warn("MCP batch operation failed", safeErrorDiagnostic(error));
+    return boundToolError(toolError(error));
+  }
+}
 async function callVisualTool(operation, logger) {
   try {
     const rawValue = await operation();
@@ -3158,12 +3360,7 @@ function boundToolError(result) {
     retryable: rawError.retryable === true
   };
   if (rawError.details !== void 0) {
-    const details = sanitizeMcpOutput(rawError.details);
-    error.details = jsonByteLength(details) <= MCP_ERROR_DETAILS_MAX_BYTES ? details : {
-      truncated: true,
-      mcpOutputTruncated: true,
-      warning: "Error details were omitted because they exceeded the MCP response budget."
-    };
+    error.details = boundErrorDetails(rawError.details);
   }
   const payload = { ok: false, error };
   return {
@@ -3177,18 +3374,18 @@ function boundToolError(result) {
 init_logger();
 
 // src/server/runtime.ts
-import { chmod, lstat as lstat2, mkdir as mkdir2, open, readFile as readFile2, realpath as realpath2, rename as rename2, unlink as unlink2 } from "node:fs/promises";
+import { chmod, lstat as lstat2, mkdir as mkdir2, open as open2, readFile as readFile2, realpath as realpath2, rename as rename2, unlink as unlink2 } from "node:fs/promises";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { basename as basename3, dirname as dirname3, join as join5, resolve as resolve4 } from "node:path";
 import process3 from "node:process";
 
 // src/server/browser/service.ts
 init_errors();
-import { access, lstat, mkdir, readFile, readdir, realpath, rename, stat, unlink } from "node:fs/promises";
+import { lstat, mkdir, open, readFile, readdir, realpath, rename, stat, unlink } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
 import { basename, dirname, extname, isAbsolute, join as join3, relative, resolve as resolve2, sep } from "node:path";
 import { randomUUID } from "node:crypto";
 import { platform } from "node:process";
-import puppeteer from "puppeteer-core";
 init_logger();
 
 // src/server/security.ts
@@ -3438,6 +3635,11 @@ function globMatches(value, glob) {
 }
 
 // src/server/browser/service.ts
+var puppeteerModulePromise;
+function loadPuppeteer() {
+  puppeteerModulePromise ??= import("puppeteer-core").then((module) => module.default);
+  return puppeteerModulePromise;
+}
 var MAX_LOG_ENTRIES = 500;
 var MAX_ACTION_PLAN_STEPS = 100;
 var MAX_QUEUED_OPERATIONS = 64;
@@ -3499,6 +3701,28 @@ var CHALLENGE_BLOCKED_ACTIONS = /* @__PURE__ */ new Set([
   "set_storage",
   "clear_storage"
 ]);
+var SNAPSHOT_AFTER_ACTIONS = /* @__PURE__ */ new Set([
+  "navigate",
+  "click",
+  "input",
+  "select_dropdown",
+  "scroll",
+  "send_keys",
+  "go_back",
+  "go_forward",
+  "reload"
+]);
+var DOM_MUTATING_ACTIONS = /* @__PURE__ */ new Set([
+  "click",
+  "input",
+  "select_dropdown",
+  "scroll",
+  "scroll_to_bottom",
+  "send_keys",
+  "upload_file",
+  "set_storage",
+  "clear_storage"
+]);
 var BrowserService = class {
   constructor(config, policy, logger, dependencies = {}) {
     this.config = config;
@@ -3522,24 +3746,31 @@ var BrowserService = class {
   browserClosePromise;
   connectionSettlementPromise;
   interruptedBrowserShutdown;
+  failedBrowserShutdown;
   browserShutdownFailure = false;
+  recoveryRequired = false;
+  recoveryPromise;
   shutdownController = new AbortController();
   activeOperationController;
   currentPageId;
   sessionGeneration = 0;
   states = /* @__PURE__ */ new Map();
+  configuredDownloadContexts = /* @__PURE__ */ new WeakSet();
   ids = /* @__PURE__ */ new WeakMap();
   targetGuardSessions = /* @__PURE__ */ new Map();
   unguardedTargetSessions = /* @__PURE__ */ new Set();
   pendingTargetGuardSessions = /* @__PURE__ */ new Map();
+  pendingTargetGuardInfos = /* @__PURE__ */ new Map();
   targetGuardUnavailable = false;
   targetGuardConnection;
   targetGuardConnectionListener;
   targetGuardRawConnectionListener;
+  targetGuardDetachedListener;
   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;
   async close() {
     if (this.closePromise) {
       return this.closePromise;
@@ -3572,11 +3803,19 @@ var BrowserService = class {
     return { ...browserResult, succeeded: browserResult.succeeded && connectionSettled && lateConnectionSettled && interruptedSucceeded };
   }
   connectionStatus() {
-    return { connected: Boolean(this.browser), owned: this.ownsBrowser, trackedPages: this.states.size, queuedOperations: this.queuedOperations, currentPageId: this.currentPageId ?? null };
+    return {
+      connected: Boolean(this.browser),
+      owned: this.ownsBrowser,
+      trackedPages: this.states.size,
+      queuedOperations: this.queuedOperations,
+      currentPageId: this.currentPageId ?? null,
+      recoveryRequired: this.recoveryRequired,
+      ...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, 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, lastActivityAt: new Date(this.lastActivityAt).toISOString() };
   }
   async doctor() {
     const discovered = this.config.browser.executablePath ? void 0 : findChromeExecutable();
@@ -3607,7 +3846,24 @@ var BrowserService = class {
     }
     this.sessionGeneration += 1;
     this.activeOperationController?.abort();
+    let interruptedCleanupFailed = false;
+    if (this.interruptedBrowserShutdown) {
+      const cleanup = await settleWithTimeout(this.interruptedBrowserShutdown, SHUTDOWN_CONNECTION_SETTLE_TIMEOUT_MS);
+      if (cleanup === void 0) {
+        this.recoveryRequired = true;
+        return { closed: false, session_id: this.sessionId };
+      }
+      if (cleanup === true) {
+        this.interruptedBrowserShutdown = void 0;
+      } else {
+        interruptedCleanupFailed = true;
+      }
+    }
     const result = await this.closeBrowser();
+    if (interruptedCleanupFailed && result.succeeded) {
+      this.interruptedBrowserShutdown = void 0;
+    }
+    this.recoveryRequired = !result.succeeded;
     return { closed: result.closed, session_id: this.sessionId };
   }
   async closeBrowser() {
@@ -3643,14 +3899,17 @@ var BrowserService = class {
     if (this.connectionPromise === pendingConnection) {
       this.connectionPromise = void 0;
     }
-    const browser = this.browser;
-    const owned = this.ownsBrowser;
+    const browser = this.browser ?? this.failedBrowserShutdown?.browser;
+    const owned = this.browser ? this.ownsBrowser : this.failedBrowserShutdown?.owned ?? false;
+    this.failedBrowserShutdown = void 0;
     this.detachTargetGuard();
     this.browser = void 0;
     this.ownsBrowser = false;
     this.retireAllStates();
     if (!browser) {
-      return { closed: false, owned: false, succeeded: !this.browserShutdownFailure };
+      const succeeded2 = !this.browserShutdownFailure;
+      this.recoveryRequired = !succeeded2;
+      return { closed: false, owned: false, succeeded: succeeded2 };
     }
     let succeeded = true;
     if (owned) {
@@ -3666,8 +3925,11 @@ var BrowserService = class {
     }
     if (!succeeded) {
       this.browserShutdownFailure = true;
+      this.failedBrowserShutdown = { browser, owned };
+      this.recoveryRequired = true;
     } else {
       this.browserShutdownFailure = false;
+      this.recoveryRequired = false;
     }
     return { closed: true, owned, succeeded };
   }
@@ -3680,6 +3942,9 @@ var BrowserService = class {
     const browser = await this.ensureBrowser(signal);
     let pages;
     try {
+      if (this.benchmarkCounters) {
+        this.benchmarkCounters.pageEnumerations += 1;
+      }
       pages = await browser.pages();
     } catch (error) {
       if (!this.isCurrentBrowser(browser, generation)) {
@@ -3733,6 +3998,9 @@ var BrowserService = class {
     return this.withOperationLock(options.signal, (signal) => this.snapshotUnlocked({ ...options, signal }), this.config.browser.actionTimeoutMs, this.config.browser.actionTimeoutMs);
   }
   async snapshotUnlocked(options = {}) {
+    if (this.benchmarkCounters) {
+      this.benchmarkCounters.pageEvaluations += 1;
+    }
     throwIfAborted(options.signal);
     this.assertNoPendingDialog(options.pageId);
     const state = await this.pageState(options.pageId, options.signal);
@@ -3848,13 +4116,12 @@ var BrowserService = class {
     throwIfAborted(options.signal);
     const snapshotId = randomUUID();
     let frameId;
-    let screenshot;
-    if (options.includeScreenshot) {
-      screenshot = await this.screenshotBase64(state.page, options.fullPage ?? false, this.config.browser.maxScreenshotBytes, "png", 80, options.maxDimension);
-    }
+    const [title, frames, screenshot] = await Promise.all([
+      frame.title().catch(() => ""),
+      options.includeFrames === "metadata" ? this.listFrames(state) : Promise.resolve(void 0),
+      options.includeScreenshot ? this.screenshotBase64(state.page, options.fullPage ?? false, this.config.browser.maxScreenshotBytes, "png", 80, options.maxDimension) : Promise.resolve(void 0)
+    ]);
     throwIfAborted(options.signal);
-    const title = await frame.title().catch(() => "");
-    const frames = options.includeFrames === "metadata" ? await this.listFrames(state) : void 0;
     const pageUrl = sanitizeUrl(state.page.url());
     this.assertStateLive(state);
     if (state.domRevision !== domRevisionAtStart || isFrameDetached(frame)) {
@@ -3874,6 +4141,11 @@ var BrowserService = class {
       frameId,
       index: element.index
     }]));
+    state.snapshotInteractive = result.interactive.map(({ signature: _signature, ...element }) => ({
+      ...element,
+      text: wrapUntrustedText("interactive_text", redactSecretPlaceholders(element.text), 500),
+      ...element.ariaLabel ? { ariaLabel: wrapUntrustedText("interactive_label", redactSecretPlaceholders(element.ariaLabel), 500) } : {}
+    }));
     return {
       pageId: state.id,
       frameId,
@@ -3884,11 +4156,7 @@ var BrowserService = class {
       text: wrapUntrustedText("page_text", redactSecretPlaceholders(result.text), maxChars),
       textTruncated: result.textTruncated,
       headings: result.headings.map((heading) => wrapUntrustedText("page_heading", redactSecretPlaceholders(heading), 500)),
-      interactive: result.interactive.map(({ signature: _signature, ...element }) => ({
-        ...element,
-        text: wrapUntrustedText("interactive_text", redactSecretPlaceholders(element.text), 500),
-        ...element.ariaLabel ? { ariaLabel: wrapUntrustedText("interactive_label", redactSecretPlaceholders(element.ariaLabel), 500) } : {}
-      })),
+      interactive: state.snapshotInteractive,
       interactiveTruncated: result.interactiveTruncated,
       viewport: result.viewport,
       document: result.document,
@@ -3899,6 +4167,12 @@ var BrowserService = class {
     };
   }
   async execute(action, signal) {
+    if (this.benchmarkCounters) {
+      this.benchmarkCounters.browserOperations += 1;
+    }
+    if (this.recoveryRequired && action.action !== "close_browser") {
+      throw new AppError("BROWSER_RECOVERY_REQUIRED", "Browser recovery is required before browser work can continue. Call browser_close_session and retry.", { retryable: true, details: { hint: "Call browser_close_session and retry after cleanup succeeds." } });
+    }
     if (isDialogAction(action)) {
       const pendingState = this.dialogState(action.pageId);
       if (pendingState?.dialogs.length) {
@@ -3910,7 +4184,50 @@ var BrowserService = class {
     }
     const timeoutMs = action.timeoutMs ?? this.config.browser.actionTimeoutMs;
     const budgetMs = action.action === "wait_for_human" ? timeoutMs + 5e3 : timeoutMs;
-    return this.withOperationLock(signal, (operationSignal) => this.executeUnlocked(action, operationSignal), budgetMs, budgetMs);
+    return this.withOperationLock(signal, async (operationSignal) => {
+      const result = await this.executeUnlocked(action, operationSignal);
+      if (DOM_MUTATING_ACTIONS.has(action.action)) {
+        this.invalidateActionSnapshot(action, result);
+      }
+      if (!action.includeSnapshot || !SNAPSHOT_AFTER_ACTIONS.has(action.action)) {
+        return result;
+      }
+      return this.attachOptionalSnapshot(action, result, operationSignal);
+    }, budgetMs, budgetMs);
+  }
+  invalidateActionSnapshot(action, result) {
+    const record = result && typeof result === "object" && !Array.isArray(result) ? result : void 0;
+    const resultPageId = typeof record?.pageId === "string" ? record.pageId : typeof record?.openedPageId === "string" ? record.openedPageId : action.pageId ?? this.currentPageId;
+    const state = resultPageId ? this.states.get(resultPageId) : void 0;
+    if (!state || state.disposed) {
+      return;
+    }
+    state.domRevision += 1;
+    state.refs.clear();
+    state.snapshotId = void 0;
+    state.snapshotInteractive = void 0;
+  }
+  async attachOptionalSnapshot(action, result, signal) {
+    const record = result && typeof result === "object" && !Array.isArray(result) ? { ...result } : { result };
+    const pageId = typeof record.openedPageId === "string" ? record.openedPageId : typeof record.pageId === "string" ? record.pageId : this.currentPageId;
+    try {
+      record.snapshot = await this.snapshotUnlocked({ pageId, frameId: action.frameId, maxChars: 8e3, signal });
+    } catch (error) {
+      record.snapshot = null;
+      record.snapshotError = boundedSnapshotError(error);
+    }
+    return record;
+  }
+  /** Execute already-normalized actions while holding one browser-operation lock. */
+  async executeBatch(actions, options = {}, signal) {
+    if (this.benchmarkCounters) {
+      this.benchmarkCounters.browserOperations += actions.length;
+    }
+    if (this.recoveryRequired) {
+      throw new AppError("BROWSER_RECOVERY_REQUIRED", "Browser recovery is required before browser work can continue. Call browser_close_session and retry.", { retryable: true, details: { hint: "Call browser_close_session and retry after cleanup succeeds." } });
+    }
+    const actionCount = actions.length;
+    return this.withOperationLock(signal, (operationSignal) => this.executeBatchUnlocked(actions, options, operationSignal), this.config.browser.actionTimeoutMs * Math.max(1, actionCount), this.config.browser.actionTimeoutMs * Math.max(1, actionCount));
   }
   async executeUnlocked(action, signal) {
     if (!isDialogAction(action) && action.action !== "list_tabs" && action.action !== "close_browser") {
@@ -3980,6 +4297,7 @@ var BrowserService = class {
       case "click": {
         const navigationGeneration = this.beginNavigation(state);
         try {
+          let monitor = { navigated: false, urlChanged: false };
           const coordinateX = action.coordinateX ?? action.coordinate_x;
           const coordinateY = action.coordinateY ?? action.coordinate_y;
           const clickInNewTab = action.newTab ?? action.new_tab;
@@ -4011,7 +4329,7 @@ var BrowserService = class {
             if (coordinateTarget) {
               this.assertClickTargetSafe(coordinateTarget);
             }
-            await this.runClickAndMonitor(page, () => page.mouse.click(coordinateX, coordinateY, { button: action.button ?? "left", count: action.clickCount ?? 1 }), signal);
+            monitor = await this.runClickAndMonitor(page, () => page.mouse.click(coordinateX, coordinateY, { button: action.button ?? "left", count: action.clickCount ?? 1 }), signal);
           } else {
             const target = targetForAction(action, "target");
             if (clickInNewTab) {
@@ -4023,10 +4341,10 @@ var BrowserService = class {
                 return opened;
               }
             }
-            await this.clickTarget(state, target, action.button ?? "left", action.clickCount ?? 1, signal, frame);
+            monitor = await this.clickTarget(state, target, action.button ?? "left", action.clickCount ?? 1, signal, frame);
           }
           await this.throwPendingNavigationError(state, signal, navigationGeneration);
-          return { clicked: true, pageId: state.id };
+          return { clicked: true, pageId: state.id, navigated: monitor.navigated, urlChanged: monitor.urlChanged, ...monitor.url ? { url: sanitizeUrl(monitor.url) } : {} };
         } finally {
           if (state.activeNavigationGeneration === navigationGeneration) {
             state.activeNavigationGeneration = void 0;
@@ -4219,15 +4537,8 @@ var BrowserService = class {
       case "wait_for_url": {
         const pattern = requireField(action.url ?? action.value, "url");
         const timeoutMs = action.timeoutMs ?? this.config.browser.actionTimeoutMs;
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() <= deadline) {
-          throwIfAborted(signal);
-          if (globMatches(page.url(), pattern)) {
-            return { url: sanitizeUrl(page.url()) };
-          }
-          await wait(Math.min(100, Math.max(1, deadline - Date.now())), signal);
-        }
-        throw new AppError("WAIT_TIMEOUT", `The URL did not match '${pattern}' within ${timeoutMs}ms.`, { retryable: true });
+        await this.waitForUrlPattern(page, pattern, timeoutMs, signal);
+        return { url: sanitizeUrl(page.url()) };
       }
       case "wait_for_network_idle":
         await page.waitForNetworkIdle({ idleTime: 500, timeout: action.timeoutMs ?? this.config.browser.actionTimeoutMs, signal });
@@ -4239,12 +4550,12 @@ var BrowserService = class {
         state.networkEnabled = false;
         return { enabled: false };
       case "get_network_log":
-        return { entries: state.network.slice(-MAX_LOG_ENTRIES) };
+        return { entries: untrustedLogEntries(state.network.slice(-MAX_LOG_ENTRIES)) };
       case "clear_network_log":
         state.network = [];
         return { cleared: true };
       case "getclear_network_log": {
-        const entries = state.network.slice(-MAX_LOG_ENTRIES);
+        const entries = untrustedLogEntries(state.network.slice(-MAX_LOG_ENTRIES));
         state.network = [];
         return { entries, cleared: true };
       }
@@ -4278,6 +4589,11 @@ var BrowserService = class {
         return { ...match, text: wrapUntrustedText("found_text", redactSecretPlaceholders(match.text), 1e3) };
       }
       case "extract": {
+        if (this.benchmarkCounters) {
+          this.benchmarkCounters.pageEvaluations += 1;
+        }
+        const offset = Math.max(0, Math.floor(action.offset ?? 0));
+        const revision = state.domRevision;
         let selector = action.selector ?? action.target ?? (action.index !== void 0 ? `e${action.index + 1}` : void 0);
         if (!selector && action.query) {
           try {
@@ -4294,65 +4610,66 @@ var BrowserService = class {
         }
         const maxChars = Math.min(action.maxChars ?? 4e4, this.config.browser.maxHtmlChars);
         const resolvedSelector = selector ? await this.selectorFor(state, selector, action.frameId) : void 0;
-        const extracted = resolvedSelector ? await frame.$eval(resolvedSelector, (element, limit) => {
+        const includeLinks = action.includeLinks === true;
+        const extracted = resolvedSelector ? await frame.$eval(resolvedSelector, (element, options) => {
           const fullText = element.textContent ?? "";
-          return { value: fullText.slice(0, limit), truncated: fullText.length > limit };
-        }, maxChars).catch((error) => {
+          const value = fullText.slice(options.start, options.start + options.limit);
+          const links = options.includeLinks ? [element, ...Array.from(element.querySelectorAll("a"))].slice(0, 100).map((candidate) => {
+            const rawHref = candidate.href;
+            try {
+              const url = new URL(rawHref);
+              if (url.protocol !== "http:" && url.protocol !== "https:") {
+                return void 0;
+              }
+              url.username = "";
+              url.password = "";
+              return { text: (candidate.textContent ?? "").trim().slice(0, 500), href: url.toString() };
+            } catch {
+              return void 0;
+            }
+          }).filter((link) => Boolean(link)) : void 0;
+          return { value, totalLength: fullText.length, truncated: options.start + value.length < fullText.length, links };
+        }, { start: offset, limit: maxChars, includeLinks }).catch((error) => {
           if (isMissingElementError(error)) {
             throw new AppError("ELEMENT_NOT_FOUND", `No element matched '${resolvedSelector}'.`, { cause: error });
           }
           throw normalizeBrowserOperationError(error, signal);
-        }) : await frame.evaluate((limit) => {
+        }) : await frame.evaluate(({ start, limit, includeLinks: includeLinks2 }) => {
           const fullText = document.body?.innerText ?? "";
-          return { value: fullText.slice(0, limit), truncated: fullText.length > limit };
-        }, maxChars);
-        const links = action.includeLinks ? resolvedSelector ? await (async () => {
-          try {
-            return await frame.$eval(resolvedSelector, (container) => {
-              const elements = [container, ...Array.from(container.querySelectorAll("a"))].slice(0, 100);
-              return elements.map((element) => {
-                const rawHref = element.href;
-                try {
-                  const url = new URL(rawHref);
-                  if (url.protocol !== "http:" && url.protocol !== "https:") {
-                    return void 0;
-                  }
-                  url.username = "";
-                  url.password = "";
-                  return { text: (element.textContent ?? "").trim().slice(0, 500), href: url.toString() };
-                } catch {
-                  return void 0;
-                }
-              }).filter((link) => Boolean(link));
-            });
-          } catch (error) {
-            if (isMissingElementError(error)) {
-              throw new AppError("ELEMENT_NOT_FOUND", `No element matched '${resolvedSelector}'.`, { cause: error });
-            }
-            throw normalizeBrowserOperationError(error, signal);
-          }
-        })() : await frame.$$eval("a", (elements) => elements.slice(0, 100).map((element) => {
-          const rawHref = element.href;
-          try {
-            const url = new URL(rawHref);
-            if (url.protocol !== "http:" && url.protocol !== "https:") {
+          const value = fullText.slice(start, start + limit);
+          const links = includeLinks2 ? Array.from(document.querySelectorAll("a")).slice(0, 100).map((candidate) => {
+            const rawHref = candidate.href;
+            try {
+              const url = new URL(rawHref);
+              if (url.protocol !== "http:" && url.protocol !== "https:") {
+                return void 0;
+              }
+              url.username = "";
+              url.password = "";
+              return { text: (candidate.textContent ?? "").trim().slice(0, 500), href: url.toString() };
+            } catch {
               return void 0;
             }
-            url.username = "";
-            url.password = "";
-            return { text: (element.textContent ?? "").trim().slice(0, 500), href: url.toString() };
-          } catch {
-            return void 0;
-          }
-        }).filter((link) => Boolean(link))) : void 0;
+          }).filter((link) => Boolean(link)) : void 0;
+          return { value, totalLength: fullText.length, truncated: start + value.length < fullText.length, links };
+        }, { start: offset, limit: maxChars, includeLinks });
+        if (state.domRevision !== revision) {
+          throw new AppError("STALE_PAGE_SLICE", "The page changed while its text slice was being collected. Retry with a fresh revision.", { retryable: true, details: { hint: "Capture browser_extract again and use its new revision." } });
+        }
+        const nextOffset = offset + extracted.value.length;
         return {
+          offset,
+          nextOffset,
+          hasMore: extracted.truncated,
+          revision,
           text: wrapUntrustedText("extracted_text", redactSecretPlaceholders(extracted.value), maxChars),
           truncated: extracted.truncated,
           textTruncated: extracted.truncated,
-          ...links ? {
-            links: links.map((link) => ({
+          ...extracted.links ? {
+            links: extracted.links.map((link) => ({
               text: wrapUntrustedText("extracted_link_text", redactSecretPlaceholders(link.text), 500),
-              href: sanitizeUrl(link.href)
+              href: sanitizeUrl(link.href),
+              untrustedUrl: wrapUntrustedText("extracted_link_url", redactSecretPlaceholders(link.href), 4096)
             }))
           } : {}
         };
@@ -4419,20 +4736,26 @@ var BrowserService = class {
         throwIfAborted(signal);
         const selector = await this.selectorFor(state, targetForAction(action, "selector"), action.frameId);
         throwIfAborted(signal);
-        const filePath = await this.existingFilePath(requireField(action.filePath, "filePath"));
+        const staged = await this.stageUploadFile(requireField(action.filePath, "filePath"), signal);
         throwIfAborted(signal);
-        const input = await frame.$(selector);
+        let input;
+        try {
+          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(filePath);
-          throwIfAborted(signal);
-          const fileSize = (await stat(filePath)).size;
+          await input.uploadFile(staged.path);
           throwIfAborted(signal);
-          return { uploaded: wrapUntrustedText("uploaded_file_name", redactSecretPlaceholders(basename(filePath)), 512), bytes: Math.min(fileSize, Number.MAX_SAFE_INTEGER) };
+          return { uploaded: wrapUntrustedText("uploaded_file_name", redactSecretPlaceholders(basename(staged.displayName)), 512), bytes: Math.min(staged.size, Number.MAX_SAFE_INTEGER) };
         } finally {
           await input.dispose().catch(() => void 0);
+          await unlinkIfPresent(staged.path);
         }
       }
       case "screenshot": {
@@ -4472,12 +4795,30 @@ var BrowserService = class {
         }));
       }
       case "page_next": {
+        if (this.benchmarkCounters) {
+          this.benchmarkCounters.pageEvaluations += 1;
+        }
         const offset = Math.max(0, Math.floor(action.offset ?? action.amount ?? 0));
+        const revision = action.revision;
+        const revisionAtStart = state.domRevision;
+        if (revision !== void 0 && revision !== revisionAtStart) {
+          throw new AppError("STALE_PAGE_SLICE", "The requested page slice revision is stale. Extract the page again and retry.", { retryable: true, details: { expectedRevision: revisionAtStart, providedRevision: revision, hint: "Capture browser_extract again and use its new revision." } });
+        }
         const maxChars = Math.min(action.maxChars ?? 4e4, this.config.browser.maxHtmlChars);
-        const text = await frame.evaluate(({ start, limit }) => document.body?.innerText.slice(start, start + limit + 1) ?? "", { start: offset, limit: maxChars });
-        return { offset, text: wrapUntrustedText("page_text", text, maxChars), hasMore: text.length > maxChars };
+        const result = await frame.evaluate(({ start, limit }) => {
+          const fullText = document.body?.innerText ?? "";
+          const text = fullText.slice(start, start + limit);
+          return { text, totalLength: fullText.length, hasMore: start + text.length < fullText.length };
+        }, { start: offset, limit: maxChars });
+        if (state.domRevision !== revisionAtStart) {
+          throw new AppError("STALE_PAGE_SLICE", "The page changed while its text slice was being collected. Retry with a fresh revision.", { retryable: true, details: { hint: "Capture browser_extract again and use its new revision." } });
+        }
+        return { offset, nextOffset: offset + result.text.length, hasMore: result.hasMore, revision: revisionAtStart, text: wrapUntrustedText("page_text", redactSecretPlaceholders(result.text), maxChars) };
       }
       case "search_page": {
+        if (this.benchmarkCounters) {
+          this.benchmarkCounters.pageEvaluations += 1;
+        }
         const query = requireField(action.query ?? action.text, "query");
         const matches = await frame.evaluate((needle) => {
           const text = document.body?.innerText ?? "";
@@ -4485,13 +4826,19 @@ var BrowserService = class {
           const target = needle.toLowerCase();
           const output = [];
           let index = lower.indexOf(target);
+          let totalMatches = 0;
           while (index >= 0 && output.length < 20) {
             output.push(text.slice(Math.max(0, index - 120), Math.min(text.length, index + needle.length + 120)));
+            totalMatches += 1;
+            index = lower.indexOf(target, index + target.length);
+          }
+          while (index >= 0) {
+            totalMatches += 1;
             index = lower.indexOf(target, index + target.length);
           }
-          return output;
+          return { matches: output, totalMatches };
         }, query);
-        return { query, matches: matches.map((match) => wrapUntrustedText("page_match", match, 500)) };
+        return { query, matches: matches.matches.map((match) => wrapUntrustedText("page_match", redactSecretPlaceholders(match), 500)), totalMatches: matches.totalMatches, matchesTruncated: matches.totalMatches > matches.matches.length };
       }
       case "find_elements": {
         const selector = targetForAction(action, "selector");
@@ -4515,8 +4862,12 @@ var BrowserService = class {
           omittedAttributes: element.omittedAttributes
         }));
       }
-      case "list_interactive":
+      case "list_interactive": {
+        if (state.snapshotId && state.snapshotInteractive) {
+          return state.snapshotInteractive;
+        }
         return (await this.snapshotUnlocked({ pageId: state.id, maxChars: 1e3, signal })).interactive;
+      }
       case "list_frames":
         return this.listFrames(state);
       case "accessibility_snapshot":
@@ -4533,7 +4884,7 @@ var BrowserService = class {
       case "evaluate": {
         const code = requireField(action.code ?? action.expression, "code");
         const value = await frame.evaluate((source) => (0, eval)(source), code);
-        return redactValue(value);
+        return sanitizeEvaluateResult(value);
       }
       case "hover":
         await frame.hover(await this.selectorFor(state, targetForAction(action, "target"), action.frameId));
@@ -4694,47 +5045,57 @@ var BrowserService = class {
     if (!Array.isArray(parsed) || parsed.length === 0 || parsed.length > MAX_ACTION_PLAN_STEPS) {
       throw new AppError("SCRIPT_INVALID", `The script must be a non-empty JSON array of at most ${MAX_ACTION_PLAN_STEPS} actions.`);
     }
+    const validation = BrowserActionPlanSchema.safeParse(parsed);
+    if (!validation.success) {
+      throw new AppError("SCRIPT_INVALID", "A batch item is not a valid browser action.", {
+        details: { issues: validation.error.issues.map((issue) => ({ path: issue.path, message: issue.message })) }
+      });
+    }
+    return this.executeBatchUnlocked(validation.data, { confirmDestructive }, signal);
+  }
+  async executeBatchUnlocked(actions, options, signal) {
     const results = [];
-    for (const [index, candidate] of parsed.entries()) {
-      const action = this.parseAction(candidate);
+    for (const [index, candidate] of actions.entries()) {
+      const action = candidate;
       if (action.action === "run_script") {
         throw new AppError("SCRIPT_INVALID", "Nested run_script actions are not allowed.");
       }
-      if (action.action === "close_browser" && index !== parsed.length - 1) {
+      if (action.action === "close_browser" && index !== actions.length - 1) {
         throw new AppError("SCRIPT_INVALID", "close_browser must be the final action in a batch.", {
-          details: { batch: { failedIndex: index, completedActions: index, failedAction: action.action } }
+          details: batchFailureDetails(index, action.action, results)
         });
       }
       if (action.action === "screenshot") {
         throw new AppError("SCRIPT_INVALID", "Screenshots must be requested with browser_screenshot so the image is returned as MCP image content.");
       }
-      if (!confirmDestructive && isDestructiveBatchAction(action.action)) {
-        throw new AppError("DESTRUCTIVE_CONFIRMATION_REQUIRED", `Action '${action.action}' must be executed separately or with confirmDestructive=true.`, { retryable: true, details: { batch: { failedIndex: index, completedActions: index, failedAction: action.action } } });
+      if (!options.confirmDestructive && isDestructiveBatchAction(action.action)) {
+        throw new AppError("DESTRUCTIVE_CONFIRMATION_REQUIRED", `Action '${action.action}' must be executed separately or with confirmDestructive=true.`, { retryable: true, details: { hint: "Set confirmDestructive=true or run the action separately.", ...batchFailureDetails(index, action.action, results) } });
       }
       try {
-        results.push(await this.executeUnlocked(action, signal));
+        const result = await this.executeUnlocked({ ...action, includeSnapshot: false }, signal);
+        if (DOM_MUTATING_ACTIONS.has(action.action)) {
+          this.invalidateActionSnapshot(action, result);
+        }
+        results.push(result);
       } catch (error) {
         const normalized = asAppError(normalizeBrowserOperationError(error, signal));
         throw new AppError(normalized.code, normalized.message, {
           retryable: normalized.retryable,
-          details: {
-            ...normalized.details,
-            batch: { failedIndex: index, completedActions: index, failedAction: action.action }
-          },
+          details: { ...normalized.details, ...batchFailureDetails(index, action.action, results) },
           cause: error
         });
       }
     }
-    return { results };
-  }
-  parseAction(value) {
-    const result = BrowserActionSchema.safeParse(value);
-    if (!result.success) {
-      throw new AppError("SCRIPT_INVALID", "A batch item is not a valid browser action.", {
-        details: { issues: result.error.issues.map((issue) => issue.message) }
-      });
+    const output = { results };
+    if (options.includeSnapshot) {
+      try {
+        output.snapshot = await this.snapshotUnlocked({ pageId: this.currentPageId, maxChars: 8e3, signal });
+      } catch (error) {
+        output.snapshot = null;
+        output.snapshotError = boundedSnapshotError(error);
+      }
     }
-    return result.data;
+    return output;
   }
   async ensureBrowser(signal) {
     if (this.shuttingDown) {
@@ -4743,6 +5104,9 @@ var BrowserService = class {
     if (this.config.browser.mode === "disabled") {
       throw new AppError("BROWSER_DISABLED", "Browser control is disabled by configuration.");
     }
+    if (this.recoveryRequired) {
+      throw new AppError("BROWSER_RECOVERY_REQUIRED", "Browser recovery is required before browser work can continue. Call browser_close_session and retry.", { retryable: true, details: { hint: "Call browser_close_session and retry after cleanup succeeds." } });
+    }
     throwIfAborted(signal);
     if (this.browserClosePromise) {
       await awaitWithAbort(this.browserClosePromise, signal);
@@ -4907,11 +5271,17 @@ var BrowserService = class {
       }
     });
   }
-  launch(options) {
-    return (this.dependencies.launch ?? puppeteer.launch)(options);
+  async launch(options) {
+    if (this.dependencies.launch) {
+      return this.dependencies.launch(options);
+    }
+    return (await loadPuppeteer()).launch(options);
   }
-  connect(options) {
-    return (this.dependencies.connect ?? puppeteer.connect)(options);
+  async connect(options) {
+    if (this.dependencies.connect) {
+      return this.dependencies.connect(options);
+    }
+    return (await loadPuppeteer()).connect(options);
   }
   async probeManagedEndpoint() {
     const userDataDir = this.config.browser.userDataDir;
@@ -4948,12 +5318,30 @@ var BrowserService = class {
     }
   }
   async pageState(pageId, signal) {
+    if (this.benchmarkCounters) {
+      this.benchmarkCounters.pageLookups += 1;
+    }
     const generation = this.lifecycleGeneration;
     throwIfAborted(signal);
     const browser = await this.ensureBrowser(signal);
     throwIfAborted(signal);
+    const requestedId = pageId ? this.resolvePageId(pageId) : this.currentPageId;
+    const tracked = requestedId ? this.states.get(requestedId) : void 0;
+    if (tracked && tracked.lifecycleGeneration === generation && !tracked.disposed && !isPageClosed(tracked.page)) {
+      try {
+        await this.configurePage(tracked, signal);
+        this.assertStateLive(tracked);
+        return tracked;
+      } catch (error) {
+        await this.disposeStalePageState(tracked);
+        throw error;
+      }
+    }
     let pages;
     try {
+      if (this.benchmarkCounters) {
+        this.benchmarkCounters.pageEnumerations += 1;
+      }
       pages = await browser.pages();
     } catch (error) {
       if (!this.isCurrentBrowser(browser, generation)) {
@@ -5096,13 +5484,17 @@ var BrowserService = class {
       }
       const session = this.pendingTargetGuardSessions.get(event.sessionId) ?? getCdpSession(targetConnection, event.sessionId);
       this.pendingTargetGuardSessions.delete(event.sessionId);
-      if (!isTopLevelPageTarget(event.targetInfo)) {
+      this.pendingTargetGuardInfos.delete(event.sessionId);
+      if (!isGuardableTarget(event.targetInfo)) {
         return;
       }
       const autoAttached = isAutoAttachedTarget(targetConnection, event.targetInfo.targetId);
       if (autoAttached !== true) {
         if (autoAttached === void 0 && event.sessionId) {
           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 could not determine attachment ownership");
         }
@@ -5110,15 +5502,33 @@ var BrowserService = class {
       }
       if (!session) {
         this.unguardedTargetSessions.add(event.sessionId);
+        if (targetConnection.send) {
+          void targetConnection.send("Target.closeTarget", { targetId: event.targetInfo.targetId }).catch(() => void 0);
+        }
         this.logger.warn("New browser target guard could not find its CDP session");
         return;
       }
-      void this.guardTargetSession(session).catch((error) => {
+      void this.guardTargetSession(session, event.targetInfo).catch((error) => {
         this.logger.warn("New browser target guard failed", { error: String(error) });
       });
     };
+    const detachedListener = (value) => {
+      if (!isRecordValue(value) || typeof value.sessionId !== "string") {
+        return;
+      }
+      const guard = this.targetGuardSessions.get(value.sessionId);
+      if (guard) {
+        guard.released = true;
+        removeCdpListener(guard.session, "Fetch.requestPaused", guard.requestPausedListener);
+        removeCdpListener(guard.session, "disconnected", guard.disconnectedListener);
+        this.targetGuardSessions.delete(value.sessionId);
+      }
+      this.pendingTargetGuardSessions.delete(value.sessionId);
+      this.pendingTargetGuardInfos.delete(value.sessionId);
+    };
     targetConnection.on("sessionattached", sessionListener);
     targetConnection.on("Target.attachedToTarget", rawListener);
+    targetConnection.on("Target.detachedFromTarget", detachedListener);
     const originalEmit = targetConnection.emit;
     if (originalEmit) {
       const wrappedEmit = (event, value) => {
@@ -5139,17 +5549,28 @@ var BrowserService = class {
     this.targetGuardConnection = targetConnection;
     this.targetGuardConnectionListener = sessionListener;
     this.targetGuardRawConnectionListener = rawListener;
+    this.targetGuardDetachedListener = detachedListener;
+    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) });
+      });
+    }
   }
   detachTargetGuard() {
     const connection = this.targetGuardConnection;
     const listener = this.targetGuardConnectionListener;
     const rawListener = this.targetGuardRawConnectionListener;
+    const detachedListener = this.targetGuardDetachedListener;
     if (connection && listener && connection.off) {
       try {
         connection.off("sessionattached", listener);
         if (rawListener) {
           connection.off("Target.attachedToTarget", rawListener);
         }
+        if (detachedListener) {
+          connection.off("Target.detachedFromTarget", detachedListener);
+        }
       } catch {
       }
     }
@@ -5162,26 +5583,31 @@ var BrowserService = class {
     this.targetGuardConnection = void 0;
     this.targetGuardConnectionListener = void 0;
     this.targetGuardRawConnectionListener = void 0;
+    this.targetGuardDetachedListener = void 0;
     this.targetGuardOriginalEmit = void 0;
     this.targetGuardWrappedEmit = void 0;
     this.targetGuardUnavailable = false;
     this.pendingTargetGuardSessions.clear();
+    this.pendingTargetGuardInfos.clear();
     for (const guard of this.targetGuardSessions.values()) {
       guard.released = true;
       removeCdpListener(guard.session, "Fetch.requestPaused", guard.requestPausedListener);
       removeCdpListener(guard.session, "disconnected", guard.disconnectedListener);
+      restoreGuardSend(guard);
       void guard.session.send("Fetch.disable").catch(() => void 0);
     }
     this.targetGuardSessions.clear();
     this.unguardedTargetSessions.clear();
   }
-  async guardTargetSession(session) {
+  async guardTargetSession(session, targetInfo) {
     const sessionId = session.id();
     if (this.targetGuardSessions.has(sessionId) || this.shuttingDown) {
       return;
     }
     const guard = {
       session,
+      targetId: targetInfo?.targetId ?? sessionId,
+      targetType: targetInfo?.type ?? "page",
       requestPausedListener: () => void 0,
       disconnectedListener: () => void 0,
       enabled: false,
@@ -5199,26 +5625,69 @@ var BrowserService = class {
     guard.disconnectedListener = () => {
       removeCdpListener(session, "Fetch.requestPaused", guard.requestPausedListener);
       removeCdpListener(session, "disconnected", guard.disconnectedListener);
+      restoreGuardSend(guard);
       this.targetGuardSessions.delete(sessionId);
       this.unguardedTargetSessions.delete(sessionId);
     };
     this.targetGuardSessions.set(sessionId, guard);
     addCdpListener(session, "Fetch.requestPaused", guard.requestPausedListener);
     addCdpListener(session, "disconnected", guard.disconnectedListener);
+    const sessionWithSend = session;
+    const originalSend = sessionWithSend.send.bind(sessionWithSend);
+    const countedSend = async (method, params) => {
+      if (this.benchmarkCounters) {
+        this.benchmarkCounters.cdpCommands += 1;
+      }
+      return originalSend(method, params);
+    };
+    let releaseDebugger;
+    let rejectDebugger;
+    const debuggerReady = new Promise((resolve6, reject) => {
+      releaseDebugger = resolve6;
+      rejectDebugger = reject;
+    });
+    void debuggerReady.catch(() => void 0);
+    const wrappedSend = async (method, params) => {
+      if (method === "Runtime.runIfWaitingForDebugger") {
+        await debuggerReady;
+      }
+      return countedSend(method, params);
+    };
+    guard.originalSend = originalSend;
+    guard.wrappedSend = wrappedSend;
+    try {
+      if (this.targetGuardConnection?.send) {
+        sessionWithSend.send = wrappedSend;
+      } else {
+        releaseDebugger();
+      }
+    } catch {
+      this.logger.warn("Browser target debugger resume could not be gated");
+    }
     try {
-      await session.send("Fetch.enable", { patterns: [{ urlPattern: "*", requestStage: "Request" }] });
+      await countedSend("Fetch.enable", { patterns: [{ urlPattern: "*", requestStage: "Request" }] });
       guard.enabled = true;
+      releaseDebugger();
     } catch (error) {
+      rejectDebugger(error);
       guard.released = true;
       removeCdpListener(session, "Fetch.requestPaused", guard.requestPausedListener);
       removeCdpListener(session, "disconnected", guard.disconnectedListener);
+      restoreGuardSend(guard);
       this.targetGuardSessions.delete(sessionId);
       this.unguardedTargetSessions.add(sessionId);
-      await session.send("Page.close").catch(() => void 0);
+      await this.closeGuardedTarget(guard);
       this.logger.warn("New browser target could not be guarded", { error: String(error) });
       throw error;
     }
   }
+  async closeGuardedTarget(guard) {
+    const connection = this.targetGuardConnection;
+    if (connection?.send) {
+      await connection.send("Target.closeTarget", { targetId: guard.targetId }).catch(() => void 0);
+    }
+    await guard.session.send("Page.close").catch(() => void 0);
+  }
   async handleTargetGuardRequest(guard, event) {
     if (guard.released || !guard.enabled || !isRecordValue(event)) {
       return;
@@ -5235,8 +5704,10 @@ var BrowserService = class {
     guard.requestIds.add(requestId);
     let allowed = false;
     try {
-      if (requestUrl === "about:blank" || requestUrl.startsWith("data:") || requestUrl.startsWith("blob:")) {
+      if (/^about:blank(?:#.*)?$/i.test(requestUrl)) {
         allowed = true;
+      } else if (requestUrl.startsWith("data:") || requestUrl.startsWith("blob:")) {
+        allowed = guard.targetType === "service_worker" || guard.targetType === "shared_worker";
       } else if (/^wss?:\/\//i.test(requestUrl)) {
         await this.policy.assertNavigationAllowedAsync(requestUrl.replace(/^ws/i, "http"));
         allowed = true;
@@ -5244,7 +5715,7 @@ var BrowserService = class {
         await this.policy.assertNavigationAllowedAsync(requestUrl);
         allowed = true;
       } else if (requestUrl) {
-        allowed = true;
+        allowed = false;
       }
     } catch (error) {
       this.logger.warn("New browser target request blocked", { url: sanitizeUrl(requestUrl), code: error instanceof AppError ? error.code : "URL_BLOCKED" });
@@ -5302,6 +5773,7 @@ var BrowserService = class {
     guard.released = true;
     removeCdpListener(guard.session, "Fetch.requestPaused", guard.requestPausedListener);
     removeCdpListener(guard.session, "disconnected", guard.disconnectedListener);
+    restoreGuardSend(guard);
     this.targetGuardSessions.delete(sessionId);
   }
   async prepareTarget(target) {
@@ -5390,6 +5862,7 @@ var BrowserService = class {
     state.disposed = true;
     this.removePageListeners(state);
     state.refs.clear();
+    state.snapshotInteractive = void 0;
     state.snapshotId = void 0;
     state.dialogs.length = 0;
     state.navigationError = void 0;
@@ -5520,7 +5993,10 @@ var BrowserService = class {
           if (!context.setDownloadBehavior) {
             throw new AppError("DOWNLOAD_CONFIGURATION_FAILED", "The connected browser does not expose context download behavior.");
           }
-          await context.setDownloadBehavior({ policy: "allow", downloadPath });
+          if (!this.configuredDownloadContexts.has(context)) {
+            await context.setDownloadBehavior({ policy: "allow", downloadPath });
+            this.configuredDownloadContexts.add(context);
+          }
           state.downloadConfigured = true;
         } catch {
           const client = await state.page.createCDPSession();
@@ -5578,7 +6054,7 @@ var BrowserService = class {
       mainFrameNavigation = isFrameNavigation && requestFrame === state.page.mainFrame();
       navigationGeneration = mainFrameNavigation ? state.activeNavigationGeneration : void 0;
       requestUrl = request.url();
-      if (requestUrl === "about:blank") {
+      if (/^about:blank(?:#.*)?$/i.test(requestUrl)) {
         await request.continue();
         return;
       }
@@ -5590,14 +6066,12 @@ var BrowserService = class {
         return;
       }
       if (!/^https?:\/\//i.test(requestUrl)) {
-        if (isFrameNavigation) {
-          throw new AppError("URL_BLOCKED", "Non-HTTP browser navigations are disabled by policy.");
-        }
         if (/^wss?:\/\//i.test(requestUrl)) {
           await this.policy.assertNavigationAllowedAsync(requestUrl.replace(/^ws/i, "http"));
+          await request.continue();
+          return;
         }
-        await request.continue();
-        return;
+        throw new AppError("URL_BLOCKED", "Unsupported browser URL schemes are disabled by policy.");
       }
       await this.policy.assertNavigationAllowedAsync(requestUrl);
       await request.continue();
@@ -5705,6 +6179,7 @@ var BrowserService = class {
       state.domRevision += 1;
       state.snapshotId = void 0;
       state.refs.clear();
+      state.snapshotInteractive = void 0;
       try {
         const mainFrame = state.page.mainFrame();
         if (frame === mainFrame && mainFrame.url() !== "about:blank") {
@@ -5723,6 +6198,7 @@ var BrowserService = class {
       state.domRevision += 1;
       state.snapshotId = void 0;
       state.refs.clear();
+      state.snapshotInteractive = void 0;
     };
     state.frameAttachedListener = frameAttachedListener;
     state.page.on("frameattached", frameAttachedListener);
@@ -5733,6 +6209,7 @@ var BrowserService = class {
       state.domRevision += 1;
       state.snapshotId = void 0;
       state.refs.clear();
+      state.snapshotInteractive = void 0;
       FRAME_IDS.delete(frame);
     };
     state.frameDetachedListener = frameDetachedListener;
@@ -5887,6 +6364,7 @@ var BrowserService = class {
       const currentSignature = await frame.$eval(stored.selector, (element) => {
         const htmlElement = element;
         const anchor = element.closest("a");
+        const rect = element.getBoundingClientRect();
         return [
           element.tagName.toLowerCase(),
           element.getAttribute("role") ?? "",
@@ -5894,10 +6372,10 @@ var BrowserService = class {
           htmlElement.type ?? "",
           (htmlElement.innerText || element.getAttribute("value") || element.textContent || "").replace(/\s+/g, " ").trim().slice(0, 500),
           anchor?.href ?? "",
-          Math.round(element.getBoundingClientRect().x),
-          Math.round(element.getBoundingClientRect().y),
-          Math.round(element.getBoundingClientRect().width),
-          Math.round(element.getBoundingClientRect().height)
+          Math.round(rect.x),
+          Math.round(rect.y),
+          Math.round(rect.width),
+          Math.round(rect.height)
         ].join("");
       }).catch(() => void 0);
       if (!currentSignature || currentSignature !== stored.signature) {
@@ -5917,6 +6395,48 @@ var BrowserService = class {
       throw error;
     }
   }
+  async clickSnapshotRef(state, target, frame) {
+    const normalized = target.trim();
+    const ref = normalized.startsWith("ref:") ? normalized.slice(4) : normalized;
+    const stored = state.refs.get(ref);
+    if (!/^e\d+$/.test(ref) || !stored || stored.snapshotId !== state.snapshotId) {
+      throw new AppError("STALE_REFERENCE", `Element reference '${ref}' is stale. Capture a fresh browser snapshot before acting.`, { retryable: true });
+    }
+    const effectiveFrameId = framePath(frame);
+    if (effectiveFrameId !== stored.frameId) {
+      throw new AppError("FRAME_MISMATCH", `Reference '${ref}' belongs to frame '${stored.frameId}', not '${effectiveFrameId}'.`, { retryable: true });
+    }
+    const evaluated = await frame.$eval(stored.selector, (element) => {
+      const clickable = element.closest("a,button,input,select,textarea,[role=button]") ?? element;
+      const htmlElement = clickable;
+      const anchor = clickable.closest("a");
+      const rect = clickable.getBoundingClientRect();
+      return {
+        signature: [
+          element.tagName.toLowerCase(),
+          element.getAttribute("role") ?? "",
+          element.getAttribute("aria-label") ?? "",
+          htmlElement.type ?? "",
+          (htmlElement.innerText || element.getAttribute("value") || element.textContent || "").replace(/\s+/g, " ").trim().slice(0, 500),
+          anchor?.href ?? "",
+          Math.round(rect.x),
+          Math.round(rect.y),
+          Math.round(rect.width),
+          Math.round(rect.height)
+        ].join(""),
+        tag: clickable.tagName.toLowerCase(),
+        type: htmlElement.type?.toLowerCase() ?? "",
+        role: clickable.getAttribute("role") ?? "",
+        label: [clickable.textContent, clickable.getAttribute("aria-label"), clickable.getAttribute("title"), htmlElement.value].filter(Boolean).join(" ").replace(/\s+/g, " ").trim().slice(0, 200),
+        href: anchor?.href ?? clickable.href ?? clickable.getAttribute("href") ?? void 0,
+        rect: { x: rect.x, y: rect.y, width: rect.width, height: rect.height }
+      };
+    }).catch(() => void 0);
+    if (!evaluated || evaluated.signature !== stored.signature) {
+      throw new AppError("STALE_REFERENCE", `Element reference '${ref}' no longer identifies the same element. Capture a fresh browser snapshot before acting.`, { retryable: true });
+    }
+    return { selector: stored.selector, descriptor: evaluated };
+  }
   async openLinkInNewTab(state, target, signal) {
     const browser = await this.ensureBrowser(signal);
     if (this.targetGuardUnavailable) {
@@ -6095,15 +6615,69 @@ var BrowserService = class {
     });
     throwIfAborted(signal);
   }
+  async waitForUrlPattern(page, pattern, timeoutMs, signal) {
+    throwIfAborted(signal);
+    if (globMatches(page.url(), pattern)) {
+      return;
+    }
+    if (typeof page.on !== "function" || typeof page.off !== "function") {
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() <= deadline) {
+        throwIfAborted(signal);
+        if (globMatches(page.url(), pattern)) {
+          return;
+        }
+        await wait(Math.min(100, Math.max(1, deadline - Date.now())), signal);
+      }
+      throw new AppError("WAIT_TIMEOUT", `The URL did not match '${pattern}' within ${timeoutMs}ms.`, { retryable: true });
+    }
+    await new Promise((resolvePromise, reject) => {
+      let settled = false;
+      const cleanup = () => {
+        clearTimeout(timer);
+        page.off("framenavigated", onNavigated);
+        signal?.removeEventListener("abort", onAbort);
+      };
+      const finish = (callback) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        callback();
+      };
+      const onNavigated = () => {
+        try {
+          if (globMatches(page.url(), pattern)) {
+            finish(resolvePromise);
+          }
+        } catch (error) {
+          finish(() => reject(error));
+        }
+      };
+      const onAbort = () => finish(() => reject(new AppError("CANCELLED", "The browser action was cancelled.")));
+      const timer = setTimeout(() => finish(() => reject(new AppError("WAIT_TIMEOUT", `The URL did not match '${pattern}' within ${timeoutMs}ms.`, { retryable: true }))), timeoutMs);
+      page.on("framenavigated", onNavigated);
+      signal?.addEventListener("abort", onAbort, { once: true });
+      onNavigated();
+    });
+  }
   async clickTarget(state, target, button, clickCount, signal, frame = state.page.mainFrame()) {
     let selector;
-    try {
-      selector = await this.selectorFor(state, target, framePath(frame));
-    } catch (error) {
-      if (shouldPropagateTargetError(error)) {
-        throw error;
+    let clickDescriptor;
+    const normalizedTarget = target.trim();
+    const ref = normalizedTarget.startsWith("ref:") ? normalizedTarget.slice(4) : normalizedTarget;
+    if (/^e\d+$/.test(ref)) {
+      const resolved = await this.clickSnapshotRef(state, normalizedTarget, frame);
+      selector = resolved.selector;
+      clickDescriptor = resolved.descriptor;
+    } else {
+      try {
+        selector = await this.selectorFor(state, target, framePath(frame));
+      } catch (error) {
+        if (shouldPropagateTargetError(error)) {
+          throw error;
+        }
+        selector = void 0;
       }
-      selector = void 0;
     }
     if (selector) {
       const resolved = await frame.$(selector);
@@ -6113,36 +6687,31 @@ var BrowserService = class {
       }
     }
     if (selector) {
-      await this.assertClickTargetSafe(await frame.$eval(selector, (element) => {
+      clickDescriptor ??= await frame.$eval(selector, (element) => {
         const clickable = element.closest("a,button,input,select,textarea,[role=button]") ?? element;
         const htmlElement = clickable;
+        const anchor = clickable.closest("a");
         return {
           tag: clickable.tagName.toLowerCase(),
           type: htmlElement.type?.toLowerCase() ?? "",
           role: clickable.getAttribute("role") ?? "",
-          label: [clickable.textContent, clickable.getAttribute("aria-label"), clickable.getAttribute("title"), htmlElement.value].filter(Boolean).join(" ").replace(/\s+/g, " ").trim().slice(0, 200)
+          label: [clickable.textContent, clickable.getAttribute("aria-label"), clickable.getAttribute("title"), htmlElement.value].filter(Boolean).join(" ").replace(/\s+/g, " ").trim().slice(0, 200),
+          href: anchor?.href ?? clickable.href ?? clickable.getAttribute("href") ?? void 0,
+          rect: (() => {
+            const rect = clickable.getBoundingClientRect();
+            return { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
+          })()
         };
-      }));
-      await this.assertElementNavigationAllowed(state, selector, frame);
-      await this.clickElement(state, frame, selector, button, clickCount, signal);
-      return;
+      });
+      this.assertClickTargetSafe(clickDescriptor);
+      if (clickDescriptor.href) {
+        await this.assertNavigationUrl(frame.url() || state.page.url(), clickDescriptor.href);
+      }
+      return this.clickElement(state, frame, selector, button, clickCount, signal);
     }
     if (button !== "left") {
       throw new AppError("INVALID_ACTION", "Exact visible-text clicks support only the left mouse button; use a selector or coordinates for other buttons.");
     }
-    const href = await frame.evaluate((needle) => {
-      const candidates = Array.from(document.querySelectorAll("body *"));
-      const element = candidates.find((candidate) => {
-        const htmlElement = candidate;
-        return (htmlElement.innerText || candidate.textContent || "").trim() === needle;
-      });
-      const clickable = element?.closest("a,button,input,select,textarea,[role=button],[onclick]");
-      const anchor = clickable?.closest("a");
-      return anchor?.href ?? clickable?.getAttribute("href") ?? null;
-    }, target);
-    if (href) {
-      await this.assertNavigationUrl(state.page.url(), href);
-    }
     const targetBox = await frame.evaluate((needle) => {
       const candidates = Array.from(document.querySelectorAll("body *"));
       const element = candidates.find((candidate) => {
@@ -6155,6 +6724,7 @@ var BrowserService = class {
       }
       const rect = clickable.getBoundingClientRect();
       const htmlElement = clickable;
+      const anchor = clickable.closest("a");
       return {
         x: rect.x + rect.width / 2,
         y: rect.y + rect.height / 2,
@@ -6163,18 +6733,23 @@ var BrowserService = class {
         tag: clickable.tagName.toLowerCase(),
         type: htmlElement.type?.toLowerCase() ?? "",
         role: clickable.getAttribute("role") ?? "",
-        label: [clickable.textContent, clickable.getAttribute("aria-label"), clickable.getAttribute("title"), htmlElement.value].filter(Boolean).join(" ").replace(/\s+/g, " ").trim().slice(0, 200)
+        label: [clickable.textContent, clickable.getAttribute("aria-label"), clickable.getAttribute("title"), htmlElement.value].filter(Boolean).join(" ").replace(/\s+/g, " ").trim().slice(0, 200),
+        href: anchor?.href ?? clickable.getAttribute("href") ?? void 0
       };
     }, target);
     if (!targetBox || targetBox.width <= 0 || targetBox.height <= 0) {
       throw new AppError("ELEMENT_NOT_FOUND", `No clickable element matched '${target.slice(0, 200)}'.`);
     }
     this.assertClickTargetSafe(targetBox);
+    if (targetBox.href) {
+      await this.assertNavigationUrl(state.page.url(), targetBox.href);
+    }
     if (frame !== state.page.mainFrame()) {
       throw new AppError("FRAME_ACTION_UNSUPPORTED", "Exact-text clicks in child frames require a selector or snapshot ref.");
     }
-    await this.runClickAndMonitor(state.page, () => state.page.mouse.click(targetBox.x, targetBox.y, { button: "left", count: clickCount }), signal);
+    const monitor = await this.runClickAndMonitor(state.page, () => state.page.mouse.click(targetBox.x, targetBox.y, { button: "left", count: clickCount }), signal);
     await this.throwPendingNavigationError(state, signal);
+    return monitor;
   }
   assertClickTargetSafe(target) {
     if (target.tag === "input" && target.type === "file") {
@@ -6194,33 +6769,35 @@ var BrowserService = class {
       const onDialog = () => {
         dialogObserved = true;
         removeDialogListener?.();
-        resolve6();
+        resolve6(null);
       };
       state.page.on("dialog", onDialog);
       removeDialogListener = () => state.page.off("dialog", onDialog);
     });
     const click = this.runClickAndMonitor(state.page, () => frame.click(selector, { button, count: clickCount }), signal).then(
-      () => false,
+      (result) => result,
       (error) => {
         removeDialogListener?.();
         if (dialogObserved) {
-          return true;
+          return { navigated: false, urlChanged: false };
         }
         throw error;
       }
     );
-    const openedDialog = await Promise.race([click, dialogOpened.then(() => true)]);
+    const openedDialog = await Promise.race([click, dialogOpened]);
     removeDialogListener?.();
-    if (openedDialog) {
+    if (openedDialog === null) {
       void click.catch((error) => {
         this.logger.debug("Browser click completed after dialog resolution", { pageId: state.id, error: String(error) });
       });
       throwIfAborted(signal);
-      return;
+      return { navigated: false, urlChanged: false };
     }
+    return openedDialog;
   }
   async runClickAndMonitor(page, trigger, signal) {
     throwIfAborted(signal);
+    const beforeUrl = typeof page.url === "function" ? page.url() : "";
     let navigated = false;
     const onFrameNavigated = (frame) => {
       try {
@@ -6233,25 +6810,18 @@ var BrowserService = class {
     page.on("framenavigated", onFrameNavigated);
     try {
       await trigger();
-      await wait(150, signal);
+      await wait(50, signal);
       if (navigated) {
         await page.waitForNetworkIdle({ idleTime: 100, timeout: Math.min(this.config.browser.actionTimeoutMs, 1e3), signal }).catch(() => {
           throwIfAborted(signal);
         });
       }
+      const url = typeof page.url === "function" ? page.url() : "";
+      return { navigated, urlChanged: url !== beforeUrl, url };
     } finally {
       page.off("framenavigated", onFrameNavigated);
     }
   }
-  async assertElementNavigationAllowed(state, selector, frame = state.page.mainFrame()) {
-    const href = await frame.$eval(selector, (element) => {
-      const anchor = element.closest("a");
-      return anchor?.href ?? element.href ?? element.getAttribute("href");
-    }).catch(() => void 0);
-    if (href) {
-      await this.assertNavigationUrl(frame.url() || state.page.url(), href);
-    }
-  }
   async assertCurrentPageAllowed(page) {
     const url = page.url();
     if (url === "about:blank") {
@@ -6569,12 +7139,59 @@ var BrowserService = class {
       throw new AppError("DOWNLOADS_UNAVAILABLE", "Downloaded files could not be listed.", { cause: error });
     });
   }
-  async existingFilePath(rawPath) {
+  async stageUploadFile(rawPath, signal) {
     const candidate = this.policy.assertFilePath(rawPath, { mustExist: true });
-    await access(candidate);
-    const resolvedPath = await realpath(candidate);
-    this.policy.assertFilePath(resolvedPath, { mustExist: true });
-    return resolvedPath;
+    const before = await lstat(candidate).catch((error) => {
+      throw new AppError("FILE_PATH_BLOCKED", "The upload source does not exist or cannot be resolved safely.", { cause: error });
+    });
+    if (before.isSymbolicLink()) {
+      throw new AppError("FILE_PATH_BLOCKED", "The upload source must not be a symbolic link.");
+    }
+    const noFollow = typeof fsConstants.O_NOFOLLOW === "number" ? fsConstants.O_NOFOLLOW : 0;
+    let sourceHandle;
+    let stagingPath;
+    try {
+      sourceHandle = await open(candidate, fsConstants.O_RDONLY | noFollow);
+      const opened = await sourceHandle.stat();
+      if (!opened.isFile()) {
+        throw new AppError("FILE_PATH_BLOCKED", "The upload source must be a regular file.");
+      }
+      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 });
+      }
+      throwIfAborted(signal);
+      const stagingDirectory = join3(this.config.dataDir, "upload-staging");
+      await mkdir(stagingDirectory, { recursive: true, mode: 448 });
+      stagingPath = join3(stagingDirectory, `.upload-${randomUUID()}`);
+      const stagingHandle = await open(stagingPath, "wx", 384);
+      try {
+        for await (const chunk of sourceHandle.createReadStream({ autoClose: false })) {
+          throwIfAborted(signal);
+          const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+          let offset = 0;
+          while (offset < buffer.byteLength) {
+            const written = await stagingHandle.write(buffer, offset, buffer.byteLength - offset, null);
+            if (written.bytesWritten <= 0) {
+              throw new AppError("FILE_PATH_BLOCKED", "The upload source could not be staged safely.");
+            }
+            offset += written.bytesWritten;
+          }
+        }
+        await stagingHandle.sync();
+      } finally {
+        await stagingHandle.close().catch(() => void 0);
+      }
+      throwIfAborted(signal);
+      return { path: stagingPath, displayName: basename(candidate), size: opened.size };
+    } catch (error) {
+      if (stagingPath) {
+        await unlinkIfPresent(stagingPath);
+      }
+      throw error instanceof AppError ? error : new AppError("FILE_PATH_BLOCKED", "The upload source could not be staged safely.", { cause: error });
+    } finally {
+      await sourceHandle?.close().catch(() => void 0);
+    }
   }
   async outputFilePath(rawPath) {
     const candidate = this.policy.assertFilePath(rawPath);
@@ -6601,25 +7218,55 @@ var BrowserService = class {
   interruptBrowserOperation() {
     this.lifecycleGeneration += 1;
     this.detachTargetGuard();
+    this.interruptedBrowserShutdown = void 0;
     const browser = this.browser;
     const owned = this.ownsBrowser;
     this.browser = void 0;
     this.ownsBrowser = false;
     this.retireAllStates();
     if (browser) {
+      this.failedBrowserShutdown = { browser, owned };
       this.interruptedBrowserShutdown = closeConnectedBrowser(browser, owned, this.logger);
       void this.interruptedBrowserShutdown.then((succeeded) => {
         if (!succeeded) {
           this.browserShutdownFailure = true;
+          this.recoveryRequired = true;
         } else {
           this.browserShutdownFailure = false;
+          if (this.failedBrowserShutdown?.browser === browser) {
+            this.failedBrowserShutdown = void 0;
+          }
         }
       });
     }
   }
+  async recoverAfterAbort(operationPromise) {
+    if (this.recoveryPromise) {
+      return this.recoveryPromise;
+    }
+    const recovery = (async () => {
+      const settled = await promiseSettledWithin(operationPromise, 250);
+      if (settled) {
+        return;
+      }
+      this.interruptBrowserOperation();
+      const shutdown = this.interruptedBrowserShutdown;
+      const succeeded = shutdown ? await settleWithTimeout(shutdown, SHUTDOWN_CONNECTION_SETTLE_TIMEOUT_MS) : true;
+      if (succeeded !== true) {
+        this.recoveryRequired = true;
+      }
+    })();
+    this.recoveryPromise = recovery;
+    void recovery.finally(() => {
+      if (this.recoveryPromise === recovery) {
+        this.recoveryPromise = void 0;
+      }
+    }).catch(() => void 0);
+    return recovery;
+  }
   async withOperationLock(signal, operation, queueTimeoutMs = this.config.browser.actionTimeoutMs, operationTimeoutMs) {
     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 });
+      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." } });
     }
     this.queuedOperations += 1;
     const requestSessionGeneration = this.sessionGeneration;
@@ -6644,16 +7291,20 @@ var BrowserService = class {
       this.activeOperationController = operationController;
       const operationSignal = combineSignals(queueSignal, operationController.signal) ?? operationController.signal;
       let operationTimedOut = false;
+      let abortRequested = false;
+      let recoveryAfterAbort;
       const operationBudgetMs = operationTimeoutMs === void 0 ? void 0 : Math.max(1, Math.floor(operationTimeoutMs) - Math.max(0, Date.now() - requestStartedAt));
-      let operationSettled = false;
       let removeAbortListener;
       let rejectAbort;
       const abortPromise = new Promise((_, reject) => {
         rejectAbort = reject;
         const onAbort = () => {
+          if (abortRequested) {
+            return;
+          }
+          abortRequested = true;
           const timedOut = operationTimedOut;
           operationController.abort();
-          this.interruptBrowserOperation();
           reject(timedOut ? new AppError("BROWSER_TIMEOUT", `The browser operation exceeded its ${Math.max(1, Math.floor(operationTimeoutMs ?? 0))}ms action deadline.`, { retryable: true, details: { timeoutMs: Math.max(1, Math.floor(operationTimeoutMs ?? 0)) } }) : new AppError("CANCELLED", "The browser action was cancelled."));
         };
         if (queueSignal?.aborted) {
@@ -6666,21 +7317,19 @@ var BrowserService = class {
       const deadlineTimer = operationTimeoutMs === void 0 ? void 0 : setTimeout(() => {
         if (!queueSignal?.aborted) {
           operationTimedOut = true;
-          operationController.abort();
-          this.interruptBrowserOperation();
-          rejectAbort(new AppError("BROWSER_TIMEOUT", `The browser operation exceeded its ${Math.max(1, Math.floor(operationTimeoutMs ?? 0))}ms action deadline.`, { retryable: true, details: { timeoutMs: Math.max(1, Math.floor(operationTimeoutMs ?? 0)) } }));
+          if (!abortRequested) {
+            abortRequested = true;
+            operationController.abort();
+            rejectAbort(new AppError("BROWSER_TIMEOUT", `The browser operation exceeded its ${Math.max(1, Math.floor(operationTimeoutMs ?? 0))}ms action deadline.`, { retryable: true, details: { timeoutMs: Math.max(1, Math.floor(operationTimeoutMs ?? 0)) } }));
+          }
         }
       }, operationBudgetMs);
       this.lastActivityAt = Date.now();
       operationPromise = Promise.resolve().then(() => operation(operationSignal));
-      void operationPromise.then(
-        () => {
-          operationSettled = true;
-        },
-        () => {
-          operationSettled = true;
-        }
-      );
+      void operationPromise.catch(() => void 0);
+      if (abortRequested) {
+        recoveryAfterAbort = this.recoverAfterAbort(operationPromise);
+      }
       try {
         const result = await Promise.race([operationPromise, abortPromise]);
         throwIfAborted(operationSignal);
@@ -6699,9 +7348,11 @@ var BrowserService = class {
         if (this.activeOperationController === operationController) {
           this.activeOperationController = void 0;
         }
-        if (!operationSettled && operationPromise) {
+        if (abortRequested && operationPromise) {
           deferRelease = true;
-          void operationPromise.then(() => release(), () => release());
+          recoveryAfterAbort ??= this.recoverAfterAbort(operationPromise);
+          await recoveryAfterAbort;
+          deferRelease = false;
         }
       }
     } finally {
@@ -6761,6 +7412,30 @@ async function closePageSafely(page) {
   await Promise.resolve().then(() => page.close()).catch(() => void 0);
 }
 async function waitForElementState(frame, selector, state, timeoutMs, signal) {
+  if (typeof frame.waitForFunction === "function") {
+    try {
+      await frame.waitForFunction(
+        (targetSelector, desiredState) => {
+          const element = document.querySelector(targetSelector);
+          const visible = Boolean(element && (() => {
+            const style = window.getComputedStyle(element);
+            const rect = element.getBoundingClientRect();
+            return style.display !== "none" && style.visibility !== "hidden" && Number.parseFloat(style.opacity || "1") > 0 && rect.width > 0 && rect.height > 0;
+          })());
+          return desiredState === "attached" ? Boolean(element) : desiredState === "detached" ? !element : desiredState === "hidden" ? !visible : visible;
+        },
+        { timeout: timeoutMs, signal },
+        selector,
+        state
+      );
+      return;
+    } catch (error) {
+      if (isPuppeteerTimeoutError(error)) {
+        throw new AppError("WAIT_TIMEOUT", `The selector '${selector.slice(0, 200)}' did not become ${state} within ${timeoutMs}ms.`, { retryable: true, cause: error });
+      }
+      throw error;
+    }
+  }
   const deadline = Date.now() + timeoutMs;
   while (true) {
     throwIfAborted(signal);
@@ -6817,6 +7492,43 @@ function normalizeBrowserOperationError(error, signal) {
   }
   return error;
 }
+function batchFailureDetails(failedIndex, failedAction, completedResults) {
+  const boundedResults = [];
+  let bytes = 2;
+  for (const result of completedResults) {
+    let resultBytes = 0;
+    try {
+      resultBytes = new TextEncoder().encode(JSON.stringify(result)).byteLength;
+    } catch {
+      resultBytes = Number.POSITIVE_INFINITY;
+    }
+    if (bytes + resultBytes + (boundedResults.length ? 1 : 0) > 6e3) {
+      break;
+    }
+    boundedResults.push(result);
+    bytes += resultBytes + (boundedResults.length > 1 ? 1 : 0);
+  }
+  return {
+    failedIndex,
+    failedAction,
+    completedActions: failedIndex,
+    completedResults: boundedResults,
+    ...boundedResults.length < completedResults.length ? { resultsTruncated: true, omittedResults: completedResults.length - boundedResults.length } : {},
+    batch: {
+      failedIndex,
+      failedAction,
+      completedActions: failedIndex
+    }
+  };
+}
+function boundedSnapshotError(error) {
+  const normalized = asAppError(error);
+  return {
+    code: normalized.code.slice(0, 200),
+    message: normalized.message.slice(0, 1e3),
+    retryable: normalized.retryable
+  };
+}
 function isPageClosed(page) {
   try {
     return page.isClosed();
@@ -6852,7 +7564,8 @@ function trimLog(entries) {
 function untrustedLogEntries(entries) {
   return entries.map((entry) => ({
     ...entry,
-    ...entry.text ? { text: wrapUntrustedText("browser_log", redactSecretPlaceholders(entry.text), 2e3) } : {}
+    ...entry.text ? { text: wrapUntrustedText("browser_log", redactSecretPlaceholders(entry.text), 2e3) } : {},
+    ...entry.url ? { untrustedUrl: wrapUntrustedText("browser_log_url", redactSecretPlaceholders(entry.url), 4096) } : {}
   }));
 }
 function sanitizeStorageResult(value) {
@@ -6888,6 +7601,19 @@ function sanitizeStorageResult(value) {
   }
   return result;
 }
+function sanitizeEvaluateResult(value) {
+  const redacted = redactValue(value);
+  if (typeof value === "string") {
+    return wrapUntrustedText("evaluate_result", redactSecretPlaceholders(String(redacted)), 2e4);
+  }
+  if (redacted && typeof redacted === "object" && !Array.isArray(redacted)) {
+    const record = { ...redacted };
+    const metadataKey = Object.hasOwn(record, "untrustedSource") ? "__untrustedSource" : "untrustedSource";
+    record[metadataKey] = "page";
+    return record;
+  }
+  return { value: redacted, untrustedSource: "page" };
+}
 function boundAccessibilityNodes(nodes, maxChars) {
   const limit = Number.isFinite(maxChars) ? Math.max(2, Math.floor(maxChars)) : 2;
   const bounded = [];
@@ -7104,6 +7830,11 @@ async function settlesWithinTimeout(promise, timeoutMs) {
   await settleWithTimeout(promise, timeoutMs).catch(() => void 0);
   return settled;
 }
+async function promiseSettledWithin(promise, timeoutMs) {
+  const settledMarker = /* @__PURE__ */ Symbol("settled");
+  const result = await settleWithTimeout(promise.then(() => settledMarker, () => settledMarker), timeoutMs);
+  return result === settledMarker;
+}
 async function wait(milliseconds, signal) {
   if (milliseconds <= 0) {
     return;
@@ -7188,6 +7919,9 @@ function redactWebSocketEndpoint(value) {
 function isMissingFile(error) {
   return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
 }
+function sameFileIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
 function boundedScreenshotDimension(value) {
   return Number.isFinite(value) && value > 0 ? Math.min(Math.round(value), 1e6) : 0;
 }
@@ -7210,8 +7944,8 @@ function parseTargetAttachedEvent(value) {
     }
   };
 }
-function isTopLevelPageTarget(targetInfo) {
-  return targetInfo.type === "page" || targetInfo.type === "tab";
+function isGuardableTarget(targetInfo) {
+  return targetInfo.type === "page" || targetInfo.type === "tab" || targetInfo.type === "service_worker" || targetInfo.type === "shared_worker";
 }
 function isAutoAttachedTarget(connection, targetId) {
   if (typeof connection.isAutoAttached !== "function") {
@@ -7248,6 +7982,18 @@ function removeCdpListener(session, event, listener) {
   } catch {
   }
 }
+function restoreGuardSend(guard) {
+  if (!guard.originalSend || !guard.wrappedSend) {
+    return;
+  }
+  const session = guard.session;
+  if (session.send === guard.wrappedSend) {
+    try {
+      session.send = guard.originalSend;
+    } catch {
+    }
+  }
+}
 
 // src/server/runtime.ts
 init_errors();
@@ -7661,6 +8407,7 @@ function parseResults(html, maxResults, maxChars, baseUrl) {
     results.push({
       title: wrapUntrustedText("research_title", boundedTitle, 500),
       url,
+      untrustedUrl: wrapUntrustedText("research_url", redactSecretPlaceholders(url), 4096),
       snippet: wrapUntrustedText("research_snippet", boundedSnippet, 4e3)
     });
   }
@@ -7767,6 +8514,31 @@ var ServerRuntime = class _ServerRuntime {
   browser;
   research;
   closePromise;
+  /** True when this session's config implies ownership of the shared managed
+   * browser profile (and therefore of its lease). */
+  get profileLeaseRequired() {
+    const ownsBrowserProcess = this.config.browser.mode !== "disabled" && (this.config.browser.mode === "managed" || this.config.browser.mode === "launch" || this.config.browser.autoLaunch && Boolean(this.config.browser.executablePath));
+    return Boolean(ownsBrowserProcess && this.config.browser.userDataDir);
+  }
+  /** Browser operations must hold the profile lease before touching the
+   * managed browser. Acquisition is lazy so concurrent harness sessions stay
+   * connected while idle; only genuinely simultaneous browsing conflicts,
+   * and that surfaces as a retryable tool error instead of a dead server. */
+  async ensureBrowserProfileLease() {
+    if (!this.profileLeaseRequired || this.browserProfileLease || !this.config.browser.userDataDir) {
+      return;
+    }
+    try {
+      await ensurePrivateDirectory(this.config.browser.userDataDir);
+      this.browserProfileLease = await acquireBrowserProfileLease(this.config.browser.userDataDir);
+      this.logger.info("Acquired browser profile lease on demand");
+    } catch (error) {
+      if (error instanceof AppError && (error.code === "BROWSER_PROFILE_IN_USE" || error.code === "BROWSER_PROFILE_LOCK_FAILED")) {
+        throw new AppError("BROWSER_PROFILE_IN_USE", "Another SmoothOperator session currently owns the managed browser profile. Retry when that session closes, or switch one of them to connect mode.", { retryable: true });
+      }
+      throw error;
+    }
+  }
   static async create(config) {
     let browserProfileLease;
     try {
@@ -7774,9 +8546,15 @@ var ServerRuntime = class _ServerRuntime {
       await ensurePrivateDirectory(join5(config.dataDir, "downloads"));
       await ensurePrivateDirectory(join5(config.dataDir, "files"));
       const ownsBrowserProcess = config.browser.mode !== "disabled" && (config.browser.mode === "managed" || config.browser.mode === "launch" || config.browser.autoLaunch && Boolean(config.browser.executablePath));
-      if (ownsBrowserProcess && config.browser.userDataDir) {
+      const needsProfileLease = Boolean(ownsBrowserProcess && config.browser.userDataDir);
+      if (needsProfileLease && config.browser.userDataDir) {
         await ensurePrivateDirectory(config.browser.userDataDir);
-        browserProfileLease = await acquireBrowserProfileLease(config.browser.userDataDir);
+        browserProfileLease = await acquireBrowserProfileLease(config.browser.userDataDir).catch((error) => {
+          if (error instanceof AppError && (error.code === "BROWSER_PROFILE_IN_USE" || error.code === "BROWSER_PROFILE_LOCK_FAILED")) {
+            return void 0;
+          }
+          throw error;
+        });
       }
       const canonicalDataDir = await realpath2(config.dataDir);
       const runtime = new _ServerRuntime({ ...config, dataDir: canonicalDataDir }, browserProfileLease);
@@ -7810,12 +8588,19 @@ var ServerRuntime = class _ServerRuntime {
     await this.closePromise;
   }
   async run(action, signal) {
+    await this.ensureBrowserProfileLease();
     return this.browser.execute(action, signal);
   }
+  async runBatch(actions, options = {}, signal) {
+    await this.ensureBrowserProfileLease();
+    return this.browser.executeBatch(actions, options, signal);
+  }
   async snapshot(options, signal) {
+    await this.ensureBrowserProfileLease();
     return this.browser.snapshot({ ...options, signal });
   }
   async listTabs(signal) {
+    await this.ensureBrowserProfileLease();
     return this.browser.listTabs(signal);
   }
   listSessions() {
@@ -7828,6 +8613,7 @@ var ServerRuntime = class _ServerRuntime {
     if (signal?.aborted) {
       throw new AppError("CANCELLED", "The browser action was cancelled.");
     }
+    await this.ensureBrowserProfileLease();
     return awaitWithAbort2(this.browser.closeSession(sessionId), signal);
   }
   async webSearch(query, options, signal) {
@@ -7845,7 +8631,7 @@ 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 } : this.browser.connectionStatus(),
+        runtime: browserDisabled ? { connected: false, owned: false, trackedPages: 0, queuedOperations: 0, currentPageId: null, recoveryRequired: false } : this.browser.connectionStatus(),
         actionTimeoutMs: this.config.browser.actionTimeoutMs,
         connectTimeoutMs: this.config.browser.connectTimeoutMs,
         cdpTimeoutMs: this.config.browser.cdpTimeoutMs,
@@ -7875,7 +8661,7 @@ async function acquireBrowserProfileLease(profileDirectory) {
   const payload = JSON.stringify({ pid: process3.pid, token, createdAt: (/* @__PURE__ */ new Date()).toISOString() });
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      const handle = await open(lockPath, "wx", 384);
+      const handle = await open2(lockPath, "wx", 384);
       try {
         await handle.writeFile(payload, "utf8");
         await handle.sync();
@@ -8150,6 +8936,7 @@ var HTTP_SHUTDOWN_GRACE_MS = 5e3;
 var HTTP_HANDLER_SHUTDOWN_TIMEOUT_MS = 5e3;
 var HTTP_REQUEST_TIMEOUT_MS = 12e4;
 var HTTP_HEADERS_TIMEOUT_MS = 15e3;
+var HTTP_BODY_READ_TIMEOUT_MS = 3e4;
 async function main(args = process4.argv.slice(2)) {
   if (args[0] === "install") {
     const yes = args.includes("--yes") || args.includes("--no-interactive");
@@ -8335,6 +9122,10 @@ async function serveHttp(runtime, shutdown) {
       if (!response.headersSent) {
         const normalized = asAppError(error);
         const status = normalized.status >= 400 && normalized.status <= 599 ? normalized.status : 500;
+        if (status === 408 || status === 413 || status === 499) {
+          response.setHeader("connection", "close");
+          response.once("finish", () => request.destroy());
+        }
         response.writeHead(status, { "content-type": "application/json" });
       }
       if (!response.writableEnded) {
@@ -8422,7 +9213,7 @@ async function dispatchHttpRequest(request, response, nodeHandler, maxBodyBytes,
     await nodeHandler(request, response);
     return;
   }
-  const body = await readRequestBody(request, maxBodyBytes);
+  const body = await readRequestBody(request, maxBodyBytes, HTTP_BODY_READ_TIMEOUT_MS);
   if (isSubscriptionRequestBody(body)) {
     promoteToStream?.();
   }
@@ -8437,37 +9228,56 @@ async function dispatchHttpRequest(request, response, nodeHandler, maxBodyBytes,
   });
   await nodeHandler(replay, response);
 }
-async function readRequestBody(request, maxBodyBytes) {
+async function readRequestBody(request, maxBodyBytes, timeoutMs) {
   const chunks = [];
   let total = 0;
-  let tooLarge = false;
-  try {
+  let timer;
+  let timedOut = false;
+  let discardChunks = false;
+  let bodyPromise;
+  const read = async () => {
     for await (const chunk of request) {
-      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-      if (tooLarge) {
+      if (discardChunks) {
         continue;
       }
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
       const nextTotal = total + buffer.byteLength;
       if (nextTotal > maxBodyBytes) {
-        tooLarge = true;
-        continue;
+        throw new AppError("HTTP_BODY_TOO_LARGE", `HTTP request body exceeds the ${maxBodyBytes}-byte limit.`, { status: 413 });
       }
       total = nextTotal;
       chunks.push(buffer);
     }
+    return Buffer.concat(chunks, total);
+  };
+  try {
+    bodyPromise = read();
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        timedOut = true;
+        reject(new AppError("HTTP_BODY_TIMEOUT", "The HTTP request body took too long to arrive.", { status: 408, retryable: true }));
+      }, timeoutMs);
+    });
+    return await Promise.race([bodyPromise, timeout]);
   } catch (error) {
-    if (tooLarge) {
-      throw new AppError("HTTP_BODY_TOO_LARGE", `HTTP request body exceeds the ${maxBodyBytes}-byte limit.`, { status: 413, cause: error });
+    discardChunks = true;
+    bodyPromise?.catch(() => void 0);
+    if (timedOut) {
+      request.pause();
+      throw error;
+    }
+    if (error instanceof AppError && (error.code === "HTTP_BODY_TOO_LARGE" || error.code === "HTTP_BODY_TIMEOUT")) {
+      throw error;
     }
     if (request.aborted) {
       throw new AppError("HTTP_REQUEST_ABORTED", "The HTTP client disconnected before the request completed.", { status: 499, retryable: true, cause: error });
     }
     throw error;
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
+    }
   }
-  if (tooLarge) {
-    throw new AppError("HTTP_BODY_TOO_LARGE", `HTTP request body exceeds the ${maxBodyBytes}-byte limit.`, { status: 413 });
-  }
-  return Buffer.concat(chunks, total);
 }
 function isPotentialHttpStream(request) {
   return request.method === "GET";
@@ -8495,8 +9305,9 @@ function authorized(request, token) {
     return false;
   }
   const presented = Buffer.from(header.slice("Bearer ".length));
-  const expected = Buffer.from(token);
-  return presented.length === expected.length && timingSafeEqual(presented, expected);
+  const expected = createHash("sha256").update(token).digest();
+  const presentedDigest = createHash("sha256").update(presented).digest();
+  return presentedDigest.length === expected.length && timingSafeEqual(presentedDigest, expected);
 }
 if (isMainModule()) {
   void main().catch((error) => {