canvas-parent-mcp 2.1.1 → 2.1.2

package/dist/bundle.js

@@ -25548,7 +25548,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();
@@ -26086,7 +26086,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;
@@ -26983,6 +26983,20 @@ var require_websocket_server = __commonJS({
 import { dirname as dirname3, join as join4 } from "path";
 import { fileURLToPath } from "url";
 
+// node_modules/@chrischall/mcp-utils/dist/cancel/index.js
+import { AsyncLocalStorage } from "node:async_hooks";
+var storage = new AsyncLocalStorage();
+function withCallSignal(signal, fn, request) {
+  return signal ? storage.run({ signal, ...request ? { request } : {} }, fn) : fn();
+}
+
+// node_modules/@chrischall/mcp-utils/dist/caller/index.js
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var storage2 = new AsyncLocalStorage2();
+function withCallerCapabilities(capabilities, fn) {
+  return capabilities ? storage2.run(capabilities, fn) : fn();
+}
+
 // node_modules/@modelcontextprotocol/server/dist/chunk-Br0eD_fh.mjs
 var __create2 = Object.create;
 var __defProp2 = Object.defineProperty;
@@ -41662,13 +41676,28 @@ var API_KEY_RE = new RegExp([
   "whsec_[A-Za-z0-9]{16,}\\b"
   // webhook signing secret (Stripe-style)
 ].map((p) => `\\b${p}`).join("|"), "g");
-var QUERY_SECRET_RE = /([?&](?:access_token|refresh_token|client_secret|api_?key|signature|token|key|sig)=)[^&#\s"'<>`]+/gi;
+var 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;
+var OAUTH_CODE_RE = /([?&]code=)(?=[^&#\s"'<>`]{16,})[^&#\s"'<>`]+/gi;
+var FORM_PASSWORD_RE = /((?:^|[\s,;:"'(\[{])(?:password|passwd)=)[^&#\s"'<>`]+/gim;
+var HEADER_SECRET_RE = /(\b(?:x[-_][a-z0-9_-]*?(?:api[-_]?key|token|secret|auth)[a-z0-9_-]*|api[-_]?key)\s*:\s*)[^\s,;"'<>`]+/gi;
 var AWS_SIGV4_RE = /([?&]X-Amz-(?:Signature|Security-Token|Credential)=)[^&#\s"'<>`]+/gi;
-var JSON_SECRET_KEYS = "access_token|refresh_token|client_secret|api_?key|password|passwd|secret|token";
-var JSON_SECRET_DQ_RE = new RegExp(`("(?:${JSON_SECRET_KEYS})"\\s*:\\s*")[^"]*(")`, "gi");
-var JSON_SECRET_SQ_RE = new RegExp(`('(?:${JSON_SECRET_KEYS})'\\s*:\\s*')[^']*(')`, "gi");
+var 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("|");
+var JSON_SECRET_DQ_RE = new RegExp(`("(?:${JSON_SECRET_KEYS})"\\s*:\\s*")(?:[^"\\\\]|\\\\.)*(")`, "gi");
+var JSON_SECRET_SQ_RE = new RegExp(`('(?:${JSON_SECRET_KEYS})'\\s*:\\s*')(?:[^'\\\\]|\\\\.)*(')`, "gi");
 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);
@@ -61447,17 +61476,73 @@ 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)
+    return void 0;
+  const req = ctx.mcpReq;
+  if (typeof req !== "object" || req === null)
+    return void 0;
+  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) => {
-    let result;
-    try {
-      result = cb(...args);
-    } catch (err) {
-      return hintResultOrRethrow(err);
-    }
-    return result instanceof Promise ? result.catch(hintResultOrRethrow) : result;
-  });
+  server.registerTool = (name, config2, cb) => register2(name, config2, (...args) => (
+    // THE CALLER'S CANCELLATION, made ambient for the whole handler
+    // (`cancel/index.ts`). The SDK delivers it and the fleet ignored it:
+    // measured against @modelcontextprotocol/server 2.0.0, a cancelled
+    // call aborts `ctx.mcpReq.signal` with the caller's reason and the
+    // handler runs to completion regardless — so the HTTP request stays
+    // in flight, the child keeps burning metered CPU, and the upstream
+    // keeps being hit for somebody who has gone. claude.ai sent 101
+    // cancellations in the week to 2026-09-20.
+    //
+    // 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), () => (
+      // 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) {
   const server = new McpServer({ name: opts.name, version: opts.version }, { supportedProtocolVersions: [...SERVER_PROTOCOL_VERSIONS] });
@@ -61472,13 +61557,47 @@ async function createMcpServer(opts) {
   }
   return server;
 }
+var DEFAULT_SHUTDOWN_TIMEOUT_MS = 5e3;
+var DEFAULT_REPEAT_SIGNAL_GRACE_MS = 500;
 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)
@@ -61487,8 +61606,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();
       }
     })();
   };
@@ -61695,6 +61816,33 @@ var pageSchema = {
 };
 
 // node_modules/@chrischall/mcp-utils/dist/auth/index.js
+var OAuth2RefreshError = class extends McpToolError {
+  status;
+  constructor(status, message, opts) {
+    super(message, opts);
+    this.name = "OAuth2RefreshError";
+    this.status = status;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var OAuth2RotationPersistError = class extends McpToolError {
+  persistenceFailure = true;
+  result;
+  constructor(result, cause) {
+    super(`OAuth2 refresh token rotated, but saving it failed: ${truncateErrorMessage(messageOf2(cause), 200)}`, {
+      hint: "The new refresh token is still held in memory; fix the storage problem before the process restarts.",
+      cause
+    });
+    this.name = "OAuth2RotationPersistError";
+    this.result = result;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+function isRetryable(err) {
+  if (!(err instanceof OAuth2RefreshError))
+    return true;
+  return err.status >= 500 || err.status === 429 || err.status === 408;
+}
 var sleep2 = (ms) => ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
 function createOAuth2Refresher(opts) {
   const doFetch = opts.fetchImpl ?? fetch;
@@ -61702,10 +61850,13 @@ function createOAuth2Refresher(opts) {
   const maxRetries = opts.retry?.count ?? 0;
   const retryDelayMs = opts.retry?.delayMs ?? 0;
   let inFlight = null;
+  let currentRefreshToken = opts.refreshToken;
+  const spent = /* @__PURE__ */ new Set();
+  let rotatedTo;
   async function exchangeOnce() {
     const body = new URLSearchParams({
       grant_type: grantType,
-      refresh_token: opts.refreshToken,
+      refresh_token: currentRefreshToken,
       ...opts.params
     }).toString();
     const res = await doFetch(opts.endpoint, {
@@ -61718,7 +61869,7 @@ function createOAuth2Refresher(opts) {
     });
     if (!res.ok) {
       const errText = await res.text().catch(() => "");
-      throw createHelpfulError(`OAuth2 token refresh failed: ${res.status} ${res.statusText}: ${truncateErrorMessage(errText, 200)}`, { hint: "The refresh token may be expired or revoked \u2014 re-authenticate." });
+      throw new OAuth2RefreshError(res.status, `OAuth2 token refresh failed: ${res.status} ${res.statusText}: ${truncateErrorMessage(errText, 200)}`, { hint: "The refresh token may be expired or revoked \u2014 re-authenticate." });
     }
     const data = await res.json().catch(() => null);
     const accessToken = data?.access_token;
@@ -61730,6 +61881,11 @@ function createOAuth2Refresher(opts) {
     const result = { accessToken };
     if (typeof data?.refresh_token === "string" && data.refresh_token.length > 0) {
       result.refreshToken = data.refresh_token;
+      if (data.refresh_token !== currentRefreshToken) {
+        spent.add(currentRefreshToken);
+        currentRefreshToken = data.refresh_token;
+        rotatedTo = data.refresh_token;
+      }
     }
     if (typeof data?.expires_in === "number") {
       result.expiresIn = data.expires_in;
@@ -61744,16 +61900,32 @@ function createOAuth2Refresher(opts) {
         return await exchangeOnce();
       } catch (e) {
         lastErr = e;
+        if (!isRetryable(e))
+          break;
         if (attempt < maxRetries)
           await sleep2(retryDelayMs);
       }
     }
     throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
   }
-  return function refresh() {
+  return function refresh(refreshToken) {
     if (inFlight)
       return inFlight;
-    const p = exchangeWithRetry().finally(() => {
+    if (typeof refreshToken === "string" && refreshToken.length > 0 && !spent.has(refreshToken)) {
+      currentRefreshToken = refreshToken;
+    }
+    const p = (async () => {
+      rotatedTo = void 0;
+      const result = await exchangeWithRetry();
+      if (rotatedTo !== void 0 && opts.onRotate) {
+        try {
+          await opts.onRotate(rotatedTo);
+        } catch (err) {
+          throw new OAuth2RotationPersistError(result, err);
+        }
+      }
+      return result;
+    })().finally(() => {
       if (inFlight === p)
         inFlight = null;
     });
@@ -61761,6 +61933,9 @@ function createOAuth2Refresher(opts) {
     return p;
   };
 }
+function messageOf2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
 
 // node_modules/@fetchproxy/protocol/dist/crypto.js
 var subtle = globalThis.crypto.subtle;
@@ -61959,6 +62134,7 @@ var KNOWN_CAPABILITIES = /* @__PURE__ */ new Set([
   "capture_redirect",
   "read_indexed_db",
   "read_dom",
+  "read_dom_list",
   "download",
   "graphql",
   "write_cookies"
@@ -62459,6 +62635,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}`);
@@ -62505,6 +62754,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) {
@@ -62575,16 +62826,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");
     }
@@ -62606,6 +62852,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)}`);
@@ -62661,6 +62909,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))
@@ -62910,6 +63179,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)
@@ -62957,7 +63244,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)) {
@@ -63065,6 +63352,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");
@@ -63166,12 +63465,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 {
@@ -63323,6 +63616,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,
@@ -63491,11 +63796,12 @@ async function awaitSessionReady(ready, opts) {
 }
 
 // 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 randomBytes2 } from "node:crypto";
 import { isAbsolute as isAbsolute2, join as join2 } from "node:path";
 
 // 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 } from "node:crypto";
 import { isAbsolute, join } from "node:path";
 import { homedir } from "node:os";
@@ -63563,7 +63869,7 @@ async function openIdentityDir(dir) {
   }
 }
 var STAGING_BYTES = 6;
-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;
@@ -63572,35 +63878,80 @@ async function sweepStagingFiles(dir, serverName) {
   } catch {
     return;
   }
-  await Promise.all(names.filter((name) => staging.test(name)).map((name) => unlink(join(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 = join(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}.${randomBytes(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()) {
+var NO_HARD_LINKS = /* @__PURE__ */ new Set(["EPERM", "ENOTSUP", "EOPNOTSUPP", "ENOSYS"]);
+async function publishIdentityIfAbsent(dir, serverName, id) {
   const path = identityFilePath(dir, serverName);
-  await openIdentityDir(dir);
+  await sweepStagingFiles(dir, serverName, { olderThanMs: 6e4 });
+  const tmp = `${path}.${randomBytes(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;
 }
 
 // node_modules/@fetchproxy/server/dist/extension-trust.js
@@ -63701,10 +64052,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}.${randomBytes2(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;
+  }
 }
 
 // node_modules/@fetchproxy/server/dist/host.js
@@ -63741,6 +64097,7 @@ function originVerdict(origin, allowLocal) {
 var HANDSHAKE_TIMEOUT_MS = 15e3;
 var MAX_PAYLOAD_BYTES = MAX_FRAME_BYTES;
 var enc4 = new TextEncoder();
+var OWN_DECRYPT_FAILURES_BEFORE_REHANDSHAKE = 3;
 async function startHost(opts) {
   const allowLocalOrigins = envAllowsLocalOrigins();
   if (allowLocalOrigins) {
@@ -63784,6 +64141,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;
@@ -63854,6 +64212,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;
@@ -64044,6 +64427,7 @@ async function startHost(opts) {
             if (extensionWs !== ws)
               return;
             ownSession = new SessionState(key);
+            ownDecryptFailures = 0;
             ownPendingPairCode = null;
             resolveOwnSession(ownSession);
           } else {
@@ -64065,15 +64449,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)
@@ -64132,6 +64543,7 @@ async function startHost(opts) {
           rejectOwnSession(new Error("extension disconnected before ready"));
         }
         ownSession = dropOwnSessionAndEphemeral();
+        ownDecryptFailures = 0;
         ownPendingPairCode = null;
         resetSessionPromise();
         disconnectListeners.forEach((cb) => cb());
@@ -64146,8 +64558,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 {
+            }
+          }
+        }
       }
     });
   });
@@ -64190,12 +64609,18 @@ async function startHost(opts) {
 }
 
 // node_modules/@fetchproxy/server/dist/peer.js
+var PEER_DIAL_TIMEOUT_MS = 5e3;
 var enc5 = new TextEncoder();
+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();
@@ -64205,11 +64630,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)}`);
@@ -64228,6 +64663,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,
@@ -64251,6 +64687,7 @@ async function startPeer(opts) {
   const renegotiateListeners = [];
   const pendingPairListeners = [];
   const closeListeners = [];
+  const extensionDisconnectListeners = [];
   let session = null;
   let sessionEphemeral = null;
   function dropSessionEphemeral() {
@@ -64270,10 +64707,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;
@@ -64370,6 +64821,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) {
@@ -64486,19 +64943,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) => {
@@ -64516,6 +64984,9 @@ async function startPeer(opts) {
     onClose: (cb) => {
       closeListeners.push(cb);
     },
+    onExtensionDisconnect: (cb) => {
+      extensionDisconnectListeners.push(cb);
+    },
     close: () => ws.close()
   };
   return handle;
@@ -64523,15 +64994,15 @@ async function startPeer(opts) {
 
 // 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";
   }
@@ -64723,6 +65194,17 @@ var FetchproxyTimeoutError = class extends FetchproxyProtocolError {
    * 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;
@@ -64735,6 +65217,7 @@ var FetchproxyTimeoutError = class extends FetchproxyProtocolError {
     this.elapsedMs = args.elapsedMs ?? args.timeoutMs;
     this.retryAttempted = args.retryAttempted ?? false;
     this.requestedTimeoutMs = args.requestedTimeoutMs ?? null;
+    this.retrySafe = args.retrySafe ?? true;
   }
 };
 var SUBDOMAIN_LABEL_RE = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$/i;
@@ -64774,6 +65257,32 @@ function assertUrlInDomains(field, url4, domains) {
   throw new Error(`FetchproxyServer: ${field} host "${host}" is outside declared domains [${declared}] \u2014 must be one of them or a subdomain`);
 }
 var DEFAULT_JSON_OK_STATUSES = [200, 201, 202, 204];
+function parseJsonBody(response) {
+  if (response.status === 204 || response.body.trim() === "")
+    return null;
+  return JSON.parse(response.body);
+}
+var TIMEOUT_RETRY_SAFE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+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 FetchproxyServer = class {
   /**
    * Bridge role. `null` until the first verb call (or an explicit
@@ -64822,12 +65331,22 @@ var FetchproxyServer = class {
   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
@@ -64873,7 +65392,7 @@ var FetchproxyServer = class {
       }
       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];
@@ -64920,6 +65439,16 @@ var FetchproxyServer = class {
         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
@@ -65049,6 +65578,7 @@ var FetchproxyServer = class {
         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()
@@ -65080,6 +65610,7 @@ var FetchproxyServer = class {
         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
@@ -65089,6 +65620,10 @@ var FetchproxyServer = class {
         this.stopKeepalive();
         this.rejectAllPending();
       });
+      this.peerHandle.onExtensionDisconnect(() => {
+        this.stopKeepalive();
+        this.rejectAllPending();
+      });
       this.peerHandle.onPendingPair((code) => {
         this.rejectAllPending(this.pairingErrorMessage(code));
       });
@@ -65100,9 +65635,9 @@ var FetchproxyServer = class {
         if (this.closing || this.peerHandle === null)
           return;
         this.stopKeepalive();
-        this.rejectAllPending();
         this.peerHandle = null;
         this.role = null;
+        void this.recoverFromHostLoss();
       });
     }
   }
@@ -65123,7 +65658,7 @@ var FetchproxyServer = class {
    * 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) {
@@ -65135,16 +65670,17 @@ var FetchproxyServer = class {
         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();
@@ -65293,13 +65829,16 @@ var FetchproxyServer = class {
    * 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;
@@ -65311,6 +65850,7 @@ var FetchproxyServer = class {
         this.pendingRedirect.delete(id);
         this.pendingDownload.delete(id);
         this.pendingIdb.delete(id);
+        this.pendingDomList.delete(id);
         this.pendingGraphql.delete(id);
       }
       throw err;
@@ -65321,13 +65861,25 @@ var FetchproxyServer = class {
    * 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;
@@ -65401,7 +65953,7 @@ var FetchproxyServer = class {
     });
     return pending;
   }
-  async _withVerbTimeout(pending, pendingMap, id, url4, requestedTimeoutMs) {
+  async _withVerbTimeout(pending, pendingMap, id, url4, requestedTimeoutMs, retrySafe = true) {
     const transportMs = this.opts.fetchTimeoutMs;
     if (transportMs === void 0 || transportMs <= 0)
       return pending;
@@ -65422,6 +65974,7 @@ var FetchproxyServer = class {
               port: this.opts.port,
               elapsedMs: Date.now() - start,
               retryAttempted: false,
+              retrySafe,
               graceMs,
               ...requestedTimeoutMs !== void 0 ? { requestedTimeoutMs } : {}
             }));
@@ -65439,7 +65992,7 @@ var FetchproxyServer = class {
    * logic re-implemented inline) `captureRequestHeader()` agree on what
    * to throw.
    */
-  _typedErrorFor(result, url4, op, retryAttempted) {
+  _typedErrorFor(result, url4, op, retryAttempted, retrySafe = true) {
     if (result.kind === "timeout") {
       return new FetchproxyTimeoutError({
         url: url4,
@@ -65447,7 +66000,8 @@ var FetchproxyServer = class {
         role: this.role,
         port: this.opts.port,
         elapsedMs: result.elapsedMs,
-        retryAttempted
+        retryAttempted,
+        retrySafe
       });
     }
     if (result.kind === "content_script_unreachable") {
@@ -65521,9 +66075,12 @@ var FetchproxyServer = class {
       // 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,
@@ -65563,17 +66120,21 @@ var FetchproxyServer = class {
    * 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 ?? {} };
@@ -65585,7 +66146,7 @@ var FetchproxyServer = class {
       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
@@ -65606,7 +66167,8 @@ var FetchproxyServer = class {
    *  - 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 +
@@ -65620,6 +66182,11 @@ var FetchproxyServer = class {
    * 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";
@@ -65633,7 +66200,8 @@ var FetchproxyServer = class {
       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,
@@ -65641,12 +66209,9 @@ var FetchproxyServer = class {
       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)}`);
     }
@@ -65703,18 +66268,19 @@ var FetchproxyServer = class {
     };
   }
   /**
-   * 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.).
@@ -65810,7 +66376,15 @@ var FetchproxyServer = class {
       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
@@ -65913,53 +66487,7 @@ var FetchproxyServer = class {
       throw new Error("FetchproxyServer.captureRequestHeader: pass both host AND headerName, or neither (which defaults to the single declared entry)");
     }
     const callOpts = { ...resolved2, ...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://${resolved2.host}${resolved2.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://${resolved2.host}${resolved2.path ?? "/*"}`,
-        role: this.role,
-        port: this.opts.port
-      });
-    }
+    return this.withLazyRevive("capture_request_header", `https://${resolved2.host}${resolved2.path ?? "/*"}`, () => this._captureRequestHeaderOnce(callOpts));
   }
   async _captureRequestHeaderOnce(opts) {
     const id = this.nextRequestId++;
@@ -66008,53 +66536,7 @@ var FetchproxyServer = class {
     }
     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++;
@@ -66099,52 +66581,57 @@ var FetchproxyServer = class {
     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, url4, 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: url4,
+        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) {
@@ -66173,7 +66660,9 @@ var FetchproxyServer = class {
       // 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
     );
   }
   /**
@@ -66264,6 +66753,52 @@ var FetchproxyServer = class {
     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.
@@ -66307,8 +66842,9 @@ var FetchproxyServer = class {
     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);
@@ -66345,6 +66881,7 @@ var FetchproxyServer = class {
   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) {
@@ -66433,6 +66970,20 @@ var FetchproxyServer = class {
       }
       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);
@@ -66492,42 +67043,133 @@ var FetchproxyServer = class {
       }
     }
   }
-  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;
     }
-    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();
+    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;
+      }
+    }
+  }
+  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
@@ -66630,6 +67272,12 @@ async function runOneLift(opts) {
   if (envVal !== void 0 && envVal !== "" && envVal !== "0" && envVal !== "false") {
     throw new BootstrapDisabledError(opts.serverName, envVar);
   }
+  for (const bucket of ["cookies", "localStorage", "sessionStorage"]) {
+    const glob = opts.declare[bucket].find((k) => k.endsWith("*"));
+    if (glob !== void 0) {
+      throw new Error(`fetchproxy bootstrap: declare.${bucket} contains ${JSON.stringify(glob)}, a glob. A lift reads each key by its exact name, so a glob can never match \u2014 list the concrete key names instead.`);
+    }
+  }
   const factory = opts._serverFactory ?? defaultFactory;
   const indexedDb = opts.declare.indexedDb ?? [];
   const localStoragePointers = opts.declare.localStoragePointers ?? [];
@@ -66887,7 +67535,7 @@ function loadAccount(env = process.env) {
 // package.json
 var package_default = {
   name: "canvas-parent-mcp",
-  version: "2.1.1",
+  version: "2.1.2",
   mcpName: "io.github.chrischall/canvas-parent-mcp",
   description: "Canvas LMS (Instructure) MCP server \u2014 student/observer read access with optional file download",
   author: "Claude Code (AI) <https://www.anthropic.com/claude>",
@@ -66934,12 +67582,12 @@ var package_default = {
     typecheck: "tsc -p tsconfig.json --noEmit"
   },
   dependencies: {
-    "@chrischall/mcp-utils": "^1.0.0",
-    "@fetchproxy/bootstrap": "^3.0.1",
-    "@fetchproxy/server": "^3.0.1",
+    "@chrischall/mcp-utils": "^2.4.0",
+    "@fetchproxy/bootstrap": "^3.2.0",
+    "@fetchproxy/server": "^3.2.0",
     "@modelcontextprotocol/server": "^2.0.0",
     dotenv: "^18.0.0",
-    zod: "^4.6.2"
+    zod: "^4.6.5"
   },
   devDependencies: {
     "@modelcontextprotocol/client": "^2.0.0",
@@ -67199,7 +67847,7 @@ import { writeFile as writeFile3, stat } from "fs/promises";
 import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync, renameSync, unlinkSync } from "node:fs";
 import { dirname, join as join3, resolve } from "node:path";
 import { homedir as homedir2 } from "node:os";
-import { randomBytes as randomBytes2, createHmac } from "node:crypto";
+import { randomBytes as randomBytes3, createHmac } from "node:crypto";
 function bindingDigest(secret, salt) {
   return createHmac("sha256", salt).update(secret).digest("hex").slice(0, 32);
 }
@@ -67251,7 +67899,7 @@ function createFileStatePersistence(opts) {
     },
     save(state) {
       const dir = dirname(filePath);
-      const tmp = `${filePath}.tmp-${randomBytes2(6).toString("hex")}`;
+      const tmp = `${filePath}.tmp-${randomBytes3(6).toString("hex")}`;
       const dirExisted = existsSync(dir);
       try {
         mkdirSync(dir, { recursive: true, mode: 448 });
@@ -67259,7 +67907,7 @@ function createFileStatePersistence(opts) {
           chmodSync(dir, 448);
         let boundTo;
         if (secret !== void 0) {
-          const salt = randomBytes2(16).toString("hex");
+          const salt = randomBytes3(16).toString("hex");
           boundTo = { salt, digest: bindingDigest(secret, salt) };
         }
         const envelope = { v: 1, ...boundTo !== void 0 ? { boundTo } : {}, state };
@@ -67729,7 +68377,7 @@ var CanvasClient = class {
     const res = await this.doRawRequest(path, opts);
     const text = await res.text();
     if (opts.responseType === "text") return text;
-    return parseJsonBody(text) ?? null;
+    return parseJsonBody2(text) ?? null;
   }
   async requestPaginated(path, opts = {}) {
     const perPage = opts.perPage ?? DEFAULT_PER_PAGE;
@@ -67739,7 +68387,7 @@ var CanvasClient = class {
     for (let page = 0; page < maxPages; page++) {
       const res = await this.doRawRequest(url4, opts);
       const text = await res.text();
-      const parsed = parseJsonBody(text) ?? [];
+      const parsed = parseJsonBody2(text) ?? [];
       for (const item of parsed) out.push(item);
       const linkHeader = res.headers.get("link");
       const next = linkHeader ? parseLinkHeader(linkHeader).next : void 0;
@@ -67880,7 +68528,7 @@ var CanvasClient = class {
     };
   }
 };
-function parseJsonBody(text) {
+function parseJsonBody2(text) {
   if (!text) return null;
   const stripped = text.replace(/^while\(1\);/, "");
   return JSON.parse(stripped);
@@ -68358,7 +69006,7 @@ try {
 }
 await runMcp({
   name: "canvas",
-  version: "2.1.1",
+  version: "2.1.2",
   // x-release-please-version
   tools: [
     // Outside the `if (resolved)` on purpose: an unconfigured server must