ofw-mcp 2.19.0 → 2.19.2

package/dist/bundle.js

@@ -2279,7 +2279,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes3, createHash: createHash2 } = __require("crypto");
+    var { randomBytes: randomBytes4, createHash: createHash2 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2817,7 +2817,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;
@@ -3713,8 +3713,8 @@ var require_websocket_server = __commonJS({
 // node_modules/@chrischall/mcp-utils/dist/cancel/index.js
 import { AsyncLocalStorage } from "node:async_hooks";
 var storage = new AsyncLocalStorage();
-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;
@@ -3728,6 +3728,13 @@ function withAmbientCancellation(own2) {
   return AbortSignal.any([own2, ambient]);
 }
 
+// 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;
@@ -8811,7 +8818,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve3) {
+function isRecursive(inst, stack, resolve4) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -8821,7 +8828,7 @@ function isRecursive(inst, stack, resolve3) {
   let result = NONE;
   const check2 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve3);
+      const answer = isRecursive(child, stack, resolve4);
       if (answer > result)
         result = answer;
     }
@@ -8832,7 +8839,7 @@ function isRecursive(inst, stack, resolve3) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve3) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve4) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -8896,7 +8903,7 @@ function isRecursive(inst, stack, resolve3) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve3 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve4 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -27796,14 +27803,14 @@ function inputRequiredRoundsExceededMessage(method, maxRounds) {
   return `Multi-round-trip request '${method}' still required input after ${maxRounds} rounds (inputRequired.maxRounds)`;
 }
 function sleep(ms, signal) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     if (signal?.aborted) {
       reject(signal.reason instanceof SdkError ? signal.reason : new SdkError(SdkErrorCode.RequestTimeout, String(signal.reason)));
       return;
     }
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve3();
+      resolve4();
     }, ms);
     const onAbort = () => {
       clearTimeout(timer);
@@ -28597,7 +28604,7 @@ var Protocol = class {
     const flowStartedAt = Date.now();
     let onAbort;
     let cleanupMessageId;
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const earlyReject = (error62) => {
         reject(error62);
       };
@@ -28665,7 +28672,7 @@ var Protocol = class {
         }
         if (decoded.kind === "invalid") return reject(decoded.error);
         if (decoded.kind === "input_required") {
-          if (options?.allowInputRequired === true) return resolve3(manualInputRequiredValue(decoded));
+          if (options?.allowInputRequired === true) return resolve4(manualInputRequiredValue(decoded));
           const flow = {
             codec: codec2,
             request,
@@ -28677,11 +28684,11 @@ var Protocol = class {
               params
             }, resultSchema, legOptions)
           };
-          return resolve3(this._resolveNonCompleteResult(decoded, flow));
+          return resolve4(this._resolveNonCompleteResult(decoded, flow));
         }
         const result = decoded.result;
         validateStandardSchema(resultSchema, result).then((parseResult) => {
-          if (parseResult.success) resolve3(parseResult.data);
+          if (parseResult.success) resolve4(parseResult.data);
           else reject(new SdkError(SdkErrorCode.InvalidResult, `Invalid result for ${request.method}: ${parseResult.error}`));
         }, reject);
       });
@@ -31593,7 +31600,7 @@ var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
     ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
     const schOrFunc = root.refs[ref];
     if (schOrFunc) return schOrFunc;
-    let _sch = resolve3.call(this, root, ref);
+    let _sch = resolve4.call(this, root, ref);
     if (_sch === void 0) {
       const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
       const { schemaId } = this.opts;
@@ -31619,7 +31626,7 @@ var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve3(root, ref) {
+  function resolve4(root, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string") ref = sch;
     return sch || this.schemas[ref] || resolveSchema.call(this, root, ref);
@@ -32069,47 +32076,47 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
     else if (typeof uri === "object") uri = parse3(serialize(uri, options), options);
     return uri;
   }
-  function resolve3(baseURI, relativeURI, options) {
+  function resolve4(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
     const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
     return serialize(resolved, schemelessOptions);
   }
-  function resolveComponent(base, relative, options, skipNormalization) {
+  function resolveComponent(base, relative2, options, skipNormalization) {
     const target = {};
     if (!skipNormalization) {
       base = parse3(serialize(base, options), options);
-      relative = parse3(serialize(relative, options), options);
+      relative2 = parse3(serialize(relative2, options), options);
     }
     options = options || {};
-    if (!options.tolerant && relative.scheme) {
-      target.scheme = relative.scheme;
-      target.userinfo = relative.userinfo;
-      target.host = relative.host;
-      target.port = relative.port;
-      target.path = removeDotSegments(relative.path || "");
-      target.query = relative.query;
+    if (!options.tolerant && relative2.scheme) {
+      target.scheme = relative2.scheme;
+      target.userinfo = relative2.userinfo;
+      target.host = relative2.host;
+      target.port = relative2.port;
+      target.path = removeDotSegments(relative2.path || "");
+      target.query = relative2.query;
     } else {
-      if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) {
-        target.userinfo = relative.userinfo;
-        target.host = relative.host;
-        target.port = relative.port;
-        target.path = removeDotSegments(relative.path || "");
-        target.query = relative.query;
+      if (relative2.userinfo !== void 0 || relative2.host !== void 0 || relative2.port !== void 0) {
+        target.userinfo = relative2.userinfo;
+        target.host = relative2.host;
+        target.port = relative2.port;
+        target.path = removeDotSegments(relative2.path || "");
+        target.query = relative2.query;
       } else {
-        if (!relative.path) {
+        if (!relative2.path) {
           target.path = base.path;
-          if (relative.query !== void 0) target.query = relative.query;
+          if (relative2.query !== void 0) target.query = relative2.query;
           else target.query = base.query;
         } else {
-          if (relative.path[0] === "/") target.path = removeDotSegments(relative.path);
+          if (relative2.path[0] === "/") target.path = removeDotSegments(relative2.path);
           else {
-            if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) target.path = "/" + relative.path;
-            else if (!base.path) target.path = relative.path;
-            else target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
+            if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) target.path = "/" + relative2.path;
+            else if (!base.path) target.path = relative2.path;
+            else target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative2.path;
             target.path = removeDotSegments(target.path);
           }
-          target.query = relative.query;
+          target.query = relative2.query;
         }
         target.userinfo = base.userinfo;
         target.host = base.host;
@@ -32117,7 +32124,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
       }
       target.scheme = base.scheme;
     }
-    target.fragment = relative.fragment;
+    target.fragment = relative2.fragment;
     return target;
   }
   function equal(uriA, uriB, options) {
@@ -32243,7 +32250,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   const fastUri = {
     SCHEMES,
     normalize,
-    resolve: resolve3,
+    resolve: resolve4,
     resolveComponent,
     equal,
     serialize,
@@ -37616,7 +37623,7 @@ var StdioServerTransport = class {
   }
   send(message) {
     if (this._closed) return Promise.reject(/* @__PURE__ */ new Error("StdioServerTransport is closed"));
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const json2 = serializeMessage(message);
       let settled = false;
       const onError = (error62) => {
@@ -37631,14 +37638,14 @@ var StdioServerTransport = class {
         settled = true;
         this._stdout.off("error", onError);
         this._stdout.off("drain", onDrain);
-        resolve3();
+        resolve4();
       };
       this._stdout.once("error", onError);
       if (this._stdout.write(json2)) {
         if (settled) return;
         settled = true;
         this._stdout.off("error", onError);
-        resolve3();
+        resolve4();
       } else if (!settled) this._stdout.once("drain", onDrain);
     });
   }
@@ -37692,14 +37699,14 @@ var StdioConnectionChannel = class {
   */
   async whenRequestsAnswered(timeoutMs) {
     if (this._closed || this._pendingRequests.size === 0) return true;
-    return await new Promise((resolve3) => {
+    return await new Promise((resolve4) => {
       const waiter = () => {
         clearTimeout(timer);
-        resolve3(true);
+        resolve4(true);
       };
       const timer = setTimeout(() => {
         this._drainWaiters = this._drainWaiters.filter((pending) => pending !== waiter);
-        resolve3(false);
+        resolve4(false);
       }, timeoutMs);
       this._drainWaiters.push(waiter);
     });
@@ -38073,13 +38080,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);
@@ -38173,6 +38195,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)
@@ -38183,6 +38214,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) => (
@@ -38198,15 +38243,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) {
@@ -38222,13 +38276,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)
@@ -38237,8 +38325,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();
       }
     })();
   };
@@ -38324,10 +38414,48 @@ async function loadDotenvSafely(opts = {}) {
 
 // node_modules/@chrischall/mcp-utils/dist/fs/index.js
 import { openAsBlob } from "node:fs";
+
+// node_modules/@chrischall/mcp-utils/dist/fs/confine.js
+import { existsSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute as isAbsolute2, relative, resolve as resolve2, sep } from "node:path";
+function isInside(root, target) {
+  const rel = relative(root, target);
+  return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute2(rel);
+}
+function realPathAllowingMissing(p) {
+  const abs = resolve2(p);
+  let existing = abs;
+  const tail = [];
+  while (!existsSync(existing)) {
+    const parent = dirname(existing);
+    if (parent === existing)
+      break;
+    tail.unshift(existing.slice(parent.length).replace(/^[/\\]+/, ""));
+    existing = parent;
+  }
+  let real;
+  try {
+    real = realpathSync(existing);
+  } catch {
+    real = existing;
+  }
+  return tail.length > 0 ? resolve2(real, ...tail) : real;
+}
+function assertPathWithinRoots(path, roots) {
+  const target = realPathAllowingMissing(expandPath(path));
+  for (const root of roots) {
+    if (isInside(realPathAllowingMissing(expandPath(root)), target))
+      return target;
+  }
+  throw new Error(`Path is outside the allowed directories: ${path}`);
+}
+
+// node_modules/@chrischall/mcp-utils/dist/fs/index.js
 async function fileBlob(path, opts = {}) {
+  const target = opts.allowedRoots ? assertPathWithinRoots(path, opts.allowedRoots) : path;
   let blob;
   try {
-    blob = await openAsBlob(path, opts.type !== void 0 ? { type: opts.type } : void 0);
+    blob = await openAsBlob(target, opts.type !== void 0 ? { type: opts.type } : void 0);
   } catch {
     throw new Error(`Cannot read file for upload: ${path}`);
   }
@@ -38415,8 +38543,8 @@ async function resolveAuthPattern(pattern) {
 }
 
 // node_modules/@chrischall/mcp-utils/dist/session/index.js
-import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync, renameSync, unlinkSync } from "node:fs";
-import { dirname, join as join2, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync, chmodSync, renameSync, unlinkSync } from "node:fs";
+import { dirname as dirname2, join as join2, resolve as resolve3 } from "node:path";
 import { homedir as homedir2 } from "node:os";
 import { randomBytes, createHmac } from "node:crypto";
 function bindingDigest(secret, salt) {
@@ -38439,7 +38567,7 @@ function createFileStatePersistence(opts) {
   const secret = opts.boundTo;
   return {
     load() {
-      if (!existsSync(filePath))
+      if (!existsSync2(filePath))
         return null;
       try {
         const raw = JSON.parse(readFileSync(filePath, "utf8"));
@@ -38469,9 +38597,9 @@ function createFileStatePersistence(opts) {
       }
     },
     save(state) {
-      const dir = dirname(filePath);
+      const dir = dirname2(filePath);
       const tmp = `${filePath}.tmp-${randomBytes(6).toString("hex")}`;
-      const dirExisted = existsSync(dir);
+      const dirExisted = existsSync2(dir);
       try {
         mkdirSync(dir, { recursive: true, mode: 448 });
         if (!dirExisted)
@@ -38488,7 +38616,7 @@ function createFileStatePersistence(opts) {
         chmodSync(filePath, 384);
       } catch (err) {
         try {
-          if (existsSync(tmp))
+          if (existsSync2(tmp))
             unlinkSync(tmp);
         } catch {
         }
@@ -38497,7 +38625,7 @@ function createFileStatePersistence(opts) {
     },
     clear() {
       try {
-        if (existsSync(filePath))
+        if (existsSync2(filePath))
           unlinkSync(filePath);
       } catch {
       }
@@ -38518,7 +38646,7 @@ function resolveStateFile(opts) {
       return homeOf(opts.env);
     if (override.startsWith("~/"))
       return join2(homeOf(opts.env), override.slice(2));
-    return resolve2(override);
+    return resolve3(override);
   }
   const dirOpts = { env: opts.env };
   if (opts.subdir !== void 0)
@@ -38531,7 +38659,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")
@@ -38698,6 +38858,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))
@@ -38713,6 +38875,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;
@@ -38753,7 +38919,7 @@ var TokenManager = class {
 };
 
 // src/client.ts
-import { dirname as dirname2, join as join5 } from "path";
+import { dirname as dirname3, join as join5 } from "path";
 import { fileURLToPath } from "url";
 
 // node_modules/@fetchproxy/protocol/dist/crypto.js
@@ -38953,6 +39119,7 @@ var KNOWN_CAPABILITIES = /* @__PURE__ */ new Set([
   "capture_redirect",
   "read_indexed_db",
   "read_dom",
+  "read_dom_list",
   "download",
   "graphql",
   "write_cookies"
@@ -39453,6 +39620,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}`);
@@ -39499,6 +39739,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) {
@@ -39569,16 +39811,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");
     }
@@ -39600,6 +39837,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)}`);
@@ -39655,6 +39894,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))
@@ -39904,6 +40164,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)
@@ -39951,7 +40229,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)) {
@@ -40059,6 +40337,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");
@@ -40160,12 +40450,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 {
@@ -40196,7 +40480,7 @@ var DEFAULT_BIND_TIMEOUT_MS = 5e3;
 async function electRole(opts) {
   const server = createServer();
   const bindTimeoutMs = opts.bindTimeoutMs ?? DEFAULT_BIND_TIMEOUT_MS;
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     let timer;
     const clearBindTimer = () => {
       if (timer) {
@@ -40212,7 +40496,7 @@ async function electRole(opts) {
           server.close();
         } catch {
         }
-        resolve3({ role: "peer" });
+        resolve4({ role: "peer" });
       } else {
         reject(e);
       }
@@ -40220,7 +40504,7 @@ async function electRole(opts) {
     const onListening = () => {
       clearBindTimer();
       server.removeListener("error", onError);
-      resolve3({ role: "host", server });
+      resolve4({ role: "host", server });
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -40317,6 +40601,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,
@@ -40485,13 +40781,14 @@ 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 { isAbsolute as isAbsolute3, join as join4 } from "node:path";
+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 isAbsolute4, join as join4 } 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 as randomBytes2 } from "node:crypto";
-import { isAbsolute as isAbsolute2, join as join3 } from "node:path";
+import { isAbsolute as isAbsolute3, join as join3 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 var SAFE_PLAIN = /^[A-Za-z0-9._-]+$/;
 var SAFE_SCOPED = /^@[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
@@ -40500,7 +40797,7 @@ function envIdentityDir() {
   if (raw === void 0)
     return void 0;
   const dir = raw.trim();
-  if (dir === "" || !isAbsolute2(dir))
+  if (dir === "" || !isAbsolute3(dir))
     return void 0;
   return dir;
 }
@@ -40557,7 +40854,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;
@@ -40566,35 +40863,80 @@ async function sweepStagingFiles(dir, serverName) {
   } catch {
     return;
   }
-  await Promise.all(names.filter((name) => staging.test(name)).map((name) => unlink(join3(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 = join3(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()) {
+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}.${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;
 }
 
 // node_modules/@fetchproxy/server/dist/extension-trust.js
@@ -40604,7 +40946,7 @@ function envTrustDir(env = process.env) {
   if (raw === void 0)
     return void 0;
   const dir = raw.trim();
-  if (dir !== "" && isAbsolute3(dir))
+  if (dir !== "" && isAbsolute4(dir))
     return dir;
   console.warn(`[fetchproxy] ignoring ${TRUST_DIR_ENV}=${JSON.stringify(raw)}: it is not an absolute path. The extension pin will be written beside the identity instead, which is not where you pointed it \u2014 if that directory is read-only, no pin is ever kept.`);
   return void 0;
@@ -40695,10 +41037,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;
+  }
 }
 
 // node_modules/@fetchproxy/server/dist/host.js
@@ -40735,6 +41082,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) {
@@ -40778,6 +41126,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;
@@ -40804,8 +41153,8 @@ async function startHost(opts) {
   let rejectOwnSession;
   let ownSessionReady;
   function resetSessionPromise() {
-    ownSessionReady = new Promise((resolve3, reject) => {
-      resolveOwnSession = resolve3;
+    ownSessionReady = new Promise((resolve4, reject) => {
+      resolveOwnSession = resolve4;
       rejectOwnSession = reject;
     });
     ownSessionReady.catch(() => {
@@ -40848,6 +41197,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;
@@ -41038,6 +41412,7 @@ async function startHost(opts) {
             if (extensionWs !== ws)
               return;
             ownSession = new SessionState(key);
+            ownDecryptFailures = 0;
             ownPendingPairCode = null;
             resolveOwnSession(ownSession);
           } else {
@@ -41059,15 +41434,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)
@@ -41126,6 +41528,7 @@ async function startHost(opts) {
           rejectOwnSession(new Error("extension disconnected before ready"));
         }
         ownSession = dropOwnSessionAndEphemeral();
+        ownDecryptFailures = 0;
         ownPendingPairCode = null;
         resetSessionPromise();
         disconnectListeners.forEach((cb) => cb());
@@ -41140,13 +41543,20 @@ 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 {
+            }
+          }
+        }
       }
     });
   });
   return {
-    close: () => new Promise((resolve3) => {
+    close: () => new Promise((resolve4) => {
       for (const client2 of wss.clients) {
         try {
           client2.terminate();
@@ -41154,7 +41564,7 @@ async function startHost(opts) {
         }
       }
       wss.close(() => {
-        opts.httpServer.close(() => resolve3());
+        opts.httpServer.close(() => resolve4());
       });
     }),
     sendOwnInner: async (inner) => {
@@ -41184,26 +41594,42 @@ 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
   });
-  await new Promise((resolve3, reject) => {
+  const dialTimeoutMs = opts.dialTimeoutMs ?? PEER_DIAL_TIMEOUT_MS;
+  await new Promise((resolve4, reject) => {
+    let timer;
     const onOpen = () => {
       cleanup();
-      resolve3();
+      resolve4();
     };
     const onError = (e) => {
       cleanup();
       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)}`);
@@ -41222,6 +41648,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,
@@ -41245,6 +41672,7 @@ async function startPeer(opts) {
   const renegotiateListeners = [];
   const pendingPairListeners = [];
   const closeListeners = [];
+  const extensionDisconnectListeners = [];
   let session = null;
   let sessionEphemeral = null;
   function dropSessionEphemeral() {
@@ -41264,10 +41692,24 @@ async function startPeer(opts) {
   let warnedUnverifiablePairCode = false;
   let resolveFirstReady;
   let rejectFirstReady;
-  const sessionPromise = new Promise((resolve3, reject) => {
-    resolveFirstReady = resolve3;
-    rejectFirstReady = reject;
-  });
+  let sessionPromise;
+  let sessionPromiseSettled = false;
+  function resetSessionPromise() {
+    sessionPromiseSettled = false;
+    sessionPromise = new Promise((resolve4, reject) => {
+      resolveFirstReady = (st) => {
+        sessionPromiseSettled = true;
+        resolve4(st);
+      };
+      rejectFirstReady = (e) => {
+        sessionPromiseSettled = true;
+        reject(e);
+      };
+    });
+    sessionPromise.catch(() => {
+    });
+  }
+  resetSessionPromise();
   let extensionHello = null;
   let extensionGone = false;
   let cachedPin = void 0;
@@ -41364,6 +41806,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) {
@@ -41480,19 +41928,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) => {
@@ -41510,6 +41969,9 @@ async function startPeer(opts) {
     onClose: (cb) => {
       closeListeners.push(cb);
     },
+    onExtensionDisconnect: (cb) => {
+      extensionDisconnectListeners.push(cb);
+    },
     close: () => ws.close()
   };
   return handle;
@@ -41517,15 +41979,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";
   }
@@ -41717,6 +42179,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;
@@ -41729,6 +42202,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;
@@ -41768,6 +42242,32 @@ function assertUrlInDomains(field, url2, 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
@@ -41816,12 +42316,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
@@ -41867,7 +42377,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];
@@ -41914,6 +42424,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
@@ -42043,6 +42563,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()
@@ -42074,6 +42595,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
@@ -42083,6 +42605,10 @@ var FetchproxyServer = class {
         this.stopKeepalive();
         this.rejectAllPending();
       });
+      this.peerHandle.onExtensionDisconnect(() => {
+        this.stopKeepalive();
+        this.rejectAllPending();
+      });
       this.peerHandle.onPendingPair((code) => {
         this.rejectAllPending(this.pairingErrorMessage(code));
       });
@@ -42094,9 +42620,9 @@ var FetchproxyServer = class {
         if (this.closing || this.peerHandle === null)
           return;
         this.stopKeepalive();
-        this.rejectAllPending();
         this.peerHandle = null;
         this.role = null;
+        void this.recoverFromHostLoss();
       });
     }
   }
@@ -42117,7 +42643,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) {
@@ -42129,16 +42655,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();
@@ -42287,13 +42814,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;
@@ -42305,6 +42835,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;
@@ -42315,13 +42846,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((resolve3) => {
-      this.pending.set(id, resolve3);
+    const pending = this.guardPending(new Promise((resolve4) => {
+      this.pending.set(id, resolve4);
     }));
-    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;
@@ -42330,12 +42873,12 @@ var FetchproxyServer = class {
     try {
       return await Promise.race([
         pending,
-        new Promise((resolve3) => {
+        new Promise((resolve4) => {
           timer = setTimeout(() => {
             this.pending.delete(id);
             const elapsedMs = Date.now() - start;
             const error62 = `fetchproxy: ${init.url} did not respond within ${timeoutMs}ms`;
-            resolve3({
+            resolve4({
               ok: false,
               error: error62,
               kind: "timeout",
@@ -42395,7 +42938,7 @@ var FetchproxyServer = class {
     });
     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;
@@ -42416,6 +42959,7 @@ var FetchproxyServer = class {
               port: this.opts.port,
               elapsedMs: Date.now() - start,
               retryAttempted: false,
+              retrySafe,
               graceMs,
               ...requestedTimeoutMs !== void 0 ? { requestedTimeoutMs } : {}
             }));
@@ -42433,7 +42977,7 @@ var FetchproxyServer = class {
    * 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,
@@ -42441,7 +42985,8 @@ var FetchproxyServer = class {
         role: this.role,
         port: this.opts.port,
         elapsedMs: result.elapsedMs,
-        retryAttempted
+        retryAttempted,
+        retrySafe
       });
     }
     if (result.kind === "content_script_unreachable") {
@@ -42477,9 +43022,9 @@ var FetchproxyServer = class {
     if (opts.subdomain !== void 0)
       assertSubdomainLabel(opts.subdomain);
     const baseDomain = this.resolveBaseDomain(opts.domain);
-    const isAbsolute4 = path.startsWith("http://") || path.startsWith("https://");
+    const isAbsolute5 = path.startsWith("http://") || path.startsWith("https://");
     let host;
-    if (isAbsolute4) {
+    if (isAbsolute5) {
       try {
         host = new URL(path).host;
       } catch {
@@ -42488,7 +43033,7 @@ var FetchproxyServer = class {
     } else {
       host = opts.subdomain ? `${opts.subdomain}.${baseDomain}` : baseDomain;
     }
-    const url2 = isAbsolute4 ? path : `https://${host}${path}`;
+    const url2 = isAbsolute5 ? path : `https://${host}${path}`;
     assertUrlInDomains("request url", url2, this.opts.domains);
     let tabUrl = `https://${host}/`;
     if (opts.viaTab !== void 0) {
@@ -42515,9 +43060,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,
@@ -42557,17 +43105,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 ?? {} };
@@ -42579,7 +43131,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
@@ -42600,7 +43152,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 +
@@ -42614,6 +43167,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";
@@ -42627,7 +43185,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,
@@ -42635,12 +43194,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)}`);
     }
@@ -42697,18 +43253,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.).
@@ -42741,8 +43298,8 @@ var FetchproxyServer = class {
       const tabUrl = `https://${host}/`;
       inner = { type: "request", id, op: "read_cookies", init: { tabUrl } };
     }
-    const pending = this.guardPending(new Promise((resolve3) => {
-      this.pendingReadCookies.set(id, resolve3);
+    const pending = this.guardPending(new Promise((resolve4) => {
+      this.pendingReadCookies.set(id, resolve4);
     }));
     await this.sendInnerFrame(inner);
     const result = await this._withVerbTimeout(pending, this.pendingReadCookies, id, `https://${host}`);
@@ -42800,11 +43357,19 @@ var FetchproxyServer = class {
         ...cookiePath !== void 0 ? { path: cookiePath } : {}
       }
     };
-    const pending = this.guardPending(new Promise((resolve3, reject) => {
-      this.pendingWriteCookies.set(id, { resolve: resolve3, reject });
+    const pending = this.guardPending(new Promise((resolve4, reject) => {
+      this.pendingWriteCookies.set(id, { resolve: resolve4, 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
@@ -42863,8 +43428,8 @@ var FetchproxyServer = class {
         ...opts.pointers ? { pointers: { ...opts.pointers } } : {}
       }
     };
-    const pending = this.guardPending(new Promise((resolve3, reject) => {
-      this.pendingStorage.set(id, { resolve: resolve3, reject });
+    const pending = this.guardPending(new Promise((resolve4, reject) => {
+      this.pendingStorage.set(id, { resolve: resolve4, reject });
     }));
     await this.sendInnerFrame(inner);
     return this._withVerbTimeout(pending, this.pendingStorage, id, `https://${host}`);
@@ -42907,53 +43472,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 = { ...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++;
@@ -42968,8 +43487,8 @@ var FetchproxyServer = class {
         ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {}
       }
     };
-    const pending = this.guardPending(new Promise((resolve3, reject) => {
-      this.pendingCapture.set(id, { resolve: resolve3, reject });
+    const pending = this.guardPending(new Promise((resolve4, reject) => {
+      this.pendingCapture.set(id, { resolve: resolve4, reject });
     }));
     await this.sendInnerFrame(inner);
     return this._withVerbTimeout(
@@ -43002,53 +43521,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++;
@@ -43062,8 +43535,8 @@ var FetchproxyServer = class {
         ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {}
       }
     };
-    const pending = this.guardPending(new Promise((resolve3, reject) => {
-      this.pendingRedirect.set(id, { resolve: resolve3, reject });
+    const pending = this.guardPending(new Promise((resolve4, reject) => {
+      this.pendingRedirect.set(id, { resolve: resolve4, reject });
     }));
     await this.sendInnerFrame(inner);
     return this._withVerbTimeout(
@@ -43093,52 +43566,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, 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) {
@@ -43153,8 +43631,8 @@ var FetchproxyServer = class {
         ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {}
       }
     };
-    const pending = this.guardPending(new Promise((resolve3, reject) => {
-      this.pendingDownload.set(id, { resolve: resolve3, reject });
+    const pending = this.guardPending(new Promise((resolve4, reject) => {
+      this.pendingDownload.set(id, { resolve: resolve4, reject });
     }));
     await this.sendInnerFrame(inner);
     return this._withVerbTimeout(
@@ -43167,7 +43645,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
     );
   }
   /**
@@ -43212,8 +43692,8 @@ var FetchproxyServer = class {
         keys: [...opts.keys]
       }
     };
-    const pending = this.guardPending(new Promise((resolve3, reject) => {
-      this.pendingIdb.set(id, { resolve: resolve3, reject });
+    const pending = this.guardPending(new Promise((resolve4, reject) => {
+      this.pendingIdb.set(id, { resolve: resolve4, reject });
     }));
     await this.sendInnerFrame(inner);
     return this._withVerbTimeout(pending, this.pendingIdb, id, origin);
@@ -43252,12 +43732,58 @@ var FetchproxyServer = class {
       op: "read_dom",
       init: { origin, names: [...opts.names] }
     };
-    const pending = this.guardPending(new Promise((resolve3, reject) => {
-      this.pendingStorage.set(id, { resolve: resolve3, reject });
+    const pending = this.guardPending(new Promise((resolve4, reject) => {
+      this.pendingStorage.set(id, { resolve: resolve4, reject });
     }));
     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((resolve4, reject) => {
+      this.pendingDomList.set(id, { resolve: resolve4, 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.
@@ -43298,11 +43824,12 @@ var FetchproxyServer = class {
         ...opts.tabUrl !== void 0 ? { tabUrl: opts.tabUrl } : {}
       }
     };
-    const pending = this.guardPending(new Promise((resolve3, reject) => {
-      this.pendingGraphql.set(id, { resolve: resolve3, reject });
+    const pending = this.guardPending(new Promise((resolve4, reject) => {
+      this.pendingGraphql.set(id, { resolve: resolve4, 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);
@@ -43339,6 +43866,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) {
@@ -43427,6 +43955,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);
@@ -43486,42 +44028,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;
+    }
+    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);
+      }
     }
-    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();
+  }
+  /**
+   * 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
@@ -43614,6 +44247,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 ?? [];
@@ -44012,7 +44651,7 @@ async function loginWithPassword(username, password) {
 // package.json
 var package_default = {
   name: "ofw-mcp",
-  version: "2.19.0",
+  version: "2.19.2",
   license: "MIT",
   mcpName: "io.github.chrischall/ofw-mcp",
   description: "OurFamilyWizard MCP server for Claude \u2014 developed and maintained by AI (Claude Code)",
@@ -44046,11 +44685,11 @@ var package_default = {
     typecheck: "tsc -p tsconfig.json --noEmit"
   },
   dependencies: {
-    "@chrischall/mcp-utils": "^2.0.0",
-    "@fetchproxy/bootstrap": "^3.0.1",
+    "@chrischall/mcp-utils": "^2.4.0",
+    "@fetchproxy/bootstrap": "^3.2.0",
     "@modelcontextprotocol/server": "^2.0.0",
-    dotenv: "^17.4.2",
-    zod: "^4.6.2"
+    dotenv: "^18.0.0",
+    zod: "^4.6.5"
   },
   devDependencies: {
     "@modelcontextprotocol/client": "^2.0.0",
@@ -44183,7 +44822,7 @@ function reportCacheWriteFailure(err) {
 
 // src/client.ts
 try {
-  const dir = dirname2(fileURLToPath(import.meta.url));
+  const dir = dirname3(fileURLToPath(import.meta.url));
   await loadDotenvSafely({ path: join5(dir, "..", ".env") });
 } catch {
 }
@@ -44658,7 +45297,7 @@ function registerUserTools(server, client2) {
   });
   server.registerTool("ofw_get_notifications", {
     description: "Get OurFamilyWizard dashboard summary: unread message count, upcoming events, outstanding expenses. Note: updates your last-seen status.",
-    annotations: { readOnlyHint: false }
+    annotations: { readOnlyHint: true }
   }, async () => {
     const data = await client2.request("GET", "/pub/v1/users/useraccountstatus");
     return jsonResponse(data);
@@ -44666,7 +45305,7 @@ function registerUserTools(server, client2) {
 }
 
 // src/tools/healthcheck.ts
-function registerHealthcheckTools(server, client2, resolve3 = resolveAuth) {
+function registerHealthcheckTools(server, client2, resolve4 = resolveAuth) {
   registerCredentialHealthcheckTool({
     server,
     prefix: "ofw",
@@ -44677,7 +45316,7 @@ function registerHealthcheckTools(server, client2, resolve3 = resolveAuth) {
     probePath: "/pub/v2/profiles",
     resolveCredential: async () => {
       try {
-        const auth = await resolve3();
+        const auth = await resolve4();
         return {
           source: auth.source,
           // Never the token. Expiry is the fact that explains a connector
@@ -46519,7 +47158,7 @@ async function extractAttachment(bytes, mimeType, fileName, opts = {}) {
 
 // src/tools/attachments.ts
 import { readFileSync as readFileSync2, statSync, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { basename, dirname as dirname3, extname } from "node:path";
+import { basename, dirname as dirname4, extname } from "node:path";
 var MIME_BY_EXT = {
   ".pdf": "application/pdf",
   ".png": "image/png",
@@ -46599,7 +47238,7 @@ var NodeAttachmentIO = class {
     }
   }
   writeDownload(dest, bytes) {
-    mkdirSync2(dirname3(dest), { recursive: true });
+    mkdirSync2(dirname4(dest), { recursive: true });
     writeFileSync2(dest, bytes);
   }
 };
@@ -46943,7 +47582,7 @@ function registerMessageTools(server, client2, cacheProvider, attachmentIO) {
   });
   server.registerTool("ofw_list_messages", {
     description: 'List messages from the local OurFamilyWizard cache. Supports filtering by folder, date range, and a substring query on subject+body. Pagination is offset-based (1-based `page`) but if you know what you want (a date range, a topic), prefer the filters over walking pages \u2014 the cache may have 1000+ messages. Results are newest-first by default; `sort:"oldest"` starts at the old end of a range instead of paging to it. Returns an explicit `complete` boolean describing the RESULT SET: true means "this is every message on OurFamilyWizard matching these filters as of freshness.asOf" \u2014 check it before asserting a count. An empty result from a cache that is not verified-fresh is REFUSED (result:"UNVERIFIED_EMPTY") rather than reported as an absence; pass autoRefresh:true to sync and answer instead.',
-    annotations: { readOnlyHint: false },
+    annotations: { readOnlyHint: true },
     inputSchema: external_exports.object({
       folderId: external_exports.string().describe('Folder name: "inbox", "sent", or "both" (default "both")').optional(),
       page: external_exports.number().int().min(1).describe("Page number (default 1)").optional(),
@@ -47038,7 +47677,7 @@ function registerMessageTools(server, client2, cacheProvider, attachmentIO) {
   });
   server.registerTool("ofw_get_message", {
     description: 'Get a single OurFamilyWizard message OR draft by ID. Reads from local cache when available; otherwise fetches from OFW \u2014 and for an UNREAD INBOX message that fetch marks it read and stamps a "First Viewed" time the co-parent can see, which is part of the record and cannot be undone. Pass allowMarkRead:false to refuse such a fetch instead (cached bodies, sent messages and already-read messages are unaffected, because none of them stamp anything). For ids that match a draft (in the drafts cache), the response carries folder="drafts" and the body/subject/recipients reflect the drafts cache (which ofw_sync_messages keeps fresh) \u2014 drafts have no `fromUser`, and `sentAt`/`fetchedBodyAt` mirror the draft\'s `modifiedAt`. For inbox/sent messages, folder is "inbox" or "sent" as before.',
-    annotations: { readOnlyHint: false },
+    annotations: { readOnlyHint: false, destructiveHint: true },
     inputSchema: external_exports.object({
       messageId: external_exports.string().describe("Message ID (also accepts draft IDs \u2014 drafts are routed via the drafts cache)"),
       allowMarkRead: external_exports.boolean().describe("Default true (the long-standing behaviour). Set false to refuse a fetch that would mark an unread INBOX message as READ on OurFamilyWizard \u2014 an irreversible, co-parent-visible change to the record. Reads that cannot stamp anything (a cached body, a sent message, an already-read message) still succeed. The server-wide OFW_ALLOW_MARK_READ=false is a ceiling this argument cannot raise.").optional(),
@@ -47433,7 +48072,7 @@ ${JSON.stringify(
   }
   server.registerTool("ofw_list_drafts", {
     description: 'List draft messages, verified against OurFamilyWizard in ONE call: when the local drafts cache is not verified-fresh, a cheap drafts sync runs first by default (verify:true), so the answer is server-confirmed without a second call. Pass verify:false to answer purely from the cache (no OFW requests). Returns an explicit `complete` boolean describing the RESULT SET: true means "these are ALL the drafts on OurFamilyWizard as of freshness.asOf" \u2014 check it before saying "you have N drafts". Each draft carries its `draftKey` (stable across the create-then-delete churn of editing) when one is known. An empty result from a cache that is not verified-fresh is REFUSED (result:"UNVERIFIED_EMPTY"); pass autoRefresh:true to sync and answer instead.',
-    annotations: { readOnlyHint: false },
+    annotations: { readOnlyHint: false, destructiveHint: false },
     inputSchema: external_exports.object({
       page: external_exports.number().int().min(1).describe("Page number (default 1)").optional(),
       size: external_exports.number().int().min(1).describe("Drafts per page (default 50)").optional(),
@@ -47531,7 +48170,7 @@ ${JSON.stringify(
   });
   if (allowDrafts) server.registerTool("ofw_save_draft", {
     description: "Save a message as a draft in OurFamilyWizard. RECIPIENTS: OurFamilyWizard does NOT persist recipients on drafts \u2014 recipientIds are accepted but the saved draft comes back with none (documented OFW behavior, noted once in the response, not warned about; supply recipientIds at send time instead). IDENTITY: the response leads with `draftKey`, the stable identity that survives editing \u2014 key off it, because the `id` changes on EVERY edit (replacing a draft creates a NEW draft and deletes the old one; OFW's update-in-place endpoint silently no-ops, so we never use it). Pass messageId to replace an existing draft; the response.id will be the NEW id, and a transparency NOTE documents the swap and which fields were carried over. THREADING: if replyToId is provided, the cache may rewrite it to the latest reply in the thread (note included). The threading verdict is read from OFW's full echo (replyToId/inReplyTo/showContext) \u2014 a warning appears ONLY when the reply linkage was genuinely dropped or re-targeted, and the response's top-level replyToId/inReplyTo always agree with its listData. Attach files via myFileIDs (from ofw_upload_attachment). After saving, the tool re-fetches the draft from OFW, and the returned `revision` reflects that authoritative state (so it will match on your next edit). SAFETY: because replacing DESTROYS the old draft rather than merging, passing messageId first re-reads that draft from OFW and REFUSES the write if its subject/body/recipients changed since you read it (drafts edited in the OFW web app do not bump any timestamp, so the local cache can be silently behind). A pure replyToId normalization by OFW is NOT treated as a conflict. The refusal returns the current server body under serverBody \u2014 merge your edit into it and retry with expectedRevision.",
-    annotations: { readOnlyHint: false },
+    annotations: { readOnlyHint: false, destructiveHint: false },
     inputSchema: external_exports.object({
       subject: external_exports.string().describe("Message subject"),
       body: external_exports.string().describe("Message body text"),
@@ -47712,7 +48351,7 @@ ${text}` : text);
   });
   server.registerTool("ofw_get_unread_sent", {
     description: 'List sent messages that have not been read by one or more recipients. Reads from local cache. Returns `complete` describing whether every sent message was scanned. An empty SENT cache that is not verified-fresh is REFUSED (result:"UNVERIFIED_EMPTY") rather than reported as "nothing sent"; pass autoRefresh:true to sync and answer instead.',
-    annotations: { readOnlyHint: false },
+    annotations: { readOnlyHint: true },
     inputSchema: external_exports.object({
       page: external_exports.number().int().min(1).describe("Page (default 1)").optional(),
       size: external_exports.number().int().min(1).describe("Per page (default 50)").optional(),
@@ -47829,7 +48468,7 @@ ${text}` : text);
   });
   server.registerTool("ofw_download_attachment", {
     description: "Download an OFW message attachment by fileId and return content you can actually read. Inline delivery walks a ladder and returns the first rung that works: (1) host-renderable images (PNG/JPEG/GIF/WEBP) come back as ImageContent; (2) .xlsx/.csv/.tsv, .pdf, .docx, .pptx and text files come back as EXTRACTED CONTENT \u2014 per-sheet CSV, per-page/slide text, document text \u2014 in the response JSON under `extracted`; (3) anything else comes back as an EmbeddedResource blob of the raw bytes. The meta block names the rung as `deliveredVia` and, when it falls through to bytes, lists what was tried in `deliveryAttempts`. Reported mime types are always normalized to a bare media type (no charset/name parameters). In disk mode the bytes are saved to ~/Downloads/ofw-mcp/ and the response carries the absolute path; pass extract:true to ALSO get the extracted content in that response. The default for `inline` can be flipped server-side via the OFW_INLINE_ATTACHMENTS env var. On a hosted deployment with no filesystem, disk mode is unavailable, so inline is forced (forcedInline:true) rather than failing \u2014 a saveTo path never costs you the content. fileId comes from attachments[].fileId on ofw_get_message. Override disk destination with OFW_ATTACHMENTS_DIR or saveTo. Re-downloading to the same path is a no-op (disk mode only).",
-    annotations: { readOnlyHint: false },
+    annotations: { readOnlyHint: true },
     inputSchema: external_exports.object({
       fileId: external_exports.number().describe("Attachment file id (from ofw_get_message \u2192 attachments[].fileId)"),
       inline: external_exports.boolean().describe("If true, return content inline as MCP content blocks and skip the disk write. If false, write to disk and return the path \u2014 except on a hosted deployment with no filesystem, where inline is forced (forcedInline:true) so the content is still returned. If omitted, falls back to the OFW_INLINE_ATTACHMENTS env var (default: false = disk).").optional(),
@@ -47916,7 +48555,7 @@ ${text}` : text);
   });
   server.registerTool("ofw_sync_messages", {
     description: "Sync messages from OurFamilyWizard into the local cache. Returns counts per folder and a list of unread inbox messages whose bodies were NOT fetched (to avoid mark-as-read on OFW). Call ofw_get_message(id) on those to read them. EVERY call re-checks the newest page first, so new messages are picked up promptly even while an old-history backfill is still running; only then does it spend what is left of its budget advancing that backfill. Pass deep:true to walk all OFW pages instead of stopping at the first all-cached page (use to backfill suspected gaps). Sync is BOUNDED and RESUMABLE: on hosted deployments a per-call OFW-request budget (env OFW_SYNC_MAX_REQUESTS, or the maxRequests argument) caps how far one call walks; when the budget is hit the response reports done:false with a note \u2014 call again with the SAME arguments to resume. done:false means older history is still being backfilled; it does NOT mean recent messages are missing. Local installs are unbounded by default (done is always true).",
-    annotations: { readOnlyHint: false },
+    annotations: { readOnlyHint: false, destructiveHint: false },
     inputSchema: external_exports.object({
       folders: external_exports.array(external_exports.enum(["inbox", "sent", "drafts"])).min(1).describe("Folders to sync (default: all three). Must be non-empty if given \u2014 an empty list would sync nothing while reporting success.").optional(),
       fetchUnreadBodies: external_exports.boolean().describe('If true, also fetch bodies for unread inbox messages \u2014 which marks each one READ on OurFamilyWizard and stamps a co-parent-visible "First Viewed" time that cannot be undone. Defaults to the OFW_FETCH_UNREAD_BODIES env var (false unless set), and is forced off entirely when OFW_ALLOW_MARK_READ=false.').optional(),
@@ -47942,7 +48581,7 @@ ${text}` : text);
   });
   server.registerTool("ofw_check_freshness", {
     description: 'Cheaply confirm whether the local cache still matches OurFamilyWizard, WITHOUT running a full sync. Use this before asserting anything about current state \u2014 especially "draft X is still sitting unsent". Costs one OFW request for the folder check plus one per messageId. For each folder it returns the live server count next to the cached count. For each id it returns a LIVE lifecycle `state` \u2014 "draft" | "sent" | "received" | "deleted" | "unknown" \u2014 alongside `folder`, `sentAt`, `existsOnServer` and a content comparison. `state` is the field that answers "is this still a draft?": a draft that has been SENT still exists on the server, so existsOnServer:true never distinguished the two. A cached draft whose state is no longer "draft" reports inSync:false even when its text is byte-identical. Content is compared by revision hash, because OFW draft timestamps do NOT change when a draft is edited in the web app. Does not fetch bodies into the cache, does not touch attachments, and does not depend on sync state. For draftKeys, or a full live draft inventory, use ofw_status.',
-    annotations: { readOnlyHint: false },
+    annotations: { readOnlyHint: true },
     inputSchema: external_exports.object({
       folders: external_exports.array(external_exports.enum(["inbox", "sent", "drafts"])).min(1).describe("Folders to compare cached vs live counts for. Defaults to all three when messageIds is not given. Must be non-empty if given.").optional(),
       messageIds: external_exports.array(external_exports.number()).describe(`Specific ids to verify against OFW (max ${MAX_FRESHNESS_IDS}). Ids cached as drafts, as sent messages, or as already-read inbox messages are probed freely \u2014 none of those can stamp the record. Anything else is skipped \u2014 see allowMarkRead.`).optional(),
@@ -48001,7 +48640,7 @@ ${text}` : text);
   });
   server.registerTool("ofw_status", {
     description: 'ONE live call that answers "where does everything stand?". This is the call that should back any status summary about drafts or specific messages \u2014 never session memory, and never a cached read alone. With no arguments it returns the FULL current draft inventory, verified against OurFamilyWizard. Pass ids and/or draftKeys to get each one\'s live lifecycle `state` ("draft" | "sent" | "received" | "deleted" | "unknown") with `sentAt` and `viewedAt`. A draftKey is the stable identity ofw_save_draft returns: editing a draft mints a new OFW id every time (create-then-delete), so the key is the only way to ask "what happened to the thing I was working on?" \u2014 it resolves to the chain\'s current id and keeps resolving after the draft is SENT (state:"sent" with sentMessageId). The top-level `complete` is true ONLY when every part of this snapshot was verified live; if it is false, do not state a draft count or a lifecycle claim from this payload.',
-    annotations: { readOnlyHint: false },
+    annotations: { readOnlyHint: true },
     inputSchema: external_exports.object({
       ids: external_exports.array(external_exports.number()).describe(`Message/draft ids to resolve to a live state (combined with draftKeys, max ${MAX_FRESHNESS_IDS} probes per call).`).optional(),
       draftKeys: external_exports.array(external_exports.string()).describe("Stable draft keys (from ofw_save_draft / ofw_list_drafts) to resolve to their CURRENT id and state.").optional(),
@@ -48378,8 +49017,8 @@ function registerJournalTools(server, client2) {
 
 // src/cache/node.ts
 import { DatabaseSync } from "node:sqlite";
-import { mkdirSync as mkdirSync3, chmodSync as chmodSync2, existsSync as existsSync2 } from "node:fs";
-import { dirname as dirname4 } from "node:path";
+import { mkdirSync as mkdirSync3, chmodSync as chmodSync2, existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname5 } from "node:path";
 
 // src/cache/store.ts
 function rowFromDb(r) {
@@ -48963,10 +49602,10 @@ var NodeSqlDriver = class {
   }
 };
 function enforceCachePermissions(dbPath) {
-  chmodSync2(dirname4(dbPath), 448);
+  chmodSync2(dirname5(dbPath), 448);
   chmodSync2(dbPath, 384);
   for (const sibling of [`${dbPath}-wal`, `${dbPath}-shm`]) {
-    if (existsSync2(sibling)) chmodSync2(sibling, 384);
+    if (existsSync3(sibling)) chmodSync2(sibling, 384);
   }
 }
 var OFWCache = class _OFWCache extends LocalCacheStore {
@@ -48977,7 +49616,7 @@ var OFWCache = class _OFWCache extends LocalCacheStore {
   db;
   static open(path) {
     const memory = path === ":memory:";
-    if (!memory) mkdirSync3(dirname4(path), { recursive: true });
+    if (!memory) mkdirSync3(dirname5(path), { recursive: true });
     const db = new DatabaseSync(path);
     if (!memory) enforceCachePermissions(path);
     db.exec("PRAGMA journal_mode = WAL");
@@ -49007,7 +49646,7 @@ var nodeCacheProvider = () => nodeCache ??= OFWCache.open(getCacheDbPath());
 var nodeAttachmentIO = new NodeAttachmentIO();
 await runMcp({
   name: "ofw",
-  version: "2.19.0",
+  version: "2.19.2",
   // x-release-please-version
   deps: client,
   tools: [