@chrischall/office-outlook-mcp 0.1.4 → 0.2.0

package/dist/bundle.js

@@ -50,8 +50,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // node_modules/@chrischall/mcp-utils/dist/cancel/index.js
 import { AsyncLocalStorage } from "node:async_hooks";
-function withCallSignal(signal, fn) {
-  return signal ? storage.run({ signal }, fn) : fn();
+function withCallSignal(signal, fn, request) {
+  return signal ? storage.run({ signal, ...request ? { request } : {} }, fn) : fn();
 }
 function currentCallSignal() {
   return storage.getStore()?.signal;
@@ -71,6 +71,18 @@ var init_cancel = __esm({
   }
 });
 
+// node_modules/@chrischall/mcp-utils/dist/caller/index.js
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+function withCallerCapabilities(capabilities, fn) {
+  return capabilities ? storage2.run(capabilities, fn) : fn();
+}
+var storage2;
+var init_caller = __esm({
+  "node_modules/@chrischall/mcp-utils/dist/caller/index.js"() {
+    storage2 = new AsyncLocalStorage2();
+  }
+});
+
 // node_modules/@modelcontextprotocol/server/dist/chunk-Br0eD_fh.mjs
 var __create2, __defProp2, __getOwnPropDesc2, __getOwnPropNames2, __getProtoOf2, __hasOwnProp2, __commonJSMin, __exportAll, __copyProps2, __toESM2;
 var init_chunk_Br0eD_fh = __esm({
@@ -35139,7 +35151,7 @@ var init_dist = __esm({
 
 // node_modules/@chrischall/mcp-utils/dist/errors/index.js
 function redactSecrets(text) {
-  return text.replace(BEARER_RE, "$1[REDACTED]").replace(BASIC_AUTH_RE, "$1[REDACTED]").replace(SET_COOKIE_RE, "$1$2=[REDACTED]").replace(COOKIE_HEADER_RE, (_m, prefix, pairs) => `${prefix}${pairs.replace(/=[^;,\s]*/g, "=[REDACTED]")}`).replace(API_KEY_RE, "[REDACTED]").replace(QUERY_SECRET_RE, "$1[REDACTED]").replace(AWS_SIGV4_RE, "$1[REDACTED]").replace(JSON_SECRET_DQ_RE, "$1[REDACTED]$2").replace(JSON_SECRET_SQ_RE, "$1[REDACTED]$2").replace(JWT_RE, "[REDACTED]");
+  return text.replace(BEARER_RE, "$1[REDACTED]").replace(BASIC_AUTH_RE, "$1[REDACTED]").replace(SET_COOKIE_RE, "$1$2=[REDACTED]").replace(COOKIE_HEADER_RE, (_m, prefix, pairs) => `${prefix}${pairs.replace(/=[^;,\s]*/g, "=[REDACTED]")}`).replace(API_KEY_RE, "[REDACTED]").replace(HEADER_SECRET_RE, "$1[REDACTED]").replace(QUERY_SECRET_RE, "$1[REDACTED]").replace(OAUTH_CODE_RE, "$1[REDACTED]").replace(FORM_PASSWORD_RE, "$1[REDACTED]").replace(AWS_SIGV4_RE, "$1[REDACTED]").replace(JSON_SECRET_DQ_RE, "$1[REDACTED]$2").replace(JSON_SECRET_SQ_RE, "$1[REDACTED]$2").replace(JWT_RE, "[REDACTED]");
 }
 function truncateErrorMessage(text, max = DEFAULT_ERROR_MESSAGE_MAX) {
   const str = text === null || text === void 0 ? "" : String(text);
@@ -35153,7 +35165,7 @@ function messageOf(err) {
     return err.message;
   return String(err);
 }
-var DEFAULT_ERROR_MESSAGE_MAX, McpToolError, BEARER_RE, JWT_RE, BASIC_AUTH_RE, SET_COOKIE_RE, COOKIE_HEADER_RE, API_KEY_RE, QUERY_SECRET_RE, AWS_SIGV4_RE, JSON_SECRET_KEYS, JSON_SECRET_DQ_RE, JSON_SECRET_SQ_RE;
+var DEFAULT_ERROR_MESSAGE_MAX, McpToolError, BEARER_RE, JWT_RE, BASIC_AUTH_RE, SET_COOKIE_RE, COOKIE_HEADER_RE, API_KEY_RE, QUERY_SECRET_RE, OAUTH_CODE_RE, FORM_PASSWORD_RE, HEADER_SECRET_RE, AWS_SIGV4_RE, JSON_SECRET_KEYS, JSON_SECRET_DQ_RE, JSON_SECRET_SQ_RE;
 var init_errors3 = __esm({
   "node_modules/@chrischall/mcp-utils/dist/errors/index.js"() {
     DEFAULT_ERROR_MESSAGE_MAX = 500;
@@ -35187,11 +35199,26 @@ var init_errors3 = __esm({
       "whsec_[A-Za-z0-9]{16,}\\b"
       // webhook signing secret (Stripe-style)
     ].map((p) => `\\b${p}`).join("|"), "g");
-    QUERY_SECRET_RE = /([?&](?:access_token|refresh_token|client_secret|api_?key|signature|token|key|sig)=)[^&#\s"'<>`]+/gi;
+    QUERY_SECRET_RE = /([?&](?:(?:access|refresh|id|auth|session|csrf|xsrf)[_-]?token|client[_-]?secret|api[_-]?secret|api[_-]?key|password|passwd|signature|token|key|sig)=)[^&#\s"'<>`]+/gi;
+    OAUTH_CODE_RE = /([?&]code=)(?=[^&#\s"'<>`]{16,})[^&#\s"'<>`]+/gi;
+    FORM_PASSWORD_RE = /((?:^|[\s,;:"'(\[{])(?:password|passwd)=)[^&#\s"'<>`]+/gim;
+    HEADER_SECRET_RE = /(\b(?:x[-_][a-z0-9_-]*?(?:api[-_]?key|token|secret|auth)[a-z0-9_-]*|api[-_]?key)\s*:\s*)[^\s,;"'<>`]+/gi;
     AWS_SIGV4_RE = /([?&]X-Amz-(?:Signature|Security-Token|Credential)=)[^&#\s"'<>`]+/gi;
-    JSON_SECRET_KEYS = "access_token|refresh_token|client_secret|api_?key|password|passwd|secret|token";
-    JSON_SECRET_DQ_RE = new RegExp(`("(?:${JSON_SECRET_KEYS})"\\s*:\\s*")[^"]*(")`, "gi");
-    JSON_SECRET_SQ_RE = new RegExp(`('(?:${JSON_SECRET_KEYS})'\\s*:\\s*')[^']*(')`, "gi");
+    JSON_SECRET_KEYS = [
+      "(?:access|refresh|id|auth|session|bearer|csrf|xsrf)[_-]?token",
+      "client[_-]?secret",
+      "api[_-]?secret",
+      "(?:x[_-])?api[_-]?key",
+      "private[_-]?key",
+      "x[_-][a-z0-9_-]*?(?:api[_-]?key|token|secret|auth)[a-z0-9_-]*",
+      "(?:proxy-)?authorization",
+      "password",
+      "passwd",
+      "secret",
+      "token"
+    ].join("|");
+    JSON_SECRET_DQ_RE = new RegExp(`("(?:${JSON_SECRET_KEYS})"\\s*:\\s*")(?:[^"\\\\]|\\\\.)*(")`, "gi");
+    JSON_SECRET_SQ_RE = new RegExp(`('(?:${JSON_SECRET_KEYS})'\\s*:\\s*')(?:[^'\\\\]|\\\\.)*(')`, "gi");
   }
 });
 
@@ -35280,6 +35307,7 @@ var init_response = __esm({
 var init_confirmation = __esm({
   "node_modules/@chrischall/mcp-utils/dist/server/confirmation.js"() {
     init_dist();
+    init_caller();
     init_response();
   }
 });
@@ -35293,6 +35321,15 @@ Hint: ${err.hint}`);
   }
   throw err;
 }
+function mcpRequestFrom(args) {
+  const ctx = args.at(-1);
+  if (typeof ctx !== "object" || ctx === null)
+    return void 0;
+  const req = ctx.mcpReq;
+  if (typeof req !== "object" || req === null)
+    return void 0;
+  return typeof req.notify === "function" ? req : void 0;
+}
 function callSignalFrom(args) {
   const ctx = args.at(-1);
   if (typeof ctx !== "object" || ctx === null)
@@ -35303,6 +35340,20 @@ function callSignalFrom(args) {
   const signal = req.signal;
   return signal instanceof AbortSignal ? signal : void 0;
 }
+function declaredCapabilitiesFrom(server) {
+  const inner = server.server;
+  if (typeof inner !== "object" || inner === null)
+    return void 0;
+  const read = inner.getClientCapabilities;
+  if (typeof read !== "function")
+    return void 0;
+  try {
+    const declared = read.call(inner);
+    return typeof declared === "object" && declared !== null ? declared : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function surfaceToolHints(server) {
   const register2 = server.registerTool.bind(server);
   server.registerTool = (name, config2, cb) => register2(name, config2, (...args) => (
@@ -35318,15 +35369,24 @@ function surfaceToolHints(server) {
     // Here because this is the one wrapper every tool already passes
     // through: threading the signal by hand would mean editing several
     // hundred handlers and missing exactly the ones nobody edits.
-    withCallSignal(callSignalFrom(args), () => {
-      let result;
-      try {
-        result = cb(...args);
-      } catch (err) {
-        return hintResultOrRethrow(err);
-      }
-      return result instanceof Promise ? result.catch(hintResultOrRethrow) : result;
-    })
+    withCallSignal(callSignalFrom(args), () => (
+      // WHAT THE CALLER CAN DO, made ambient for the same reason and in
+      // the same place (`caller/index.ts`). Only the 2025-era half needs
+      // the wrapper — a 2026-07-28 request answers for itself off its own
+      // envelope — but a guarded tool that cannot tell whether the caller
+      // can be shown a prompt returns one the SDK then refuses to deliver,
+      // and that refusal reaches the caller as an unexplained protocol
+      // error it had no chance to catch.
+      withCallerCapabilities(declaredCapabilitiesFrom(server), () => {
+        let result;
+        try {
+          result = cb(...args);
+        } catch (err) {
+          return hintResultOrRethrow(err);
+        }
+        return result instanceof Promise ? result.catch(hintResultOrRethrow) : result;
+      })
+    ), mcpRequestFrom(args))
   ));
 }
 async function createMcpServer(opts) {
@@ -35344,11 +35404,43 @@ async function createMcpServer(opts) {
 }
 function withGracefulShutdown(target, opts = {}) {
   const shouldExit = opts.exit ?? true;
+  if (opts.timeoutMs !== void 0 && !(Number.isFinite(opts.timeoutMs) && opts.timeoutMs > 0)) {
+    throw new RangeError("withGracefulShutdown: timeoutMs must be a finite number greater than 0.");
+  }
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS;
+  if (opts.repeatSignalGraceMs !== void 0 && !(Number.isFinite(opts.repeatSignalGraceMs) && opts.repeatSignalGraceMs >= 0)) {
+    throw new RangeError("withGracefulShutdown: repeatSignalGraceMs must be a finite number >= 0.");
+  }
+  const repeatGraceMs = opts.repeatSignalGraceMs ?? DEFAULT_REPEAT_SIGNAL_GRACE_MS;
   let shuttingDown = false;
+  let firstSignalAt = 0;
+  let exited = false;
+  const exitOnce = () => {
+    if (exited)
+      return;
+    exited = true;
+    process.exit(0);
+  };
   const handler = (signal) => {
-    if (shuttingDown)
+    if (shuttingDown) {
+      if (Date.now() - firstSignalAt < repeatGraceMs)
+        return;
+      if (shouldExit) {
+        console.error(`[mcp-utils] second ${signal} during shutdown \u2014 exiting now`);
+        exitOnce();
+      }
       return;
+    }
     shuttingDown = true;
+    firstSignalAt = Date.now();
+    let timer;
+    if (shouldExit) {
+      timer = setTimeout(() => {
+        console.error(`[mcp-utils] graceful shutdown on ${signal} did not finish in ${timeoutMs}ms \u2014 exiting`);
+        exitOnce();
+      }, timeoutMs);
+      timer.unref?.();
+    }
     void (async () => {
       try {
         if (opts.onSignal)
@@ -35357,8 +35449,10 @@ function withGracefulShutdown(target, opts = {}) {
       } catch (err) {
         console.error(`[mcp-utils] error during graceful shutdown on ${signal}: ${err instanceof Error ? err.message : String(err)}`);
       } finally {
+        if (timer !== void 0)
+          clearTimeout(timer);
         if (shouldExit)
-          process.exit(0);
+          exitOnce();
       }
     })();
   };
@@ -35386,7 +35480,7 @@ function runMcp(opts) {
   }
   return handle;
 }
-var SERVER_PROTOCOL_VERSIONS;
+var SERVER_PROTOCOL_VERSIONS, DEFAULT_SHUTDOWN_TIMEOUT_MS, DEFAULT_REPEAT_SIGNAL_GRACE_MS;
 var init_server = __esm({
   "node_modules/@chrischall/mcp-utils/dist/server/index.js"() {
     init_stdio();
@@ -35395,10 +35489,13 @@ var init_server = __esm({
     init_response();
     init_confirmation();
     init_cancel();
+    init_caller();
     SERVER_PROTOCOL_VERSIONS = Object.freeze([
       "2026-07-28",
       ...SUPPORTED_PROTOCOL_VERSIONS
     ]);
+    DEFAULT_SHUTDOWN_TIMEOUT_MS = 5e3;
+    DEFAULT_REPEAT_SIGNAL_GRACE_MS = 500;
   }
 });
 
@@ -35482,17 +35579,27 @@ var init_config = __esm({
   }
 });
 
+// node_modules/@chrischall/mcp-utils/dist/fs/confine.js
+var init_confine = __esm({
+  "node_modules/@chrischall/mcp-utils/dist/fs/confine.js"() {
+    init_config();
+  }
+});
+
 // node_modules/@chrischall/mcp-utils/dist/fs/output.js
 var init_output = __esm({
   "node_modules/@chrischall/mcp-utils/dist/fs/output.js"() {
     init_config();
+    init_confine();
   }
 });
 
 // node_modules/@chrischall/mcp-utils/dist/fs/index.js
 var init_fs = __esm({
   "node_modules/@chrischall/mcp-utils/dist/fs/index.js"() {
+    init_confine();
     init_output();
+    init_confine();
   }
 });
 
@@ -35543,24 +35650,78 @@ function createApiClient(opts) {
   const retryStatuses = retry.statuses ?? [429];
   const timeoutMs = opts.timeout;
   const authHeader = (token) => !token ? {} : opts.tokenHeader ? { [opts.tokenHeader]: token } : { Authorization: `Bearer ${token}` };
-  function withTimeout(run) {
-    if (timeoutMs == null || timeoutMs <= 0)
-      return run(withAmbientCancellation(void 0));
+  async function withTimeout(run) {
+    if (timeoutMs == null || timeoutMs <= 0) {
+      const res2 = await run(withAmbientCancellation(void 0));
+      return { res: res2, done: () => {
+      }, expired: void 0 };
+    }
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);
-    return run(withAmbientCancellation(controller.signal)).catch((err) => {
+    let res;
+    try {
+      res = await run(withAmbientCancellation(controller.signal));
+    } catch (err) {
+      clearTimeout(timer);
       if (err instanceof Error && err.name === "AbortError" && controller.signal.aborted) {
         throw new RequestTimeoutError(service, timeoutMs);
       }
       throw err;
-    }).finally(() => clearTimeout(timer));
+    }
+    const expired = new Promise((_resolve, reject) => {
+      controller.signal.addEventListener("abort", () => reject(new RequestTimeoutError(service, timeoutMs)), {
+        once: true
+      });
+    });
+    expired.catch(() => {
+    });
+    return { res, done: () => clearTimeout(timer), expired };
+  }
+  async function readBody(attempt, read) {
+    try {
+      if (!attempt.expired)
+        return await read(attempt.res);
+      return await Promise.race([read(attempt.res), attempt.expired]);
+    } catch (err) {
+      if (err instanceof RequestTimeoutError) {
+        attempt.res.body?.cancel().catch(() => {
+        });
+      }
+      throw err;
+    } finally {
+      attempt.done();
+    }
+  }
+  const baseParts = (() => {
+    try {
+      const u = new URL(base);
+      return { origin: u.origin, username: u.username, password: u.password };
+    } catch {
+      return void 0;
+    }
+  })();
+  const baseOrigin = baseParts?.origin;
+  function resolveUrl(path, query) {
+    const url2 = `${base}${path}${query}`;
+    if (baseOrigin === void 0)
+      return url2;
+    let parsed;
+    try {
+      parsed = new URL(url2);
+    } catch {
+      throw new Error(`Refusing request to ${service}: path ${JSON.stringify(path)} does not form a valid URL.`);
+    }
+    if (parsed.origin !== baseOrigin || parsed.username !== baseParts?.username || parsed.password !== baseParts?.password) {
+      throw new Error(`Refusing request to ${service}: path ${JSON.stringify(path)} resolves outside the base origin ${baseOrigin}. Paths must be relative to baseUrl (start them with "/").`);
+    }
+    return url2;
   }
   async function send(method, path, opt) {
     const isMultipart = opt.formData !== void 0;
     const hasJsonBody = !isMultipart && opt.body !== void 0;
     const reqBody = isMultipart ? opt.formData : hasJsonBody ? JSON.stringify(opt.body) : void 0;
     const query = opt.query ? buildQueryString(opt.query) : "";
-    const url2 = `${base}${path}${query}`;
+    const url2 = resolveUrl(path, query);
     const bodyInit = reqBody !== void 0 ? { body: reqBody } : {};
     const fetchWith = (token, signal) => doFetch(url2, {
       method,
@@ -35577,8 +35738,10 @@ function createApiClient(opts) {
     const once = () => withTimeout((signal) => opts.tokenManager ? opts.tokenManager.withAuth((token) => fetchWith(token, signal)) : (async () => fetchWith(await opts.getToken?.() || void 0, signal))());
     let attempt = 0;
     for (; ; ) {
-      const res = await once();
+      const current = await once();
+      const res = current.res;
       if (retryStatuses.includes(res.status) && attempt < retry.count) {
+        current.done();
         attempt += 1;
         const delay = retry.honorRetryAfter ? parseRetryAfterMs(res.headers.get("retry-after"), {
           defaultMs: retry.delayMs,
@@ -35587,18 +35750,21 @@ function createApiClient(opts) {
         await sleep3(delay);
         continue;
       }
-      return res;
+      return current;
     }
   }
   async function fetchJson(method, path, opt = {}) {
-    const res = await send(method, path, opt);
+    const attempt = await send(method, path, opt);
+    const res = attempt.res;
+    if (res.status === 401 || res.status === 429 || res.status === 204)
+      attempt.done();
     if (res.status === 401)
       throw unauthorized();
     if (res.status === 429)
       throw rateLimited();
     if (res.status === 204)
       return void 0;
-    const text = await res.text();
+    const text = await readBody(attempt, (r) => r.text());
     if (!res.ok) {
       throw new ApiError(res.status, formatApiError(res.status, method, path, text, { service }));
     }
@@ -35608,12 +35774,15 @@ function createApiClient(opts) {
   }
   async function fetchHtml(method, path, opt = {}) {
     const headers = { Accept: "text/html,*/*", ...opt.headers };
-    const res = await send(method, path, { ...opt, headers });
+    const attempt = await send(method, path, { ...opt, headers });
+    const res = attempt.res;
+    if (res.status === 401 || res.status === 429)
+      attempt.done();
     if (res.status === 401)
       throw unauthorized();
     if (res.status === 429)
       throw rateLimited();
-    const text = await res.text();
+    const text = await readBody(attempt, (r) => r.text());
     if (!res.ok) {
       throw new ApiError(res.status, formatApiError(res.status, method, path, text, { service }));
     }
@@ -35621,16 +35790,23 @@ function createApiClient(opts) {
   }
   async function fetchRaw(method, path, opt = {}) {
     const headers = { Accept: "*/*", ...opt.headers };
-    const res = await send(method, path, { ...opt, headers });
+    const attempt = await send(method, path, { ...opt, headers });
+    const res = attempt.res;
+    if (res.status === 401 || res.status === 429)
+      attempt.done();
     if (res.status === 401)
       throw unauthorized();
     if (res.status === 429)
       throw rateLimited();
     if (!res.ok) {
-      const text = await res.text().catch(() => "");
+      const text = await readBody(attempt, (r) => r.text()).catch((err) => {
+        if (err instanceof RequestTimeoutError)
+          throw err;
+        return "";
+      });
       throw new ApiError(res.status, formatApiError(res.status, method, path, text, { service }));
     }
-    const bytes = new Uint8Array(await res.arrayBuffer());
+    const bytes = new Uint8Array(await readBody(attempt, (r) => r.arrayBuffer()));
     return {
       status: res.status,
       contentType: res.headers.get("content-type"),
@@ -35813,9 +35989,16 @@ var init_auth = __esm({
   }
 });
 
+// node_modules/@chrischall/mcp-utils/dist/internal/ascii.js
+var init_ascii = __esm({
+  "node_modules/@chrischall/mcp-utils/dist/internal/ascii.js"() {
+  }
+});
+
 // node_modules/@chrischall/mcp-utils/dist/scrape/index.js
 var init_scrape = __esm({
   "node_modules/@chrischall/mcp-utils/dist/scrape/index.js"() {
+    init_ascii();
   }
 });
 
@@ -35823,6 +36006,7 @@ var init_scrape = __esm({
 var init_dist2 = __esm({
   "node_modules/@chrischall/mcp-utils/dist/index.js"() {
     init_cancel();
+    init_caller();
     init_server();
     init_response();
     init_errors3();
@@ -35843,7 +36027,7 @@ var init_version = __esm({
   "src/version.ts"() {
     "use strict";
     PACKAGE_NAME = "office-outlook-mcp";
-    VERSION = "0.1.4";
+    VERSION = "0.2.0";
   }
 });
 
@@ -36058,6 +36242,7 @@ var init_frames = __esm({
       "capture_redirect",
       "read_indexed_db",
       "read_dom",
+      "read_dom_list",
       "download",
       "graphql",
       "write_cookies"
@@ -36558,6 +36743,79 @@ function assertDomSelectorsArray(value, label) {
     }
   }
 }
+function assertDomListSelectorsArray(value, label) {
+  if (!Array.isArray(value)) {
+    throw new ProtocolError3(`${label}: expected array, got ${typeof value}`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < value.length; i++) {
+    const entry = value[i];
+    assertObject(entry, `${label}[${i}]`);
+    if (entry.name === void 0) {
+      throw new ProtocolError3(`${label}[${i}].name: missing`);
+    }
+    if (entry.itemSelector === void 0) {
+      throw new ProtocolError3(`${label}[${i}].itemSelector: missing`);
+    }
+    if (entry.fields === void 0) {
+      throw new ProtocolError3(`${label}[${i}].fields: missing`);
+    }
+    if (typeof entry.name !== "string" || !SCOPE_KEY_RE.test(entry.name)) {
+      throw new ProtocolError3(`${label}[${i}].name: invalid ${JSON.stringify(entry.name)}`);
+    }
+    if (typeof entry.itemSelector !== "string" || !DOM_SELECTOR_RE.test(entry.itemSelector)) {
+      throw new ProtocolError3(`${label}[${i}].itemSelector: invalid ${JSON.stringify(entry.itemSelector)}`);
+    }
+    if (!Array.isArray(entry.fields) || entry.fields.length === 0) {
+      throw new ProtocolError3(`${label}[${i}].fields: expected non-empty array`);
+    }
+    const fieldNames = /* @__PURE__ */ new Set();
+    for (let j = 0; j < entry.fields.length; j++) {
+      const field = entry.fields[j];
+      const fieldLabel = `${label}[${i}].fields[${j}]`;
+      assertObject(field, fieldLabel);
+      if (field.name === void 0) {
+        throw new ProtocolError3(`${fieldLabel}.name: missing`);
+      }
+      if (typeof field.name !== "string" || !SCOPE_KEY_RE.test(field.name)) {
+        throw new ProtocolError3(`${fieldLabel}.name: invalid ${JSON.stringify(field.name)}`);
+      }
+      if (field.selector !== void 0) {
+        if (typeof field.selector !== "string" || !DOM_SELECTOR_RE.test(field.selector)) {
+          throw new ProtocolError3(`${fieldLabel}.selector: invalid ${JSON.stringify(field.selector)}`);
+        }
+      }
+      if (field.attribute !== void 0) {
+        if (typeof field.attribute !== "string" || !DOM_ATTRIBUTE_RE.test(field.attribute)) {
+          throw new ProtocolError3(`${fieldLabel}.attribute: invalid ${JSON.stringify(field.attribute)}`);
+        }
+      }
+      if (fieldNames.has(field.name)) {
+        throw new ProtocolError3(`${label}[${i}].fields: duplicate name ${JSON.stringify(field.name)}`);
+      }
+      fieldNames.add(field.name);
+      for (const k of Object.keys(field)) {
+        if (k !== "name" && k !== "selector" && k !== "attribute") {
+          throw new ProtocolError3(`${fieldLabel}: unexpected field ${JSON.stringify(k)}`);
+        }
+      }
+    }
+    if (entry.maxItems !== void 0) {
+      if (typeof entry.maxItems !== "number" || !Number.isInteger(entry.maxItems) || entry.maxItems < 1 || entry.maxItems > 1e3) {
+        throw new ProtocolError3(`${label}[${i}].maxItems: invalid ${JSON.stringify(entry.maxItems)}`);
+      }
+    }
+    if (seen.has(entry.name)) {
+      throw new ProtocolError3(`${label}: duplicate name ${JSON.stringify(entry.name)}`);
+    }
+    seen.add(entry.name);
+    for (const k of Object.keys(entry)) {
+      if (k !== "name" && k !== "itemSelector" && k !== "fields" && k !== "maxItems") {
+        throw new ProtocolError3(`${label}[${i}]: unexpected field ${JSON.stringify(k)}`);
+      }
+    }
+  }
+}
 function assertGraphqlOpsArray(value, label) {
   if (!Array.isArray(value)) {
     throw new ProtocolError3(`${label}: expected array, got ${typeof value}`);
@@ -36604,6 +36862,8 @@ function validateFrame(raw) {
     return validateHelloRejected(raw);
   if (t === "extension-disconnected")
     return { type: "extension-disconnected" };
+  if (t === "peer-gone")
+    return validatePeerGone(raw);
   throw new ProtocolError3(`unknown frame type: ${String(t)}`);
 }
 function validateHello(raw) {
@@ -36674,16 +36934,11 @@ function validateHello(raw) {
     if (raw.domSelectors !== void 0) {
       assertDomSelectorsArray(raw.domSelectors, "hello.domSelectors");
     }
-    if (raw.accepts !== void 0) {
-      if (!Array.isArray(raw.accepts)) {
-        throw new ProtocolError3("hello.accepts: expected array");
-      }
-      for (const a of raw.accepts) {
-        if (typeof a !== "string") {
-          throw new ProtocolError3(`hello.accepts: entry must be string, got ${typeof a}`);
-        }
-      }
+    if (raw.domListSelectors !== void 0) {
+      assertDomListSelectorsArray(raw.domListSelectors, "hello.domListSelectors");
     }
+    if (raw.accepts !== void 0)
+      assertAcceptsList(raw.accepts);
     if (raw.graphqlOps !== void 0) {
       assertGraphqlOpsArray(raw.graphqlOps, "hello.graphqlOps");
     }
@@ -36705,6 +36960,8 @@ function validateHello(raw) {
     assertBase64(raw.identityX25519Pub, "hello.identityX25519Pub");
     assertBase64(raw.identityEd25519Pub, "hello.identityEd25519Pub");
     assertBase64(raw.sessionNonce, "hello.sessionNonce");
+    if (raw.accepts !== void 0)
+      assertAcceptsList(raw.accepts);
     return raw;
   }
   throw new ProtocolError3(`hello.role: must be 'server' or 'extension', got ${String(role)}`);
@@ -36759,6 +37016,27 @@ function validatePairPending(raw) {
   }
   return { type: "pair-pending", mcpId: raw.mcpId, pairCode: raw.pairCode };
 }
+function assertAcceptsList(accepts) {
+  if (!Array.isArray(accepts)) {
+    throw new ProtocolError3("hello.accepts: expected array");
+  }
+  for (const a of accepts) {
+    if (typeof a !== "string") {
+      throw new ProtocolError3(`hello.accepts: entry must be string, got ${typeof a}`);
+    }
+  }
+}
+function validatePeerGone(raw) {
+  assertString(raw.mcpId, "peer-gone.mcpId");
+  if (!isValidMcpId(raw.mcpId))
+    throw new ProtocolError3("peer-gone.mcpId: invalid format");
+  for (const k of Object.keys(raw)) {
+    if (k !== "type" && k !== "mcpId") {
+      throw new ProtocolError3(`peer-gone: unexpected field ${JSON.stringify(k)}`);
+    }
+  }
+  return { type: "peer-gone", mcpId: raw.mcpId };
+}
 function validateHelloRejected(raw) {
   assertString(raw.mcpId, "hello-rejected.mcpId");
   if (!isValidMcpId(raw.mcpId))
@@ -37008,6 +37286,24 @@ function validateInnerRequest(raw) {
     }
     return raw;
   }
+  if (raw.op === "read_dom_list") {
+    assertObject(raw.init, "inner.init");
+    if (raw.init.origin === void 0)
+      throw new ProtocolError3("inner.init.origin: missing");
+    if (raw.init.name === void 0)
+      throw new ProtocolError3("inner.init.name: missing");
+    assertHttpsOriginOnly(raw.init.origin, "inner.init.origin");
+    assertString(raw.init.name, "inner.init.name");
+    if (raw.init.name.length === 0) {
+      throw new ProtocolError3("inner.init.name: must be non-empty");
+    }
+    for (const k of Object.keys(raw.init)) {
+      if (k !== "origin" && k !== "name") {
+        throw new ProtocolError3(`inner.init: unexpected field ${JSON.stringify(k)} on read_dom_list`);
+      }
+    }
+    return raw;
+  }
   if (raw.op === "graphql_query") {
     assertObject(raw.init, "inner.init");
     if (raw.init.name === void 0)
@@ -37055,7 +37351,7 @@ function validateInnerRequest(raw) {
     }
     return raw;
   }
-  throw new ProtocolError3(`inner.op: must be one of "fetch", "read_cookies", "read_local_storage", "read_session_storage", "capture_request_header", "capture_redirect", "read_indexed_db", "read_dom", "download", "graphql_query", "write_cookies"; got ${JSON.stringify(raw.op)}`);
+  throw new ProtocolError3(`inner.op: must be one of "fetch", "read_cookies", "read_local_storage", "read_session_storage", "capture_request_header", "capture_redirect", "read_indexed_db", "read_dom", "read_dom_list", "download", "graphql_query", "write_cookies"; got ${JSON.stringify(raw.op)}`);
 }
 function assertNonEmptyKeyArray(value, label) {
   if (!Array.isArray(value)) {
@@ -37159,6 +37455,18 @@ function validateInnerResponse(raw) {
       assertStringMap(raw.values, "inner.values");
       return raw;
     }
+    if (op === "read_dom_list") {
+      if (raw.rows === void 0) {
+        throw new ProtocolError3("inner.rows: missing on read_dom_list response");
+      }
+      if (!Array.isArray(raw.rows)) {
+        throw new ProtocolError3("inner.rows: expected array, got " + typeof raw.rows);
+      }
+      for (const [i, row] of raw.rows.entries()) {
+        assertStringMap(row, `inner.rows[${i}]`);
+      }
+      return raw;
+    }
     if (op === "graphql_query") {
       if (raw.data === void 0) {
         throw new ProtocolError3("inner.data: missing on graphql_query response");
@@ -37291,12 +37599,6 @@ async function sealInnerFrame(sessionKey, mcpId, seq, inner, direction) {
     ciphertext: toB64(ct)
   };
 }
-async function openEncryptedFrame(sessionKey, frame, direction) {
-  const result = await openEncryptedFrameDetailed(sessionKey, frame, direction);
-  if (result.stage === "ok")
-    return result.inner;
-  throw result.error instanceof Error ? result.error : new Error(String(result.error));
-}
 async function openEncryptedFrameDetailed(sessionKey, frame, direction) {
   let pt;
   try {
@@ -39645,7 +39947,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes3, createHash } = __require("crypto");
+    var { randomBytes: randomBytes4, createHash } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -40183,7 +40485,7 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes3(16).toString("base64");
+      const key = randomBytes4(16).toString("base64");
       const request = isSecure ? https.request : http.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
@@ -41157,6 +41459,18 @@ async function buildServerHello(opts) {
       ...d.attribute !== void 0 ? { attribute: d.attribute } : {}
     }));
   }
+  if (opts.domListSelectors && opts.domListSelectors.length > 0) {
+    hello.domListSelectors = opts.domListSelectors.map((d) => ({
+      name: d.name,
+      itemSelector: d.itemSelector,
+      fields: d.fields.map((f) => ({
+        name: f.name,
+        ...f.selector !== void 0 ? { selector: f.selector } : {},
+        ...f.attribute !== void 0 ? { attribute: f.attribute } : {}
+      })),
+      ...d.maxItems !== void 0 ? { maxItems: d.maxItems } : {}
+    }));
+  }
   if (opts.graphqlOps && opts.graphqlOps.length > 0) {
     hello.graphqlOps = opts.graphqlOps.map((d) => ({
       name: d.name,
@@ -41345,7 +41659,7 @@ var init_session_ready = __esm({
 });
 
 // node_modules/@fetchproxy/server/dist/identity.js
-import { readFile, readdir, writeFile, mkdir, chmod, rename, rm, unlink } from "node:fs/promises";
+import { readFile, readdir, writeFile, mkdir, chmod, rename, rm, unlink, link, lstat } from "node:fs/promises";
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { isAbsolute, join as join2 } from "node:path";
 import { homedir as homedir2 } from "node:os";
@@ -41410,7 +41724,7 @@ async function openIdentityDir(dir) {
       throw e;
   }
 }
-async function sweepStagingFiles(dir, serverName) {
+async function sweepStagingFiles(dir, serverName, opts = {}) {
   const base = safeIdentityFileBase(serverName).replace(/[.]/g, "\\.");
   const staging = new RegExp(`^${base}\\.json\\.[0-9a-f]{${STAGING_BYTES * 2}}\\.tmp$`);
   let names;
@@ -41419,48 +41733,94 @@ async function sweepStagingFiles(dir, serverName) {
   } catch {
     return;
   }
-  await Promise.all(names.filter((name) => staging.test(name)).map((name) => unlink(join2(dir, name)).catch(() => void 0)));
+  const cutoff = opts.olderThanMs === void 0 ? null : Date.now() - opts.olderThanMs;
+  await Promise.all(names.filter((name) => staging.test(name)).map(async (name) => {
+    const path = join2(dir, name);
+    if (cutoff !== null) {
+      const st = await lstat(path).catch(() => null);
+      if (st === null || st.mtimeMs > cutoff)
+        return;
+    }
+    await unlink(path).catch(() => void 0);
+  }));
 }
-async function writeIdentityFile(dir, serverName, id) {
+async function loadOrCreateIdentity(serverName, dir = defaultIdentityDir()) {
   const path = identityFilePath(dir, serverName);
   await openIdentityDir(dir);
-  await sweepStagingFiles(dir, serverName);
-  const tmp = `${path}.${randomBytes2(STAGING_BYTES).toString("hex")}.tmp`;
   try {
-    await writeFile(tmp, serializeIdentity(id), { mode: 384, flag: "wx" });
-    await chmod(tmp, 384);
-    await rename(tmp, path);
+    return parseIdentity(await readFile(path, "utf8"));
   } catch (e) {
-    await rm(tmp, { force: true });
-    throw e;
+    if (e.code !== "ENOENT" && !(e instanceof SyntaxError))
+      throw e;
+  }
+  let unreadable = null;
+  for (let attempt = 0; attempt < 5; attempt++) {
+    const id = await generateIdentity();
+    if (await publishIdentityIfAbsent(dir, serverName, id))
+      return id;
+    try {
+      return parseIdentity(await readFile(path, "utf8"));
+    } catch (e) {
+      if (e.code === "ENOENT") {
+        continue;
+      }
+      if (!(e instanceof SyntaxError))
+        throw e;
+      unreadable = e;
+      await new Promise((r) => setTimeout(r, 20 * (attempt + 1)));
+    }
   }
-  return path;
+  if (unreadable !== null)
+    throw unreadable;
+  throw new Error(`fetchproxy: could not create an identity for ${JSON.stringify(serverName)} in ${dir}`);
 }
-async function loadOrCreateIdentity(serverName, dir = defaultIdentityDir()) {
+async function publishIdentityIfAbsent(dir, serverName, id) {
   const path = identityFilePath(dir, serverName);
-  await openIdentityDir(dir);
+  await sweepStagingFiles(dir, serverName, { olderThanMs: 6e4 });
+  const tmp = `${path}.${randomBytes2(STAGING_BYTES).toString("hex")}.tmp`;
   try {
-    return parseIdentity(await readFile(path, "utf8"));
+    await writeFile(tmp, serializeIdentity(id), { mode: 384, flag: "wx" });
+    await chmod(tmp, 384);
+    try {
+      await link(tmp, path);
+    } catch (e) {
+      const code = e.code;
+      if (code === void 0 || !NO_HARD_LINKS.has(code))
+        throw e;
+      try {
+        await writeFile(path, serializeIdentity(id), { mode: 384, flag: "wx" });
+      } catch (writeErr) {
+        if (writeErr.code !== "EEXIST") {
+          await rm(path, { force: true }).catch(() => void 0);
+        }
+        throw writeErr;
+      }
+      await chmod(path, 384);
+    }
+    return true;
   } catch (e) {
-    if (e.code !== "ENOENT")
-      throw e;
+    const code = e.code;
+    if (code === "EEXIST" || code === "ENOENT")
+      return false;
+    throw e;
+  } finally {
+    await rm(tmp, { force: true });
   }
-  const id = await generateIdentity();
-  await writeIdentityFile(dir, serverName, id);
-  return id;
 }
-var SAFE_PLAIN, SAFE_SCOPED, STAGING_BYTES;
+var SAFE_PLAIN, SAFE_SCOPED, STAGING_BYTES, NO_HARD_LINKS;
 var init_identity = __esm({
   "node_modules/@fetchproxy/server/dist/identity.js"() {
     init_dist3();
     SAFE_PLAIN = /^[A-Za-z0-9._-]+$/;
     SAFE_SCOPED = /^@[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
     STAGING_BYTES = 6;
+    NO_HARD_LINKS = /* @__PURE__ */ new Set(["EPERM", "ENOTSUP", "EOPNOTSUPP", "ENOSYS"]);
   }
 });
 
 // node_modules/@fetchproxy/server/dist/extension-trust.js
-import { readFile as readFile2, writeFile as writeFile2, rename as rename2, unlink as unlink2, mkdir as mkdir2, chmod as chmod2 } from "node:fs/promises";
+import { readFile as readFile2, writeFile as writeFile2, rename as rename2, unlink as unlink2, mkdir as mkdir2, chmod as chmod2, rm as rm2 } from "node:fs/promises";
+import { randomBytes as randomBytes3 } from "node:crypto";
 import { isAbsolute as isAbsolute2, join as join3 } from "node:path";
 function envTrustDir(env = process.env) {
   const raw = env[TRUST_DIR_ENV];
@@ -41557,10 +41917,15 @@ async function readExtensionPin(serverName, dir = defaultTrustDir()) {
 async function writeExtensionPin(serverName, pin, dir = defaultTrustDir()) {
   const path = extensionTrustPath(serverName, dir);
   await mkdir2(dir, { recursive: true, mode: 448 });
-  const tmp = `${path}.tmp`;
-  await writeFile2(tmp, JSON.stringify(pin, null, 2), { mode: 384 });
-  await chmod2(tmp, 384);
-  await rename2(tmp, path);
+  const tmp = `${path}.${randomBytes3(6).toString("hex")}.tmp`;
+  try {
+    await writeFile2(tmp, JSON.stringify(pin, null, 2), { mode: 384, flag: "wx" });
+    await chmod2(tmp, 384);
+    await rename2(tmp, path);
+  } catch (e) {
+    await rm2(tmp, { force: true });
+    throw e;
+  }
 }
 var TRUST_DIR_ENV, TRUST_NEW_EXTENSION_ENV;
 var init_extension_trust = __esm({
@@ -41640,6 +42005,7 @@ async function startHost(opts) {
     localStoragePointers: opts.ownLocalStoragePointers,
     sessionStoragePointers: opts.ownSessionStoragePointers,
     domSelectors: opts.ownDomSelectors,
+    domListSelectors: opts.ownDomListSelectors,
     graphqlOps: opts.ownGraphqlOps
   };
   const generateSessionKeypair = opts.generateSessionKeypair ?? generateX25519;
@@ -41710,6 +42076,31 @@ async function startHost(opts) {
       return null;
     }
   };
+  let ownDecryptFailures = 0;
+  const rehandshakeOwnSession = async (ws) => {
+    const hello = extensionHello;
+    if (extensionWs !== ws || !hello)
+      return;
+    console.warn(`[fetchproxy] ${opts.ownServerName}: ${OWN_DECRYPT_FAILURES_BEFORE_REHANDSHAKE} frames in a row from the extension failed authentication under this MCP's session key \u2014 re-handshaking this MCP's session (the extension stays connected).`);
+    ownSession = dropOwnSessionAndEphemeral();
+    resetSessionPromise();
+    const mintedKeypair = await generateSessionKeypair();
+    const mintedHello = await buildServerHello({
+      ...ownHelloBase,
+      sessionPub: mintedKeypair.publicKey,
+      answersExtNonce: fromB64(hello.sessionNonce)
+    });
+    if (extensionWs !== ws || extensionHello !== hello || ownSession !== null) {
+      mintedKeypair.privateKey.fill(0);
+      return;
+    }
+    installOwnEphemeral({
+      nonce: fromB64(mintedHello.sessionNonce),
+      pub: mintedKeypair.publicKey,
+      priv: mintedKeypair.privateKey
+    });
+    ws.send(JSON.stringify(mintedHello));
+  };
   wss.on("connection", (ws) => {
     let identified = null;
     let peerMcpId = null;
@@ -41900,6 +42291,7 @@ async function startHost(opts) {
             if (extensionWs !== ws)
               return;
             ownSession = new SessionState(key);
+            ownDecryptFailures = 0;
             ownPendingPairCode = null;
             resolveOwnSession(ownSession);
           } else {
@@ -41921,15 +42313,42 @@ async function startHost(opts) {
               }
               if (claim2 !== "ok")
                 return;
-              let inner;
+              let result;
               try {
-                inner = await openEncryptedFrame(session.sessionKey, frame, "e2s");
+                result = await openEncryptedFrameDetailed(session.sessionKey, frame, "e2s");
               } catch (e) {
                 session.releaseInboundSeq(frame.seq);
                 throw e;
               }
+              if (result.stage === "decrypt-failed") {
+                session.releaseInboundSeq(frame.seq);
+                console.warn(`[fetchproxy] ${opts.ownServerName}: dropped an inbound frame (seq ${frame.seq}) that failed authentication \u2014 most likely a straggler from a previous session.`);
+                if (session === ownSession) {
+                  ownDecryptFailures += 1;
+                  if (ownDecryptFailures >= OWN_DECRYPT_FAILURES_BEFORE_REHANDSHAKE) {
+                    ownDecryptFailures = 0;
+                    void rehandshakeOwnSession(ws).catch((e) => console.error(`[fetchproxy] ${opts.ownServerName}: re-handshake failed:`, e));
+                  }
+                }
+                return;
+              }
+              if (session === ownSession)
+                ownDecryptFailures = 0;
               session.commitInboundSeq(frame.seq);
-              ownInnerListeners.forEach((cb) => cb(inner));
+              if (result.stage === "ok") {
+                ownInnerListeners.forEach((cb) => cb(result.inner));
+              } else {
+                console.error("[fetchproxy] host: received a frame that decrypted OK but failed validation:", result.error);
+                const recoveredId = result.recoveredId;
+                if (recoveredId !== void 0) {
+                  ownInnerListeners.forEach((cb) => cb({
+                    type: "response",
+                    id: recoveredId,
+                    ok: false,
+                    error: `malformed response failed protocol validation: ${String(result.error)}`
+                  }));
+                }
+              }
             } else {
               const slot = peers.get(frame.mcpId);
               if (slot)
@@ -41988,6 +42407,7 @@ async function startHost(opts) {
           rejectOwnSession(new Error("extension disconnected before ready"));
         }
         ownSession = dropOwnSessionAndEphemeral();
+        ownDecryptFailures = 0;
         ownPendingPairCode = null;
         resetSessionPromise();
         disconnectListeners.forEach((cb) => cb());
@@ -42002,8 +42422,15 @@ async function startHost(opts) {
         }
       }
       if (identified === "peer" && peerMcpId) {
-        if (peers.get(peerMcpId)?.ws === ws)
+        if (peers.get(peerMcpId)?.ws === ws) {
           peers.delete(peerMcpId);
+          if (extensionWs && extensionHello?.accepts?.includes("peer-gone")) {
+            try {
+              extensionWs.send(JSON.stringify({ type: "peer-gone", mcpId: peerMcpId }));
+            } catch {
+            }
+          }
+        }
       }
     });
   });
@@ -42044,7 +42471,7 @@ async function startHost(opts) {
     sessionLinked: () => ownSession !== null
   };
 }
-var HTTP_ORIGIN_RE, PUBLIC_ORIGIN_RE, EXTENSION_ORIGIN_RE, OPAQUE_ORIGIN, ALLOW_LOCAL_ORIGINS_ENV, HANDSHAKE_TIMEOUT_MS, MAX_PAYLOAD_BYTES, enc4;
+var HTTP_ORIGIN_RE, PUBLIC_ORIGIN_RE, EXTENSION_ORIGIN_RE, OPAQUE_ORIGIN, ALLOW_LOCAL_ORIGINS_ENV, HANDSHAKE_TIMEOUT_MS, MAX_PAYLOAD_BYTES, enc4, OWN_DECRYPT_FAILURES_BEFORE_REHANDSHAKE;
 var init_host = __esm({
   "node_modules/@fetchproxy/server/dist/host.js"() {
     init_wrapper();
@@ -42062,15 +42489,21 @@ var init_host = __esm({
     HANDSHAKE_TIMEOUT_MS = 15e3;
     MAX_PAYLOAD_BYTES = MAX_FRAME_BYTES;
     enc4 = new TextEncoder();
+    OWN_DECRYPT_FAILURES_BEFORE_REHANDSHAKE = 3;
   }
 });
 
 // node_modules/@fetchproxy/server/dist/peer.js
+function notSentError() {
+  return new Error("fetchproxy: request not sent \u2014 the connection to the bridge host closed before it went out, so nothing reached the browser. It is safe to retry.");
+}
 async function startPeer(opts) {
   const ws = new import_websocket.default(`ws://${opts.host}:${opts.port}`, {
     maxPayload: opts.maxPayloadBytes ?? MAX_PAYLOAD_BYTES
   });
+  const dialTimeoutMs = opts.dialTimeoutMs ?? PEER_DIAL_TIMEOUT_MS;
   await new Promise((resolve2, reject) => {
+    let timer;
     const onOpen = () => {
       cleanup();
       resolve2();
@@ -42080,11 +42513,21 @@ async function startPeer(opts) {
       reject(e);
     };
     const cleanup = () => {
+      if (timer !== void 0)
+        clearTimeout(timer);
       ws.off("open", onOpen);
       ws.off("error", onError);
     };
     ws.once("open", onOpen);
     ws.once("error", onError);
+    if (dialTimeoutMs > 0) {
+      timer = setTimeout(() => {
+        cleanup();
+        ws.on("error", () => void 0);
+        ws.terminate();
+        reject(new Error(`fetchproxy: the process holding ${opts.host}:${opts.port} did not answer the WebSocket upgrade within ${dialTimeoutMs}ms \u2014 it may be wedged or not a fetchproxy host. Restart the MCP that owns the port (or free it) and retry.`));
+      }, dialTimeoutMs);
+    }
   });
   ws.on("error", (e) => {
     console.warn(`[fetchproxy] peer: socket error: ${String(e)}`);
@@ -42103,6 +42546,7 @@ async function startPeer(opts) {
     captureHeaders: opts.captureHeaders,
     indexedDbScopes: opts.indexedDbScopes,
     domSelectors: opts.domSelectors,
+    domListSelectors: opts.domListSelectors,
     localStoragePointers: opts.localStoragePointers,
     sessionStoragePointers: opts.sessionStoragePointers,
     graphqlOps: opts.graphqlOps,
@@ -42126,6 +42570,7 @@ async function startPeer(opts) {
   const renegotiateListeners = [];
   const pendingPairListeners = [];
   const closeListeners = [];
+  const extensionDisconnectListeners = [];
   let session = null;
   let sessionEphemeral = null;
   function dropSessionEphemeral() {
@@ -42145,10 +42590,24 @@ async function startPeer(opts) {
   let warnedUnverifiablePairCode = false;
   let resolveFirstReady;
   let rejectFirstReady;
-  const sessionPromise = new Promise((resolve2, reject) => {
-    resolveFirstReady = resolve2;
-    rejectFirstReady = reject;
-  });
+  let sessionPromise;
+  let sessionPromiseSettled = false;
+  function resetSessionPromise() {
+    sessionPromiseSettled = false;
+    sessionPromise = new Promise((resolve2, reject) => {
+      resolveFirstReady = (st) => {
+        sessionPromiseSettled = true;
+        resolve2(st);
+      };
+      rejectFirstReady = (e) => {
+        sessionPromiseSettled = true;
+        reject(e);
+      };
+    });
+    sessionPromise.catch(() => {
+    });
+  }
+  resetSessionPromise();
   let extensionHello = null;
   let extensionGone = false;
   let cachedPin = void 0;
@@ -42245,6 +42704,12 @@ async function startPeer(opts) {
         extensionGone = true;
         dropSessionEphemeral();
         pendingPairCode = null;
+        if (session !== null) {
+          session = null;
+          if (sessionPromiseSettled)
+            resetSessionPromise();
+        }
+        extensionDisconnectListeners.forEach((cb) => cb());
         return;
       }
       if (frame.type === "ready" && frame.mcpId === opts.mcpId) {
@@ -42361,19 +42826,30 @@ async function startPeer(opts) {
     }
     closeListeners.forEach((cb) => cb());
   });
-  sessionPromise.catch(() => {
-  });
   const handle = {
     ws,
-    session: sessionPromise,
+    // A getter: `extension-disconnected` replaces the promise (B-BUG-5).
+    get session() {
+      return sessionPromise;
+    },
     sendInner: async (inner) => {
-      await awaitSessionReady(sessionPromise, {
-        mcpId: opts.mcpId,
-        pendingPairCode: () => pendingPairCode
-      });
+      try {
+        await awaitSessionReady(sessionPromise, {
+          mcpId: opts.mcpId,
+          pendingPairCode: () => pendingPairCode
+        });
+      } catch (e) {
+        if (ws.readyState !== import_websocket.default.OPEN)
+          throw notSentError();
+        throw e;
+      }
       const s = session;
+      if (s === null)
+        throw new Error("peer: extension disconnected");
       const plaintext = encodeOutboundInnerFrame(opts.mcpId, inner);
       const sealed = await sealInnerFrame(s.sessionKey, opts.mcpId, s.nextOutboundSeq(), plaintext, "s2e");
+      if (ws.readyState !== import_websocket.default.OPEN)
+        throw notSentError();
       ws.send(JSON.stringify(sealed));
     },
     onInner: (cb) => {
@@ -42391,11 +42867,14 @@ async function startPeer(opts) {
     onClose: (cb) => {
       closeListeners.push(cb);
     },
+    onExtensionDisconnect: (cb) => {
+      extensionDisconnectListeners.push(cb);
+    },
     close: () => ws.close()
   };
   return handle;
 }
-var enc5;
+var PEER_DIAL_TIMEOUT_MS, enc5;
 var init_peer = __esm({
   "node_modules/@fetchproxy/server/dist/peer.js"() {
     init_wrapper();
@@ -42406,21 +42885,22 @@ var init_peer = __esm({
     init_session();
     init_session_ready();
     init_extension_trust();
+    PEER_DIAL_TIMEOUT_MS = 5e3;
     enc5 = new TextEncoder();
   }
 });
 
 // node_modules/@fetchproxy/server/dist/error-kind.js
 function classifyFetchError(error62) {
+  if (/^(in-page )?fetch threw:/.test(error62)) {
+    return "tab_fetch_failed";
+  }
   if (/Could not establish connection/i.test(error62) || /Receiving end does not exist/i.test(error62)) {
     return "content_script_unreachable";
   }
   if (/^tab fetch failed:/.test(error62)) {
     return "tab_fetch_failed";
   }
-  if (/^(in-page )?fetch threw:/.test(error62)) {
-    return "tab_fetch_failed";
-  }
   if (/^no tab matching /.test(error62)) {
     return "no_tab";
   }
@@ -42548,7 +43028,32 @@ function assertUrlInDomains(field, url2, domains) {
   const declared = domains.map((d) => JSON.stringify(d)).join(", ");
   throw new Error(`FetchproxyServer: ${field} host "${host}" is outside declared domains [${declared}] \u2014 must be one of them or a subdomain`);
 }
-var FetchproxyProtocolError, FetchproxyHttpError, FetchproxyBridgeDownError, FetchproxyHintedError, FetchproxyScopeError, FetchproxyNoTabError, FetchproxyTabOpeningError, FetchproxyWaitedError, SCOPE_REJECTION, NO_TAB_REJECTION, TAB_OPENING_REJECTION, VERB_DEADLINE_GRACE_MS, FetchproxyTimeoutError, SUBDOMAIN_LABEL_RE, DEFAULT_JSON_OK_STATUSES, FetchproxyServer;
+function parseJsonBody(response) {
+  if (response.status === 204 || response.body.trim() === "")
+    return null;
+  return JSON.parse(response.body);
+}
+function isRetrySafeOnTimeout(method, retryOnTimeout) {
+  if (retryOnTimeout !== void 0)
+    return retryOnTimeout;
+  return TIMEOUT_RETRY_SAFE_METHODS.has(method.toUpperCase());
+}
+function isResendableRequest(inner) {
+  switch (inner.op) {
+    case "fetch":
+      return isRetrySafeOnTimeout(inner.init.method);
+    case "write_cookies":
+    case "download":
+    // A declared GraphQL operation may be a mutation; the server holds only
+    // its name, so it cannot tell. `graphqlQuery({ retryOnTimeout: true })`
+    // passes `resendable` explicitly for a known query.
+    case "graphql_query":
+      return false;
+    default:
+      return true;
+  }
+}
+var FetchproxyProtocolError, FetchproxyHttpError, FetchproxyBridgeDownError, FetchproxyHintedError, FetchproxyScopeError, FetchproxyNoTabError, FetchproxyTabOpeningError, FetchproxyWaitedError, SCOPE_REJECTION, NO_TAB_REJECTION, TAB_OPENING_REJECTION, VERB_DEADLINE_GRACE_MS, FetchproxyTimeoutError, SUBDOMAIN_LABEL_RE, DEFAULT_JSON_OK_STATUSES, TIMEOUT_RETRY_SAFE_METHODS, FetchproxyServer;
 var init_ws_server = __esm({
   "node_modules/@fetchproxy/server/dist/ws-server.js"() {
     init_dist3();
@@ -42668,6 +43173,17 @@ var init_ws_server = __esm({
        * the message says which number that was and where it came from.
        */
       requestedTimeoutMs;
+      /**
+       * B-BUG-1: whether re-sending this request is safe. A timeout only means
+       * the reply did not arrive in time — the extension may already have run the
+       * request in the tab — so this is `false` for a non-idempotent `fetch`
+       * (anything but GET/HEAD/OPTIONS) the caller did not mark `retryOnTimeout`,
+       * for `download` and `writeCookies`, and for `graphqlQuery` unless the
+       * caller marked it `retryOnTimeout` (a declared operation may be a
+       * mutation). `retryOnceOnTimeout` honours it. Defaults to `true` (the read
+       * verbs).
+       */
+      retrySafe;
       constructor(args) {
         const graceMs = args.graceMs ?? VERB_DEADLINE_GRACE_MS;
         const callerChose = args.requestedTimeoutMs !== void 0 && args.timeoutMs === args.requestedTimeoutMs + graceMs;
@@ -42680,10 +43196,12 @@ var init_ws_server = __esm({
         this.elapsedMs = args.elapsedMs ?? args.timeoutMs;
         this.retryAttempted = args.retryAttempted ?? false;
         this.requestedTimeoutMs = args.requestedTimeoutMs ?? null;
+        this.retrySafe = args.retrySafe ?? true;
       }
     };
     SUBDOMAIN_LABEL_RE = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$/i;
     DEFAULT_JSON_OK_STATUSES = [200, 201, 202, 204];
+    TIMEOUT_RETRY_SAFE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
     FetchproxyServer = class {
       /**
        * Bridge role. `null` until the first verb call (or an explicit
@@ -42732,12 +43250,22 @@ var init_ws_server = __esm({
       pendingRedirect = /* @__PURE__ */ new Map();
       // 0.4.0+: read_indexed_db awaiters resolve a JSON-typed values map.
       pendingIdb = /* @__PURE__ */ new Map();
+      // 3.1.0+: read_dom_list awaiters resolve an array of field-value rows —
+      // a different shape from `pendingStorage`'s single map, so its own map.
+      pendingDomList = /* @__PURE__ */ new Map();
       // download awaiters resolve the saved-file metadata (path + size + mime).
       pendingDownload = /* @__PURE__ */ new Map();
       // 1.x+: graphql_query awaiters resolve the GraphQL `data` object. Its
       // shape is operation-specific, so the awaiter resolves `unknown` and the
       // caller narrows.
       pendingGraphql = /* @__PURE__ */ new Map();
+      /**
+       * B-BUG-6: the frames of in-flight requests that are safe to send again
+       * if the host that relayed them exits before replying (see
+       * `recoverFromHostLoss`). Keyed by request id; an entry outlives its
+       * request only until the next prune or response.
+       */
+      resendable = /* @__PURE__ */ new Map();
       mcpId = null;
       identity = null;
       // 0.5.3+: in-flight role-election / handle-start promise. Set the
@@ -42783,7 +43311,7 @@ var init_ws_server = __esm({
           }
           for (const c of opts.capabilities) {
             if (!KNOWN_CAPABILITIES.has(c)) {
-              throw new Error(`FetchproxyServer: unknown capability ${JSON.stringify(c)} \u2014 known values: ["fetch", "read_cookies"]`);
+              throw new Error(`FetchproxyServer: unknown capability ${JSON.stringify(c)} \u2014 known values: ${JSON.stringify([...KNOWN_CAPABILITIES])}`);
             }
           }
           capabilities = [...opts.capabilities];
@@ -42830,6 +43358,16 @@ var init_ws_server = __esm({
             selector: d.selector,
             ...d.attribute !== void 0 ? { attribute: d.attribute } : {}
           })),
+          domListSelectors: (opts.domListSelectors ?? []).map((d) => ({
+            name: d.name,
+            itemSelector: d.itemSelector,
+            fields: d.fields.map((f) => ({
+              name: f.name,
+              ...f.selector !== void 0 ? { selector: f.selector } : {},
+              ...f.attribute !== void 0 ? { attribute: f.attribute } : {}
+            })),
+            ...d.maxItems !== void 0 ? { maxItems: d.maxItems } : {}
+          })),
           graphqlOps: (opts.graphqlOps ?? []).map((d) => ({
             name: d.name,
             operationName: d.operationName
@@ -42959,6 +43497,7 @@ var init_ws_server = __esm({
             ownLocalStoragePointers: this.opts.localStoragePointers,
             ownSessionStoragePointers: this.opts.sessionStoragePointers,
             ownDomSelectors: this.opts.domSelectors,
+            ownDomListSelectors: this.opts.domListSelectors,
             ownGraphqlOps: this.opts.graphqlOps,
             onPairCode: this.opts.onPairCode,
             extensionTrust: this.extensionTrust()
@@ -42990,6 +43529,7 @@ var init_ws_server = __esm({
             localStoragePointers: this.opts.localStoragePointers,
             sessionStoragePointers: this.opts.sessionStoragePointers,
             domSelectors: this.opts.domSelectors,
+            domListSelectors: this.opts.domListSelectors,
             graphqlOps: this.opts.graphqlOps,
             extensionTrust: this.extensionTrust(),
             requireExtensionIdentity: this.opts.requireExtensionIdentity
@@ -42999,6 +43539,10 @@ var init_ws_server = __esm({
             this.stopKeepalive();
             this.rejectAllPending();
           });
+          this.peerHandle.onExtensionDisconnect(() => {
+            this.stopKeepalive();
+            this.rejectAllPending();
+          });
           this.peerHandle.onPendingPair((code) => {
             this.rejectAllPending(this.pairingErrorMessage(code));
           });
@@ -43010,9 +43554,9 @@ var init_ws_server = __esm({
             if (this.closing || this.peerHandle === null)
               return;
             this.stopKeepalive();
-            this.rejectAllPending();
             this.peerHandle = null;
             this.role = null;
+            void this.recoverFromHostLoss();
           });
         }
       }
@@ -43033,7 +43577,7 @@ var init_ws_server = __esm({
        * only when the bridge itself failed (no signed-in tab, extension
        * offline, etc.).
        */
-      async fetch(init) {
+      async fetch(init, fetchOpts = {}) {
         await this.ensureConnected();
         const pendingCode = this.currentPendingPairCode();
         if (pendingCode !== null) {
@@ -43045,16 +43589,17 @@ var init_ws_server = __esm({
             retryAttempted: false
           };
         }
-        const first = await this._fetchOnceWithTimeout(init);
+        const first = await this._fetchOnceWithTimeout(init, fetchOpts);
         const reviveMs = this.opts.bridgeReviveDelayMs;
         const isColdStartSymptom = !first.ok && (first.kind === "content_script_unreachable" || first.kind === "timeout");
         if (isColdStartSymptom) {
           this.lastEvictionDetectedAt = Date.now();
         }
-        if (isColdStartSymptom && reviveMs !== void 0 && reviveMs > 0) {
+        const retryable = isColdStartSymptom && (first.kind === "content_script_unreachable" || isRetrySafeOnTimeout(init.method, fetchOpts.retryOnTimeout));
+        if (retryable && reviveMs !== void 0 && reviveMs > 0) {
           this.lazyReviveAttempts += 1;
           await new Promise((r) => setTimeout(r, reviveMs));
-          const second = await this._fetchOnceWithTimeout(init);
+          const second = await this._fetchOnceWithTimeout(init, fetchOpts);
           if (second.ok) {
             this.lazyReviveSuccesses += 1;
             this.recordSuccess();
@@ -43203,13 +43748,16 @@ var init_ws_server = __esm({
        * one of the op maps — request ids are unique) so it doesn't leak until the
        * server closes, then rethrow.
        */
-      async sendInnerFrame(inner) {
+      async sendInnerFrame(inner, opts = {}) {
         try {
           if (this.hostHandle) {
             await this.hostHandle.sendOwnInner(inner);
           } else if (this.peerHandle) {
             await this.peerHandle.sendInner(inner);
           }
+          if (inner.type === "request" && (opts.resendable ?? isResendableRequest(inner))) {
+            this.noteResendable(inner);
+          }
         } catch (err) {
           if ("id" in inner && typeof inner.id === "number") {
             const { id } = inner;
@@ -43221,6 +43769,7 @@ var init_ws_server = __esm({
             this.pendingRedirect.delete(id);
             this.pendingDownload.delete(id);
             this.pendingIdb.delete(id);
+            this.pendingDomList.delete(id);
             this.pendingGraphql.delete(id);
           }
           throw err;
@@ -43231,13 +43780,25 @@ var init_ws_server = __esm({
        * On timeout returns the `{ok:false, kind:'timeout'}` envelope —
        * the throwing surface is the convenience methods.
        */
-      async _fetchOnceWithTimeout(init) {
+      async _fetchOnceWithTimeout(init, fetchOpts = {}) {
         const id = this.nextRequestId++;
         const inner = { type: "request", id, op: "fetch", init };
         const pending = this.guardPending(new Promise((resolve2) => {
           this.pending.set(id, resolve2);
         }));
-        await this.sendInnerFrame(inner);
+        try {
+          await this.sendInnerFrame(inner, {
+            resendable: isRetrySafeOnTimeout(init.method, fetchOpts.retryOnTimeout)
+          });
+        } catch (err) {
+          return {
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+            kind: "session_not_ready",
+            retryAttempted: false,
+            cause: err
+          };
+        }
         const timeoutMs = this.opts.fetchTimeoutMs;
         if (timeoutMs === void 0 || timeoutMs <= 0)
           return pending;
@@ -43311,7 +43872,7 @@ var init_ws_server = __esm({
         });
         return pending;
       }
-      async _withVerbTimeout(pending, pendingMap, id, url2, requestedTimeoutMs) {
+      async _withVerbTimeout(pending, pendingMap, id, url2, requestedTimeoutMs, retrySafe = true) {
         const transportMs = this.opts.fetchTimeoutMs;
         if (transportMs === void 0 || transportMs <= 0)
           return pending;
@@ -43332,6 +43893,7 @@ var init_ws_server = __esm({
                   port: this.opts.port,
                   elapsedMs: Date.now() - start,
                   retryAttempted: false,
+                  retrySafe,
                   graceMs,
                   ...requestedTimeoutMs !== void 0 ? { requestedTimeoutMs } : {}
                 }));
@@ -43349,7 +43911,7 @@ var init_ws_server = __esm({
        * logic re-implemented inline) `captureRequestHeader()` agree on what
        * to throw.
        */
-      _typedErrorFor(result, url2, op, retryAttempted) {
+      _typedErrorFor(result, url2, op, retryAttempted, retrySafe = true) {
         if (result.kind === "timeout") {
           return new FetchproxyTimeoutError({
             url: url2,
@@ -43357,7 +43919,8 @@ var init_ws_server = __esm({
             role: this.role,
             port: this.opts.port,
             elapsedMs: result.elapsedMs,
-            retryAttempted
+            retryAttempted,
+            retrySafe
           });
         }
         if (result.kind === "content_script_unreachable") {
@@ -43431,9 +43994,12 @@ var init_ws_server = __esm({
           // every version before this option existed.
           ...opts.credentials === "omit" ? { credentials: "omit" } : {}
         };
-        const result = await this.fetch(init);
+        const result = await this.fetch(init, opts.retryOnTimeout !== void 0 ? { retryOnTimeout: opts.retryOnTimeout } : {});
         if (!result.ok) {
-          throw this._typedErrorFor(result, init.url, "fetch", result.retryAttempted ?? false);
+          if (result.kind === "session_not_ready" && result.cause instanceof Error) {
+            throw result.cause;
+          }
+          throw this._typedErrorFor(result, init.url, "fetch", result.retryAttempted ?? false, isRetrySafeOnTimeout(method, opts.retryOnTimeout));
         }
         const response = {
           status: result.status,
@@ -43473,17 +44039,21 @@ var init_ws_server = __esm({
        * GET a path and parse the response body as JSON. Throws
        * `FetchproxyHttpError` if the status is outside the default 2xx
        * happy-path set (`[200, 201, 202, 204]`); pass a custom
-       * `expectStatus` to override.
+       * `expectStatus` to override. A 204 or an empty/whitespace body
+       * resolves to `null` (the declared `T` does not say so, to keep
+       * existing call sites compiling — include `| null` in `T` if the
+       * endpoint can answer empty).
        */
       async getJson(path, opts = {}) {
         const response = await this.get(path, this.applyJsonDefaults(opts));
-        return JSON.parse(response.body);
+        return parseJsonBody(response);
       }
       /**
        * POST a JSON body and parse the response body as JSON. The body is
        * `JSON.stringify`'d; `Content-Type: application/json` is set unless
        * the caller already provided one. Defaults `expectStatus` to the 2xx
-       * happy-path set.
+       * happy-path set. A 204 or an empty/whitespace body resolves to `null`
+       * rather than throwing after the write already happened (see `getJson`).
        */
       async postJson(path, body, opts = {}) {
         const headers = { ...opts.headers ?? {} };
@@ -43495,7 +44065,7 @@ var init_ws_server = __esm({
           headers,
           body: body === void 0 ? void 0 : JSON.stringify(body)
         });
-        return JSON.parse(response.body);
+        return parseJsonBody(response);
       }
       /**
        * GET a path and return the response body as a string. Throws
@@ -43516,7 +44086,8 @@ var init_ws_server = __esm({
        *  - adds `Content-Type: application/json` only for a non-GET request
        *    that carries a `body` (and only if the caller didn't set one);
        *  - `JSON.stringify`s the body (GET / no-body sends nothing);
-       *  - treats a `204` or an empty body as `data: null` (no parse);
+       *  - treats a `204`, an empty body, or a whitespace-only body as
+       *    `data: null` (no parse), the same rule as getJson/postJson;
        *  - otherwise `JSON.parse`s the body.
        *
        * Scope is serialization + header defaults + 204-handling +
@@ -43530,6 +44101,11 @@ var init_ws_server = __esm({
        * Bridge-level failures (no signed-in tab, SW down, timeout) still
        * throw the typed errors via `request()`, exactly like the verb
        * helpers — only successful round-trips (any HTTP status) return.
+       *
+       * `retryOnTimeout` is `RequestOpts.retryOnTimeout`: a timed-out POST is
+       * NOT re-sent unless the caller says it is safe to repeat. A read-only POST
+       * (a search, a GraphQL query) should pass `true` to keep the cold-start
+       * timeout retry (#90).
        */
       async requestJson(method, path, opts = {}) {
         const isGet = method.toUpperCase() === "GET";
@@ -43543,7 +44119,8 @@ var init_ws_server = __esm({
           headers,
           body: sendBody ? JSON.stringify(opts.body) : void 0,
           ...opts.subdomain !== void 0 ? { subdomain: opts.subdomain } : {},
-          ...opts.domain !== void 0 ? { domain: opts.domain } : {}
+          ...opts.domain !== void 0 ? { domain: opts.domain } : {},
+          ...opts.retryOnTimeout !== void 0 ? { retryOnTimeout: opts.retryOnTimeout } : {}
         });
         const result = {
           ok: true,
@@ -43551,12 +44128,9 @@ var init_ws_server = __esm({
           url: response.url,
           body: response.body
         };
-        if (response.status === 204 || response.body === "") {
-          return { data: null, result };
-        }
         let data;
         try {
-          data = JSON.parse(response.body);
+          data = parseJsonBody(response);
         } catch (e) {
           throw new Error(`fetchproxy ${method} ${path} \u2014 response was not JSON: ${e instanceof Error ? e.message : String(e)}`);
         }
@@ -43613,18 +44187,19 @@ var init_ws_server = __esm({
         };
       }
       /**
-       * Snapshot the user's non-HttpOnly cookies for the chosen domain.
+       * Read the user's cookies for the chosen domain.
        *
        * Requires `'read_cookies'` in `FetchproxyServerOpts.capabilities`.
        * Throws a developer-facing `Error` at the call site if the MCP did
        * not declare the capability — this is a programming mistake, not a
        * runtime condition.
        *
-       * The returned string is the raw `document.cookie` value (semicolon-
-       * separated `k=v` pairs). HttpOnly cookies are NOT visible to page JS
-       * and are therefore not included; the underlying threat model assumes
-       * the cookies that matter for the auth bootstrap (session tokens, csrf
-       * cookies that the page itself reads) are non-HttpOnly.
+       * The returned string is semicolon-separated `k=v` pairs. With `keys`
+       * (each in the declared `cookieKeys`), the extension reads each name via
+       * `chrome.cookies.get`, which INCLUDES HttpOnly cookies — the login
+       * session cookie among them; that is what cookie-session MCPs use it
+       * for. Without `keys` (legacy), it is the tab's `document.cookie`, which
+       * omits HttpOnly cookies. See docs/SECURITY.md §T-cookie-exfil.
        *
        * Throws `FetchproxyProtocolError` if the bridge could not deliver
        * the request (no signed-in tab, extension offline, etc.).
@@ -43720,7 +44295,15 @@ var init_ws_server = __esm({
           this.pendingWriteCookies.set(id, { resolve: resolve2, reject });
         }));
         await this.sendInnerFrame(inner);
-        return this._withVerbTimeout(pending, this.pendingWriteCookies, id, `https://${host}`);
+        return this._withVerbTimeout(
+          pending,
+          this.pendingWriteCookies,
+          id,
+          `https://${host}`,
+          void 0,
+          // A write: never re-sent after an ambiguous timeout.
+          false
+        );
       }
       /**
        * 0.3.0+: read declared localStorage keys from the user's signed-in
@@ -43823,53 +44406,7 @@ var init_ws_server = __esm({
           throw new Error("FetchproxyServer.captureRequestHeader: pass both host AND headerName, or neither (which defaults to the single declared entry)");
         }
         const callOpts = { ...resolved, ...opts?.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {} };
-        try {
-          const result = await this._captureRequestHeaderOnce(callOpts);
-          this.recordSuccess();
-          return result;
-        } catch (err) {
-          const swDown = err instanceof FetchproxyProtocolError && classifyFetchError(err.message) === "content_script_unreachable";
-          if (!swDown) {
-            this.recordFailure(`capture_request_header: ${err.message ?? String(err)}`);
-            throw err;
-          }
-          this.lastEvictionDetectedAt = Date.now();
-          const reviveMs = this.opts.bridgeReviveDelayMs ?? 0;
-          if (reviveMs > 0) {
-            this.lazyReviveAttempts += 1;
-            await new Promise((r) => setTimeout(r, reviveMs));
-            try {
-              const result = await this._captureRequestHeaderOnce(callOpts);
-              this.lazyReviveSuccesses += 1;
-              this.recordSuccess();
-              return result;
-            } catch (retryErr) {
-              const stillDown = retryErr instanceof FetchproxyProtocolError && classifyFetchError(retryErr.message) === "content_script_unreachable";
-              if (!stillDown) {
-                this.recordFailure(`capture_request_header: ${retryErr.message ?? String(retryErr)}`);
-                throw retryErr;
-              }
-              this.recordFailure(`capture_request_header bridge-down: ${retryErr.message}`);
-              throw new FetchproxyBridgeDownError({
-                originalError: retryErr.message,
-                retryAttempted: true,
-                op: "capture_request_header",
-                url: `https://${resolved.host}${resolved.path ?? "/*"}`,
-                role: this.role,
-                port: this.opts.port
-              });
-            }
-          }
-          this.recordFailure(`capture_request_header bridge-down: ${err.message}`);
-          throw new FetchproxyBridgeDownError({
-            originalError: err.message,
-            retryAttempted: false,
-            op: "capture_request_header",
-            url: `https://${resolved.host}${resolved.path ?? "/*"}`,
-            role: this.role,
-            port: this.opts.port
-          });
-        }
+        return this.withLazyRevive("capture_request_header", `https://${resolved.host}${resolved.path ?? "/*"}`, () => this._captureRequestHeaderOnce(callOpts));
       }
       async _captureRequestHeaderOnce(opts) {
         const id = this.nextRequestId++;
@@ -43918,53 +44455,7 @@ var init_ws_server = __esm({
         }
         await this.ensureConnected();
         this.throwIfPendingPair();
-        try {
-          const result = await this._captureRedirectOnce(opts);
-          this.recordSuccess();
-          return result;
-        } catch (err) {
-          const swDown = err instanceof FetchproxyProtocolError && classifyFetchError(err.message) === "content_script_unreachable";
-          if (!swDown) {
-            this.recordFailure(`capture_redirect: ${err.message ?? String(err)}`);
-            throw err;
-          }
-          this.lastEvictionDetectedAt = Date.now();
-          const reviveMs = this.opts.bridgeReviveDelayMs ?? 0;
-          if (reviveMs > 0) {
-            this.lazyReviveAttempts += 1;
-            await new Promise((r) => setTimeout(r, reviveMs));
-            try {
-              const result = await this._captureRedirectOnce(opts);
-              this.lazyReviveSuccesses += 1;
-              this.recordSuccess();
-              return result;
-            } catch (retryErr) {
-              const stillDown = retryErr instanceof FetchproxyProtocolError && classifyFetchError(retryErr.message) === "content_script_unreachable";
-              if (!stillDown) {
-                this.recordFailure(`capture_redirect: ${retryErr.message ?? String(retryErr)}`);
-                throw retryErr;
-              }
-              this.recordFailure(`capture_redirect bridge-down: ${retryErr.message}`);
-              throw new FetchproxyBridgeDownError({
-                originalError: retryErr.message,
-                retryAttempted: true,
-                op: "capture_redirect",
-                url: `https://${opts.host}${opts.path ?? "/*"}`,
-                role: this.role,
-                port: this.opts.port
-              });
-            }
-          }
-          this.recordFailure(`capture_redirect bridge-down: ${err.message}`);
-          throw new FetchproxyBridgeDownError({
-            originalError: err.message,
-            retryAttempted: false,
-            op: "capture_redirect",
-            url: `https://${opts.host}${opts.path ?? "/*"}`,
-            role: this.role,
-            port: this.opts.port
-          });
-        }
+        return this.withLazyRevive("capture_redirect", `https://${opts.host}${opts.path ?? "/*"}`, () => this._captureRedirectOnce(opts));
       }
       async _captureRedirectOnce(opts) {
         const id = this.nextRequestId++;
@@ -44009,52 +44500,57 @@ var init_ws_server = __esm({
         assertUrlInDomains("download url", opts.url, this.opts.domains);
         await this.ensureConnected();
         this.throwIfPendingPair();
+        return this.withLazyRevive("download", opts.url, () => this._downloadOnce(opts));
+      }
+      /**
+       * B-QUAL-1: the lazy-revive policy for the throwing verbs
+       * (`capture_request_header`, `capture_redirect`, `download`), in one place.
+       * Runs `once`; on the SW-eviction symptom (`content_script_unreachable` —
+       * the request provably never reached a tab, so re-sending is safe) stamps
+       * the eviction counter, waits `bridgeReviveDelayMs` and retries once, then
+       * surfaces a `FetchproxyBridgeDownError`. Every other error is recorded and
+       * rethrown untouched. `fetch()` keeps its own envelope-shaped variant.
+       */
+      async withLazyRevive(op, url2, once) {
+        const isSwDown = (e) => e instanceof FetchproxyProtocolError && classifyFetchError(e.message) === "content_script_unreachable";
+        const bridgeDown = (e, retryAttempted) => {
+          this.recordFailure(`${op} bridge-down: ${e.message}`);
+          return new FetchproxyBridgeDownError({
+            originalError: e.message,
+            retryAttempted,
+            op,
+            url: url2,
+            role: this.role,
+            port: this.opts.port
+          });
+        };
         try {
-          const result = await this._downloadOnce(opts);
+          const result = await once();
           this.recordSuccess();
           return result;
         } catch (err) {
-          const swDown = err instanceof FetchproxyProtocolError && classifyFetchError(err.message) === "content_script_unreachable";
-          if (!swDown) {
-            this.recordFailure(`download: ${err.message ?? String(err)}`);
+          if (!isSwDown(err)) {
+            this.recordFailure(`${op}: ${err.message ?? String(err)}`);
             throw err;
           }
           this.lastEvictionDetectedAt = Date.now();
           const reviveMs = this.opts.bridgeReviveDelayMs ?? 0;
-          if (reviveMs > 0) {
-            this.lazyReviveAttempts += 1;
-            await new Promise((r) => setTimeout(r, reviveMs));
-            try {
-              const result = await this._downloadOnce(opts);
-              this.lazyReviveSuccesses += 1;
-              this.recordSuccess();
-              return result;
-            } catch (retryErr) {
-              const stillDown = retryErr instanceof FetchproxyProtocolError && classifyFetchError(retryErr.message) === "content_script_unreachable";
-              if (!stillDown) {
-                this.recordFailure(`download: ${retryErr.message ?? String(retryErr)}`);
-                throw retryErr;
-              }
-              this.recordFailure(`download bridge-down: ${retryErr.message}`);
-              throw new FetchproxyBridgeDownError({
-                originalError: retryErr.message,
-                retryAttempted: true,
-                op: "download",
-                url: opts.url,
-                role: this.role,
-                port: this.opts.port
-              });
+          if (reviveMs <= 0)
+            throw bridgeDown(err, false);
+          this.lazyReviveAttempts += 1;
+          await new Promise((r) => setTimeout(r, reviveMs));
+          try {
+            const result = await once();
+            this.lazyReviveSuccesses += 1;
+            this.recordSuccess();
+            return result;
+          } catch (retryErr) {
+            if (!isSwDown(retryErr)) {
+              this.recordFailure(`${op}: ${retryErr.message ?? String(retryErr)}`);
+              throw retryErr;
             }
+            throw bridgeDown(retryErr, true);
           }
-          this.recordFailure(`download bridge-down: ${err.message}`);
-          throw new FetchproxyBridgeDownError({
-            originalError: err.message,
-            retryAttempted: false,
-            op: "download",
-            url: opts.url,
-            role: this.role,
-            port: this.opts.port
-          });
         }
       }
       async _downloadOnce(opts) {
@@ -44083,7 +44579,9 @@ var init_ws_server = __esm({
           // CAP and need the identical explanation; missing it then was the point
           // of #279 — "both verbs" was counted off the two call sites in view
           // rather than off the type. Three is still the number.
-          opts.timeoutMs
+          opts.timeoutMs,
+          // A second download saves a duplicate "file (1)".
+          false
         );
       }
       /**
@@ -44174,6 +44672,52 @@ var init_ws_server = __esm({
         await this.sendInnerFrame(inner);
         return this._withVerbTimeout(pending, this.pendingStorage, id, origin);
       }
+      /**
+       * 3.1.0+: read a declared REPEATED DOM structure from the user's
+       * signed-in tab. Requires `'read_dom_list'` in capabilities AND `name` to
+       * match a declared `domListSelectors` entry. The extension resolves the
+       * entry's `itemSelector` via `document.querySelectorAll` in the matched
+       * tab's DOM (isolated world), then resolves each declared field against
+       * every matched item in turn — no page-JS execution, same as `readDom`.
+       *
+       * Returns one row per matched item, in document order, truncated to the
+       * entry's declared `maxItems` when set. A field absent on a given item is
+       * omitted from that item's row (the row itself is still returned). Throws
+       * `FetchproxyProtocolError` on bridge failures and a plain `Error` on
+       * developer mistakes (undeclared capability, undeclared name).
+       *
+       * Reads only what is CURRENTLY rendered — a virtualized or lazily-loaded
+       * list returns only its visible rows. A caller that needs more scrolls
+       * the list (out of band) and calls again.
+       */
+      async readDomList(opts) {
+        if (!this.opts.capabilities.includes("read_dom_list")) {
+          throw new Error('FetchproxyServer.readDomList(): MCP did not declare "read_dom_list" in capabilities');
+        }
+        await this.ensureConnected();
+        this.throwIfPendingPair();
+        if (typeof opts.name !== "string" || opts.name.length === 0) {
+          throw new Error("FetchproxyServer.readDomList: opts.name must be a non-empty string");
+        }
+        this.assertScopeSubset([opts.name], this.opts.domListSelectors.map((d) => d.name), "domListSelectors");
+        if (opts.subdomain !== void 0)
+          assertSubdomainLabel(opts.subdomain);
+        const baseDomain = this.resolveBaseDomain(opts.domain);
+        const host = opts.subdomain ? `${opts.subdomain}.${baseDomain}` : baseDomain;
+        const origin = `https://${host}`;
+        const id = this.nextRequestId++;
+        const inner = {
+          type: "request",
+          id,
+          op: "read_dom_list",
+          init: { origin, name: opts.name }
+        };
+        const pending = this.guardPending(new Promise((resolve2, reject) => {
+          this.pendingDomList.set(id, { resolve: resolve2, reject });
+        }));
+        await this.sendInnerFrame(inner);
+        return this._withVerbTimeout(pending, this.pendingDomList, id, origin);
+      }
       /**
        * 1.x+: run a declared GraphQL operation through the page's own Apollo
        * client (`window.__APOLLO_CLIENT__`) in the signed-in tab's MAIN world.
@@ -44217,8 +44761,9 @@ var init_ws_server = __esm({
         const pending = this.guardPending(new Promise((resolve2, reject) => {
           this.pendingGraphql.set(id, { resolve: resolve2, reject });
         }));
-        await this.sendInnerFrame(inner);
-        return this._withVerbTimeout(pending, this.pendingGraphql, id, opts.name);
+        const retrySafe = opts.retryOnTimeout === true;
+        await this.sendInnerFrame(inner, { resendable: retrySafe });
+        return this._withVerbTimeout(pending, this.pendingGraphql, id, opts.name, void 0, retrySafe);
       }
       assertScopeSubset(requested, declared, label) {
         const undeclared = undeclaredKeys(requested, declared);
@@ -44255,6 +44800,7 @@ var init_ws_server = __esm({
       onInner(inner) {
         if (inner.type !== "response")
           return;
+        this.resendable.delete(inner.id);
         this.lastExtensionMessageAt = Date.now();
         const fetchCb = this.pending.get(inner.id);
         if (fetchCb) {
@@ -44343,6 +44889,20 @@ var init_ws_server = __esm({
           }
           return;
         }
+        const domListCb = this.pendingDomList.get(inner.id);
+        if (domListCb) {
+          this.pendingDomList.delete(inner.id);
+          if (inner.ok) {
+            if (inner.op === "read_dom_list" && inner.rows) {
+              domListCb.resolve(inner.rows.map((row) => ({ ...row })));
+            } else {
+              domListCb.reject(new FetchproxyProtocolError(`unexpected ${String(inner.op)} response on read_dom_list awaiter`));
+            }
+          } else {
+            domListCb.reject(protocolErrorFrom(inner.error));
+          }
+          return;
+        }
         const downloadCb = this.pendingDownload.get(inner.id);
         if (downloadCb) {
           this.pendingDownload.delete(inner.id);
@@ -44402,42 +44962,133 @@ var init_ws_server = __esm({
           }
         }
       }
-      rejectAllPending(reason = "extension disconnected") {
+      rejectAllPending(reason = "extension disconnected", keep = /* @__PURE__ */ new Set()) {
+        for (const id of this.allPendingIds()) {
+          if (!keep.has(id))
+            this.rejectPendingId(id, reason);
+        }
+        if (keep.size === 0)
+          this.resendable.clear();
+      }
+      /** Every request id with a live awaiter, across all op maps. */
+      allPendingIds() {
+        const ids = [];
+        for (const map2 of this.pendingMaps())
+          for (const id of map2.keys())
+            ids.push(id);
+        return ids;
+      }
+      pendingMaps() {
+        return [
+          this.pending,
+          this.pendingReadCookies,
+          this.pendingStorage,
+          this.pendingWriteCookies,
+          this.pendingCapture,
+          this.pendingRedirect,
+          this.pendingIdb,
+          this.pendingDomList,
+          this.pendingDownload,
+          this.pendingGraphql
+        ];
+      }
+      isPendingId(id) {
+        return this.pendingMaps().some((m) => m.has(id));
+      }
+      /** Fail the one awaiter registered under `id`, in its own map's shape. */
+      rejectPendingId(id, reason) {
         const err = new FetchproxyProtocolError(reason);
-        for (const cb of this.pending.values()) {
-          cb({
+        this.resendable.delete(id);
+        const fetchCb = this.pending.get(id);
+        if (fetchCb) {
+          this.pending.delete(id);
+          fetchCb({
             ok: false,
             error: err.message,
             kind: classifyFetchError(err.message),
             retryAttempted: false
           });
+          return;
+        }
+        const cookieCb = this.pendingReadCookies.get(id);
+        if (cookieCb) {
+          this.pendingReadCookies.delete(id);
+          cookieCb({ ok: false, error: err.message });
+          return;
+        }
+        for (const map2 of [
+          this.pendingStorage,
+          this.pendingWriteCookies,
+          this.pendingCapture,
+          this.pendingRedirect,
+          this.pendingIdb,
+          this.pendingDomList,
+          this.pendingDownload,
+          this.pendingGraphql
+        ]) {
+          const entry = map2.get(id);
+          if (entry) {
+            map2.delete(id);
+            entry.reject(err);
+            return;
+          }
         }
-        this.pending.clear();
-        for (const cb of this.pendingReadCookies.values()) {
-          cb({ ok: false, error: err.message });
-        }
-        this.pendingReadCookies.clear();
-        for (const { reject } of this.pendingStorage.values())
-          reject(err);
-        this.pendingStorage.clear();
-        for (const { reject } of this.pendingWriteCookies.values())
-          reject(err);
-        this.pendingWriteCookies.clear();
-        for (const { reject } of this.pendingCapture.values())
-          reject(err);
-        this.pendingCapture.clear();
-        for (const { reject } of this.pendingRedirect.values())
-          reject(err);
-        this.pendingRedirect.clear();
-        for (const { reject } of this.pendingIdb.values())
-          reject(err);
-        this.pendingIdb.clear();
-        for (const { reject } of this.pendingDownload.values())
-          reject(err);
-        this.pendingDownload.clear();
-        for (const { reject } of this.pendingGraphql.values())
-          reject(err);
-        this.pendingGraphql.clear();
+      }
+      noteResendable(inner) {
+        this.resendable.set(inner.id, inner);
+        if (this.resendable.size > 256) {
+          for (const id of [...this.resendable.keys()]) {
+            if (!this.isPendingId(id))
+              this.resendable.delete(id);
+          }
+        }
+      }
+      /**
+       * B-BUG-6: the host this peer relayed through has gone — most often a
+       * short-lived process (a bootstrap lift, an `fpx` call) that won the
+       * election and then closed. Fail only the in-flight requests that may
+       * already have run (a non-idempotent fetch, a cookie write, a download);
+       * re-elect and send the rest again. The replies to the originals died with
+       * the old host, and each re-sent request keeps its awaiter and its
+       * original deadline.
+       */
+      async recoverFromHostLoss() {
+        const toResend = /* @__PURE__ */ new Map();
+        for (const [id, inner] of this.resendable) {
+          if (this.isPendingId(id))
+            toResend.set(id, inner);
+        }
+        this.resendable.clear();
+        this.rejectAllPending("fetchproxy: the MCP process holding the bridge port exited while this request was in flight. It was not re-sent because it may already have run in the browser \u2014 check before retrying.", new Set(toResend.keys()));
+        if (toResend.size === 0)
+          return;
+        const lost = (id, e) => this.rejectPendingId(id, `fetchproxy: the bridge host exited and reconnecting failed: ${e instanceof Error ? e.message : String(e)}`);
+        try {
+          await this.ensureConnected();
+        } catch (e) {
+          for (const id of toResend.keys())
+            lost(id, e);
+          return;
+        }
+        for (const [id, inner] of toResend) {
+          if (!this.isPendingId(id))
+            continue;
+          try {
+            await this.resendInnerFrame(inner);
+          } catch (e) {
+            lost(id, e);
+          }
+        }
+      }
+      /** Send an already-registered request again, keeping its awaiter on failure. */
+      async resendInnerFrame(inner) {
+        if (this.hostHandle)
+          await this.hostHandle.sendOwnInner(inner);
+        else if (this.peerHandle)
+          await this.peerHandle.sendInner(inner);
+        else
+          throw new Error("no bridge handle after re-election");
+        this.noteResendable(inner);
       }
       /**
        * 0.5.2+: read the current pair-pending pair code from whichever handle
@@ -44802,7 +45453,8 @@ function createFetchproxyTransport(opts) {
         ...init.headers !== void 0 ? { headers: init.headers } : {},
         ...init.body !== void 0 ? { body: init.body } : {},
         ...init.subdomain !== void 0 ? { subdomain: init.subdomain } : {},
-        ...init.domain !== void 0 ? { domain: init.domain } : {}
+        ...init.domain !== void 0 ? { domain: init.domain } : {},
+        ...init.retryOnTimeout !== void 0 ? { retryOnTimeout: init.retryOnTimeout } : {}
       }));
       return { status: response.status, body: response.body, url: response.url };
     },
@@ -44811,7 +45463,8 @@ function createFetchproxyTransport(opts) {
         ...init.headers !== void 0 ? { headers: init.headers } : {},
         ...init.body !== void 0 ? { body: init.body } : {},
         ...init.subdomain !== void 0 ? { subdomain: init.subdomain } : {},
-        ...init.domain !== void 0 ? { domain: init.domain } : {}
+        ...init.domain !== void 0 ? { domain: init.domain } : {},
+        ...init.retryOnTimeout !== void 0 ? { retryOnTimeout: init.retryOnTimeout } : {}
       }));
       return {
         data,
@@ -45136,7 +45789,39 @@ function defaultIsRefreshRevoked(err) {
     return false;
   if (err instanceof ApiError && err.status >= 500)
     return false;
-  return true;
+  return !isTransientFailure(err);
+}
+function isPersistenceFailure(err) {
+  return err !== null && typeof err === "object" && err.persistenceFailure === true;
+}
+var TRANSIENT_NETWORK_CODES = /* @__PURE__ */ new Set([
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ECONNABORTED",
+  "ETIMEDOUT",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "ENETUNREACH",
+  "ENETDOWN",
+  "EHOSTUNREACH",
+  "EPIPE"
+]);
+function isTransientFailure(err) {
+  let cur = err;
+  for (let depth = 0; depth < 4 && cur !== null && typeof cur === "object"; depth++) {
+    const e = cur;
+    if (typeof e.status === "number" && (e.status >= 500 || e.status === 429 || e.status === 408))
+      return true;
+    if (e.name === "AbortError" || e.name === "TimeoutError")
+      return true;
+    if (typeof e.code === "string" && (TRANSIENT_NETWORK_CODES.has(e.code) || e.code.startsWith("UND_ERR_"))) {
+      return true;
+    }
+    if (e.name === "TypeError" && e.message === "fetch failed")
+      return true;
+    cur = e.cause;
+  }
+  return false;
 }
 function isBearerTokens(raw) {
   if (raw === null || typeof raw !== "object")
@@ -45303,6 +45988,8 @@ var TokenManager = class {
   async reBootstrap(err) {
     if (err instanceof StatePersistenceError)
       throw err.cause;
+    if (isPersistenceFailure(err))
+      throw err;
     if (this.bootstrapFn === void 0)
       throw err;
     if (!this.isRefreshRevokedFn(err))
@@ -45318,6 +46005,10 @@ var TokenManager = class {
       try {
         await this.refreshNow();
       } catch (err) {
+        const held = this.tokens;
+        if (!(err instanceof StatePersistenceError) && held !== void 0 && this.now() < held.expiresAt && !this.isRefreshRevokedFn(err)) {
+          return held.accessToken;
+        }
         return (await this.reBootstrap(err)).accessToken;
       }
       tokens = this.tokens ?? tokens;
@@ -45532,17 +46223,33 @@ var OutlookClient = class {
       headers: prefer.length ? { Prefer: prefer.join(", ") } : void 0
     });
   }
-  /** GET an absolute URL — used only to follow `@odata.nextLink`. */
-  async getAbsolute(url2) {
+  /**
+   * GET an absolute URL — used only to follow `@odata.nextLink`.
+   *
+   * The link is absolute and already carries the base path
+   * (`https://outlook.office.com/api/v2.0/me/messages?$skip=25`), while the
+   * underlying client appends every path to that same base. So the base path is
+   * stripped here, and a link that is not under it — another origin, or another
+   * path on the same host — is refused rather than sent the bearer token.
+   */
+  async getAbsolute(url2, opts = {}) {
     this.#requireConfigured();
     const base = new URL(this.#baseUrl);
-    const target = new URL(url2);
-    if (target.origin !== base.origin) {
-      throw new McpToolError(`Refusing to follow a link to ${target.origin}.`, {
-        hint: "Pagination links must stay on the Outlook API host."
+    let target;
+    try {
+      target = new URL(url2);
+    } catch {
+      throw new McpToolError(`Refusing to follow a link that is not a URL: ${url2}`, {
+        hint: "Pass the nextLink value exactly as a previous listing returned it."
+      });
+    }
+    const prefix = base.pathname.replace(/\/+$/, "");
+    if (target.origin !== base.origin || !(target.pathname === prefix || target.pathname.startsWith(`${prefix}/`))) {
+      throw new McpToolError(`Refusing to follow a link to ${target.origin}${target.pathname}.`, {
+        hint: `Pagination links must stay under the Outlook API base (${this.#baseUrl}).`
       });
     }
-    return this.#client().fetchJson("GET", target.pathname + target.search);
+    return this.get(target.pathname.slice(prefix.length) + target.search, opts);
   }
   /**
    * The single write path. Everything mutating goes through here so auth and
@@ -45682,6 +46389,22 @@ function projectCollection(payload, project, label) {
   });
 }
 
+// src/tools/_paging.ts
+init_zod();
+var nextLinkParam = external_exports.string().min(1).optional().describe(
+  "Continue a previous listing: pass its `nextLink` value unchanged to fetch the next page. When set, the paging/filter arguments are taken from the link and ignored here."
+);
+function fetchPage(client2, nextLink, path, opts = {}) {
+  return nextLink !== void 0 ? client2.getAbsolute(nextLink, opts) : client2.get(path, opts);
+}
+function plainCollection(data) {
+  const items = Array.isArray(data?.value) ? data.value : [];
+  const out = { count: items.length, items: items.map(stripOData) };
+  const next = data?.["@odata.nextLink"];
+  if (next) out.nextLink = next;
+  return out;
+}
+
 // src/tools/mail.ts
 var VIEWS2 = ["compact", "full", "raw"];
 var WELL_KNOWN = [
@@ -45714,11 +46437,14 @@ function registerMailTools(server, client2) {
       annotations: { readOnlyHint: true },
       inputSchema: external_exports.object({
         view: viewParam(VIEWS2),
-        limit: external_exports.number().int().min(1).max(200).optional().describe("Max folders (default 50)")
+        limit: external_exports.number().int().min(1).max(200).optional().describe("Max folders (default 50)"),
+        nextLink: nextLinkParam
       })
     },
-    async ({ view, limit }) => {
-      const data = await client2.get(
+    async ({ view, limit, nextLink }) => {
+      const data = await fetchPage(
+        client2,
+        nextLink,
         `/me/mailfolders${qs({ $top: limit ?? 50 })}`
       );
       if (resolveView(view, VIEWS2) === "raw") return minifiedResult(data);
@@ -45728,7 +46454,7 @@ function registerMailTools(server, client2) {
   server.registerTool(
     "outlook_list_messages",
     {
-      description: "List messages in a folder, newest first. Defaults to the inbox. Use `unreadOnly` for a triage view. Bodies are NOT included \u2014 call outlook_get_message for one. Note `search` and `unreadOnly` cannot be combined (the API rejects $search with $filter); pass `search` alone to search the whole mailbox.",
+      description: "List messages in a folder, newest first. Defaults to the inbox. Use `unreadOnly` for a triage view. Bodies are NOT included \u2014 call outlook_get_message for one. Note `search` and `unreadOnly` cannot be combined on a first-page request (the API rejects $search with $filter); pass `search` alone to search the whole mailbox. When following a `nextLink`, both are ignored, so echoing them back is harmless.",
       annotations: { readOnlyHint: true },
       inputSchema: external_exports.object({
         view: viewParam(VIEWS2),
@@ -45736,11 +46462,12 @@ function registerMailTools(server, client2) {
         limit: external_exports.number().int().min(1).max(100).optional().describe("Max messages (default 25)"),
         skip: external_exports.number().int().min(0).optional().describe("Offset for paging"),
         unreadOnly: external_exports.boolean().optional().describe("Only unread messages"),
-        search: external_exports.string().optional().describe("Full-text search across the whole mailbox; cannot combine with unreadOnly")
+        search: external_exports.string().optional().describe("Full-text search across the whole mailbox; cannot combine with unreadOnly on a first page (ignored with nextLink)"),
+        nextLink: nextLinkParam
       })
     },
-    async ({ view, folder, limit, skip, unreadOnly, search }) => {
-      if (search !== void 0 && unreadOnly === true) {
+    async ({ view, folder, limit, skip, unreadOnly, search, nextLink }) => {
+      if (nextLink === void 0 && search !== void 0 && unreadOnly === true) {
         throw new McpToolError("`search` and `unreadOnly` cannot be combined.", {
           hint: "Outlook rejects $search together with $filter. Search first, then filter the results."
         });
@@ -45757,7 +46484,11 @@ function registerMailTools(server, client2) {
         params.$orderby = "ReceivedDateTime desc";
         if (unreadOnly === true) params.$filter = "IsRead eq false";
       }
-      const data = await client2.get(`${base}${qs(params)}`);
+      const data = await fetchPage(
+        client2,
+        nextLink,
+        `${base}${qs(params)}`
+      );
       const v = resolveView(view, VIEWS2);
       if (v === "raw") return minifiedResult(data);
       return minifiedResult(
@@ -45791,19 +46522,19 @@ function registerMailTools(server, client2) {
       description: "List a message's attachments (name, size, content type). Metadata only \u2014 this deliberately does not download bytes.",
       annotations: { readOnlyHint: true },
       inputSchema: external_exports.object({
-        id: external_exports.string().min(1).describe("Message Id")
+        id: external_exports.string().min(1).describe("Message Id"),
+        nextLink: nextLinkParam
       })
     },
-    async ({ id }) => {
-      const data = await client2.get(
+    async ({ id, nextLink }) => {
+      const data = await fetchPage(
+        client2,
+        nextLink,
         `/me/messages/${encodeURIComponent(id)}/attachments${qs({
           $select: "Id,Name,Size,ContentType"
         })}`
       );
-      return minifiedResult({
-        count: data.value?.length ?? 0,
-        items: (data.value ?? []).map(stripOData)
-      });
+      return minifiedResult(plainCollection(data));
     }
   );
 }
@@ -45850,12 +46581,15 @@ function registerCalendarTools(server, client2) {
         timeZone: external_exports.string().optional().describe(
           'Windows time-zone name for the returned times, e.g. "Eastern Standard Time". NOT an IANA name like America/New_York.'
         ),
-        limit: external_exports.number().int().min(1).max(200).optional().describe("Max events (default 50)")
+        limit: external_exports.number().int().min(1).max(200).optional().describe("Max events (default 50)"),
+        nextLink: nextLinkParam
       })
     },
-    async ({ view, start, end, timeZone, limit }) => {
+    async ({ view, start, end, timeZone, limit, nextLink }) => {
       const zone = timeZone ?? await mailboxTimeZone(client2);
-      const data = await client2.get(
+      const data = await fetchPage(
+        client2,
+        nextLink,
         `/me/calendarview${qs2({
           startDateTime: start,
           endDateTime: end,
@@ -45900,18 +46634,14 @@ function registerCalendarTools(server, client2) {
       description: "List the calendars in the mailbox, for picking one to read or write against.",
       annotations: { readOnlyHint: true },
       inputSchema: external_exports.object({
-        view: viewParam(VIEWS2)
+        view: viewParam(VIEWS2),
+        nextLink: nextLinkParam
       })
     },
-    async ({ view }) => {
-      const data = await client2.get(
-        `/me/calendars${qs2({ $select: "Id,Name,Color,CanEdit,Owner" })}`
-      );
+    async ({ view, nextLink }) => {
+      const data = await fetchPage(client2, nextLink, `/me/calendars${qs2({ $select: "Id,Name,Color,CanEdit,Owner" })}`);
       if (resolveView(view, VIEWS2) === "raw") return minifiedResult(data);
-      return minifiedResult({
-        count: data.value?.length ?? 0,
-        items: (data.value ?? []).map(stripOData)
-      });
+      return minifiedResult(plainCollection(data));
     }
   );
 }
@@ -45929,7 +46659,7 @@ function qs3(params) {
 }
 function collection(data, raw) {
   if (raw) return data;
-  return { count: data.value?.length ?? 0, items: (data.value ?? []).map(stripOData) };
+  return plainCollection(data);
 }
 function registerDirectoryTools(server, client2) {
   server.registerTool(
@@ -45958,11 +46688,14 @@ function registerDirectoryTools(server, client2) {
       inputSchema: external_exports.object({
         view: viewParam(VIEWS2),
         limit: external_exports.number().int().min(1).max(200).optional().describe("Max contacts (default 50)"),
-        skip: external_exports.number().int().min(0).optional().describe("Offset for paging")
+        skip: external_exports.number().int().min(0).optional().describe("Offset for paging"),
+        nextLink: nextLinkParam
       })
     },
-    async ({ view, limit, skip }) => {
-      const data = await client2.get(
+    async ({ view, limit, skip, nextLink }) => {
+      const data = await fetchPage(
+        client2,
+        nextLink,
         `/me/contacts${qs3({
           $top: limit ?? 50,
           $skip: skip,
@@ -45981,11 +46714,14 @@ function registerDirectoryTools(server, client2) {
       annotations: { readOnlyHint: true },
       inputSchema: external_exports.object({
         view: viewParam(VIEWS2),
-        limit: external_exports.number().int().min(1).max(100).optional().describe("Max people (default 25)")
+        limit: external_exports.number().int().min(1).max(100).optional().describe("Max people (default 25)"),
+        nextLink: nextLinkParam
       })
     },
-    async ({ view, limit }) => {
-      const data = await client2.get(
+    async ({ view, limit, nextLink }) => {
+      const data = await fetchPage(
+        client2,
+        nextLink,
         `/me/people${qs3({
           $top: limit ?? 25,
           $select: "Id,DisplayName,ScoredEmailAddresses,JobTitle,CompanyName"
@@ -46001,11 +46737,14 @@ function registerDirectoryTools(server, client2) {
       annotations: { readOnlyHint: true },
       inputSchema: external_exports.object({
         view: viewParam(VIEWS2),
-        limit: external_exports.number().int().min(1).max(200).optional().describe("Max tasks (default 50)")
+        limit: external_exports.number().int().min(1).max(200).optional().describe("Max tasks (default 50)"),
+        nextLink: nextLinkParam
       })
     },
-    async ({ view, limit }) => {
-      const data = await client2.get(
+    async ({ view, limit, nextLink }) => {
+      const data = await fetchPage(
+        client2,
+        nextLink,
         `/me/tasks${qs3({
           $top: limit ?? 50,
           $select: "Id,Subject,Status,Importance,DueDateTime,CompletedDateTime"