dsh-remote-web 0.7.3 → 0.7.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-web",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "description": "公网远程控制 DeepSeek Harness（dsh web）：安装即得专属加密地址，人在外面也能用手机访问电脑上的 dsh——无需同一局域网/WiFi、无需公网 IP 与内网穿透，全程加密；手机端 100% 还原电脑体验（对话/工具/审批/设置）。技术用户可选自建服务，流量走自己的服务器。Remote control DeepSeek Harness (dsh web) from anywhere over the public internet — install, get an encrypted URL, use it from your phone on any network (dual-half cordis plugin: Settings panel + same-origin /dsh-remote routes). (2026-09 由 dsh-remote-ui 更名 / renamed from dsh-remote-ui; dsh-remote 的 dsh web 插件半，不是纯 UI/皮肤插件)",
   "type": "module",
   "main": "lib/index.js",

package/runtime/clients/dsh-remote/dsh-bridge.mjs

@@ -484,6 +484,26 @@ const CHUNK_SIZE = 200 * 1024;
 // 单个 HTTP 请求的兜底超时(秒)。dsh 的 prompt 等操作可能跑很久,给足余量。
 const HTTP_TIMEOUT_MS = 120_000;
 
+/**
+ * 隧道 WS **接收**上限,与 relay-router 的 `WS_MAX_PAYLOAD`(256MB) 对齐。
+ *
+ * 【为什么要显式抬高】`ws` 的**客户端**默认 `maxPayload = 100MiB`;而 router → bridge
+ * 方向的帧**不分块**(router 的 `sendToBridge` 直接 `ws.send(JSON.stringify(frame))`),
+ * 最大的一帧来自上传:`/api/session/uploadFileBinary` 的请求体在 router 侧被
+ * `bodyBuf.toString("base64")` 后塞进帧里 —— router `MAX_BODY_BYTES = 64MiB`,
+ * 64MiB 的请求体 = 89.5MB 的 base64 字符串,离 100MiB 只剩 ~15% 余量。
+ * 一旦越界,`ws` 以 1009(message too big) 直接关闭:bridge 掉线 → router 对所有
+ * 后续请求回 502 `device_offline`(生产上"连续 502、怎么重试都失败"就是这个形态),
+ * 而**用户只看到"上传失败"**。对齐 256MB 后这一侧不再是瓶颈(内存风险仍由 router 的
+ * MAX_BODY_BYTES 兜住,这里只是不再替 router 提前掐线)。
+ */
+export const TUNNEL_WS_MAX_PAYLOAD = 256 * 1024 * 1024;
+/** 隧道 `new WebSocket` 的选项(导出给用例钉住 maxPayload,避免以后被"顺手删掉")。 */
+export const TUNNEL_WS_OPTIONS = Object.freeze({ followRedirects: false, maxPayload: TUNNEL_WS_MAX_PAYLOAD });
+
+/** 需要「长请求」可观测性的路径:大文件上传最典型(分钟级、几十 MB、失败无解释)。 */
+const LONG_REQUEST_PATH_RE = /^\/api\/session\/uploadFileBinary(?:\?|$)/;
+
 // ---------- E2EE 运行时(默认禁用;main() 启动时按配置/服务端开关初始化) ----------
 
 /**
@@ -736,6 +756,125 @@ export async function maybeCompressResponse({ buf, contentType, contentEncoding,
   return { buf: out, headers: { "content-encoding": "gzip" } };
 }
 
+/**
+ * 帧里请求体的**字节数**(http 帧一律 base64;旧协议是原始文本按 UTF-8 计)。
+ * 只用于日志/错误回包里的 `bytes`,算错不影响转发。
+ */
+export function requestBodyBytes(body, isB64) {
+  if (body === undefined || body === null || body === "") return 0;
+  const s = String(body);
+  if (!isB64) return Buffer.byteLength(s, "utf8");
+  // base64 → 字节数 = 去掉 padding 后的长度 * 3/4(避免为了记日志再解一遍几十 MB)
+  const pad = s.endsWith("==") ? 2 : s.endsWith("=") ? 1 : 0;
+  return Math.max(0, Math.floor((s.length * 3) / 4) - pad);
+}
+
+/**
+ * 把「上游 fetch 失败」翻译成**用户能懂、客服能查**的 code + message。
+ *
+ * 背景(生产 2026-10-20~22):上传接口的 22 次 502 里有 24 字节的 `{"error":"fetch failed"}`
+ * —— 手机端只看到"上传失败",客服拿到的日志也只有一句 undici 的 `fetch failed`,
+ * 既分不清"上游没起来"和"请求太大超时",也没法告诉用户该做什么。分类后:
+ *   - `upstream_timeout`     本机 dsh web 120s 没响应(大文件/上游卡住);
+ *   - `upstream_unreachable` 连不上本机 dsh web(退出/换端口/连接被重置);
+ *   - `upstream_error`       其余(带原始 message 与 cause code)。
+ * 纯函数、无 IO —— 502 回包与日志共用同一份结论,导出给用例钉住 code。
+ *
+ * @param {any} e fetch 抛出的错误(可能带 undici 的 `cause.code`)
+ * @returns {{code:string,message:string,detail:string}}
+ */
+export function classifyUpstreamError(e) {
+  const name = String((e && e.name) || "");
+  const msg = String((e && e.message) || e || "");
+  const cause = e && typeof e.cause === "object" && e.cause ? e.cause : null;
+  const causeCode = String((cause && cause.code) || (e && e.code) || "").toUpperCase();
+  if (name === "TimeoutError" || name === "AbortError" || /timed out|timeout|aborted due to timeout/i.test(msg)) {
+    return {
+      code: "upstream_timeout",
+      message: `本机 dsh web 在 ${Math.round(HTTP_TIMEOUT_MS / 1000)} 秒内没有响应(文件太大或电脑端卡住),请稍后重试;反复失败请确认电脑端 DSH 仍在运行。`,
+      detail: causeCode || name || "timeout"
+    };
+  }
+  if (/ECONNREFUSED|ECONNRESET|ENOTFOUND|EAI_AGAIN|EHOSTUNREACH|ENETUNREACH|EPIPE|UND_ERR|socket hang up|fetch failed|other side closed|terminated/i.test(causeCode + " " + msg)) {
+    return {
+      code: "upstream_unreachable",
+      message: "连不上电脑端的 dsh web(可能已退出或换了端口);bridge 会自动重新发现,请稍后重试。",
+      detail: causeCode || msg.slice(0, 80)
+    };
+  }
+  return {
+    code: "upstream_error",
+    message: `转发到本机 dsh web 失败: ${msg || "未知错误"}`,
+    detail: causeCode
+  };
+}
+
+/** 在 `/api/file?path=...` 的 path 参数里取文件名(取最后一段;非法输入回落 download)。 */
+export function downloadFilenameOf(filePath) {
+  const raw = String(filePath || "").replace(/[\x00-\x1f\x7f]/g, "");
+  const cleaned = raw.replace(/\\/g, "/").replace(/\/+$/, "");
+  const base = cleaned.split("/").filter(Boolean).pop() || "";
+  return base && base !== "." && base !== ".." ? base : "download";
+}
+
+/**
+ * 下载语义(C):给 `/api/file` 的**导航**请求补 `Content-Disposition: attachment`。
+ *
+ * 【为什么需要】上游 dsh web 的 `/api/file` 只给 `Content-Type`,**没有** Content-Disposition
+ * (dsh-api-session-controller 的 serveFile)。iOS Safari 于是把 PDF/大图**内联**打开;
+ * 而上游同时带 `Content-Security-Policy: sandbox; default-src 'none'`,内联页经常直接空白 ——
+ * 用户看到的正是"下载只能在电脑端查看"。加 attachment 让手机浏览器落到下载管理器。
+ *
+ * 【为什么只对导航加】同一个 `/api/file` 也被官方前端当 `<img src>` 用(聊天里的绝对路径图片),
+ * 无差别加 attachment 有把图片预览打成下载的风险。判定顺序:
+ *   1. 方法必须是 GET,路径必须是 `/api/file`;
+ *   2. 响应必须是 2xx 且**有实体**(200/206):4xx/5xx 是错误页,加了 attachment 会
+ *      让浏览器把「登录失效/文件太大」的报错正文**下载成文件**,比原来更糟;
+ *   3. 上游**已经**给了 content-disposition(attachment 或 inline)→ 一律不覆盖(上游语义优先);
+ *   4. `?download=1/0` 显式指定:1 强制加、0 强制不加;
+ *   5. 没有显式参数时看导航特征:有 `sec-fetch-dest` 就只认 `document`;
+ *      没有(老浏览器)则要求 Accept 含 `text/html`(导航)。
+ *      `image`/`empty`(fetch/XHR)/`iframe` 一律不动 —— 子资源加载本来就不受 attachment 影响,
+ *      但没必要冒任何风险。
+ *
+ * @param {{method?:string,path?:string,status?:number,reqHeaders?:object,resHeaders?:object}} args
+ * @returns {string|null} 需要附加的 Content-Disposition 值;null = 不附加
+ */
+export function downloadDispositionOf({ method = "GET", path = "", status = 200, reqHeaders = {}, resHeaders = {} } = {}) {
+  if (String(method || "").toUpperCase() !== "GET") return null;
+  if (status !== 200 && status !== 206) return null; // 错误页不伪装成下载
+  const raw = String(path || "");
+  const q = raw.indexOf("?");
+  const pathname = q === -1 ? raw : raw.slice(0, q);
+  const search = q === -1 ? "" : raw.slice(q + 1);
+  if (pathname !== "/api/file") return null;
+  if (headerValue(resHeaders, "content-disposition")) return null; // 上游已有 → 不覆盖
+  let params = null;
+  try {
+    params = new URLSearchParams(search);
+  } catch {
+    params = null;
+  }
+  const explicit = params ? params.get("download") : null;
+  if (explicit === "0" || explicit === "false") return null;
+  if (explicit !== "1" && explicit !== "true") {
+    const dest = headerValue(reqHeaders, "sec-fetch-dest").toLowerCase();
+    if (dest) {
+      if (dest !== "document") return null;
+    } else if (!headerValue(reqHeaders, "accept").toLowerCase().includes("text/html")) {
+      return null; // 没有导航特征(老浏览器) → 保守不动
+    }
+  }
+  const name = downloadFilenameOf(params ? params.get("path") : "");
+  // RFC 5987 的 ext-value:Safari/Chrome/Firefox 都认 filename*;同时给一个 ASCII 回退,
+  // 免得只认 filename= 的老客户端把文件存成 URL 里的 "file"(连带丢扩展名)。
+  // 非 ASCII 名(中文等)的 ASCII 回退统一成 download.<ext> —— 比一串下划线可读。
+  const encoded = encodeURIComponent(name).replace(/['()*]/g, (c) => "%" + c.charCodeAt(0).toString(16).toUpperCase());
+  const ext = (/\.([A-Za-z0-9]{1,8})$/.exec(name) || [""])[0];
+  const ascii = /[^\x20-\x7e]/.test(name) ? `download${ext}` : name.replace(/["\\]/g, "_") || "download";
+  return `attachment; filename="${ascii}"; filename*=UTF-8''${encoded}`;
+}
+
 /**
  * 进行中的 SSE 流:frameId → AbortController。
  * 手机侧断开时,中继会发 `http-abort`,这里据此掐掉上游(否则电脑上会留一条永不结束的连接)。
@@ -868,6 +1007,13 @@ async function doHttp(method, path, reqHeaders, body, isB64) {
   // 若我们自行 gzip,必须在 sanitize 之后把 content-encoding: gzip 补回,手机才能正确解压。
   const headers = sanitizeResponseHeaders(Object.fromEntries(res.headers.entries()));
   const contentType = res.headers.get("content-type") || "";
+  // 下载语义(C):`/api/file` 的**导航**响应补 Content-Disposition: attachment。
+  // 上游只给 Content-Type(iOS 会内联打开 PDF/大图,叠加 sandbox CSP 后常常一片空白),
+  // 手机浏览器就不会落到下载管理器 —— 判据见 downloadDispositionOf(子资源/图片不动)。
+  {
+    const disposition = downloadDispositionOf({ method, path: safe, status: res.status, reqHeaders, resHeaders: headers });
+    if (disposition) headers["content-disposition"] = disposition;
+  }
   if (!contentType.includes("text/event-stream")) { // SSE 长连不缓冲不注入(见模块注释)
     const m = maybeInjectMobileAdapter({ buf, contentType });
     if (m.injected) {
@@ -980,6 +1126,9 @@ export async function handleHttpFrame(dchOrSend, frame) {
   const send = toSender(dchOrSend);
   const { id, method = "GET", path = "/", headers = {}, body, bodyBase64: isB64 } = frame;
   const t0 = Date.now();
+  // 长请求(大文件上传)的可观测性:上行字节与耗时都要进日志/错误回包,见 B 段注释。
+  const bytesIn = requestBodyBytes(body, !!isB64);
+  const isLongRequest = LONG_REQUEST_PATH_RE.test(String(path));
   // 页面还活着：任何后续请求都撤掉「镜像页加载」看门狗（见 armMirrorLoadWatch）
   if (mirrorLoadWatch) { mirrorLoadWatch = null; }
   // 桌面授权引导(方案A):POST /_e2ee/intro(device/channel 形态归一)—— 本地应答,不连上游
@@ -1036,17 +1185,67 @@ export async function handleHttpFrame(dchOrSend, frame) {
     const reply = await doHttp(method, path, headers, body, !!isB64);
     reply.id = id;
     reply.type = "http";
-    send(reply);
-    console.log(`[bridge] ${method} ${path} → ${reply.status} (${Date.now() - t0}ms, ${(reply.body.length * 3 / 4 / 1024).toFixed(0)}KB)`);
+    const sent = send(reply);
+    const ms = Date.now() - t0;
+    const outBytes = Math.floor((reply.body.length * 3) / 4);
+    if (isLongRequest) {
+      // 长请求(大文件上传)单独记:上行字节、总耗时、状态码 —— 客服排查"上传失败"最需要这三样。
+      console.log(`[bridge] ${method} ${path} → ${reply.status} (${ms}ms, 上行 ${(bytesIn / 1024 / 1024).toFixed(2)}MB, 下行 ${(outBytes / 1024).toFixed(0)}KB)`);
+    } else {
+      console.log(`[bridge] ${method} ${path} → ${reply.status} (${ms}ms, ${(outBytes / 1024).toFixed(0)}KB)`);
+    }
+    reportUndelivered(sent, { method, path, phase: "reply", ms, bytesIn, outBytes });
   } catch (e) {
     // 上游不可达是「端口可能变了」的最强信号（Desktop 换端口 / dsh web 重启到别的端口）：
     // 触发一次带冷却的重新发现，后续请求自动跟上，不必重启 bridge。
     void refreshUpstream("上游请求失败");
-    console.log(`[bridge] ${method} ${path} 上游错误: ${e.message}`);
-    send({ id, type: "http", status: 502, headers: { "content-type": "application/json" }, body: Buffer.from(JSON.stringify({ error: String(e.message || e) })).toString("base64"), bodyBase64: true });
+    const ms = Date.now() - t0;
+    const info = classifyUpstreamError(e);
+    const detail = info.detail ? `, detail=${info.detail}` : "";
+    const tag = isLongRequest ? "长请求" : "普通请求";
+    const line = `[bridge] ${method} ${path} 上游错误(${info.code}): ${info.message}（${tag}, ${ms}ms, 上行 ${bytesIn}B${detail}）`;
+    if (isLongRequest || info.code !== "upstream_error") console.error(line);
+    else console.log(line);
+    // 502 body:从 `{"error":"fetch failed"}`(24 字节、用户与客服都看不懂)改成
+    // `{error:{code,message,...}}` —— 与 bridge/router 其它错误回包同一形态。
+    // 兼容:保留顶层 code/message,老读取方从 error 字符串改读这两个即可。
+    const payload = {
+      error: {
+        code: info.code,
+        message: info.message,
+        method,
+        path,
+        bytes: bytesIn,
+        durationMs: ms,
+        ...(info.detail ? { detail: info.detail } : {})
+      },
+      code: info.code,
+      message: info.message
+    };
+    const sent = send({
+      id,
+      type: "http",
+      status: 502,
+      headers: { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" },
+      body: Buffer.from(JSON.stringify(payload)).toString("base64"),
+      bodyBase64: true
+    });
+    reportUndelivered(sent, { method, path, phase: "502", ms, bytesIn, outBytes: 0 });
   }
 }
 
+/**
+ * 回包没送进隧道(ws 已断/缓冲写失败)时的**唯一在线证据**。
+ *
+ * 中继侧对"bridge 断开"只会回一句 `502 device_offline`,bridge 这边如果静默吞掉,
+ * 事后就分不清是"桥没收到请求"还是"桥回了但没送出去"。这里只在 send 明确返回 false
+ * (makeChunkedSender 捕获到 ws.send 抛错)时记一行 —— 不改变任何行为。
+ */
+function reportUndelivered(sent, { method, path, phase, ms, bytesIn, outBytes }) {
+  if (sent !== false) return;
+  console.error(`[bridge] ${method} ${path} ${phase} 回包未能送入中继(tunnel_closed): ${ms}ms, 上行 ${bytesIn}B, 下行 ${outBytes}B`);
+}
+
 /** 桌面授权引导(方案A):POST /_e2ee/intro —— 桥端本地应答,不连上游。
  *  路由层已按 dsh_token cookie 完成同账号授权(device/channel 形态都只到本设备);
  *  这里仅当桥端 E2EE 启用时一次性下发派生 MK(内存转发,不落盘不写日志)。 */
@@ -1536,7 +1735,9 @@ async function registerDeviceInAccount(token) {
 
 function connectTunnel(token) {
   const endpoint = tunnelEndpoint(TUNNEL_URL);
-  const ws = new WebSocket(endpoint, { followRedirects: false });
+  // maxPayload 必须显式给:ws 客户端默认 100MiB,而 router→bridge 的单帧不分块,
+  // 大文件上传的 base64 请求体可以顶到 89.5MB(见 TUNNEL_WS_MAX_PAYLOAD 注释)。
+  const ws = new WebSocket(endpoint, TUNNEL_WS_OPTIONS);
   const send = makeChunkedSender((s) => { if (ws.readyState === WebSocket.OPEN) ws.send(s); });
   let heartbeat;
   let pongReceived = true;

package/runtime/clients/dsh-remote/e2ee-shim-script.js

@@ -571,9 +571,56 @@
     var noBody = status === 204 || status === 205 || status === 304 || bodyU8.length === 0;
     return new Response(noBody ? null : bodyU8, { status: status, headers: hdrs });
   }
+  /* ---- 网络层失败的一次极短重试(D,2026-10-23) ----------------------------------
+   * 为什么:大文件读(`/api/workspaceFiles/readBytes`)、会话历史(`/api/session/page`)、
+   * Office/PDF 渲染(`/api/officeToPdf/`)在弱网/中继限速下经常"读到一半断"——浏览器只
+   * 看到一次 fetch reject 或空响应,上层(文档预览/会话列表)直接落到失败态,用户得手点
+   * 「重新读取文件」。这些都是**幂等读**,重发一次几乎无副作用,却能吃掉大部分瞬时断流。
+   * 边界:
+   *   - 只白名单幂等读路径;上传/写入路径永不重试;
+   *   - 最多 1 次,间隔 300ms;
+   *   - 只有**网络层失败**(fetch reject / 信封响应体为空或非 JSON)才重试;
+   *     已有响应体的 4xx/5xx(明文错误页)一律不重试;解封/解压失败(密钥问题)不重试;
+   *   - 每次重试都重新封**新 nonce 的信封**:桥端 http 防重放是 5 分钟 nonce 滑动窗口,
+   *     复用同一个信封会被判 replay;
+   *   - 调用方已 abort(切页/锁屏)→ 不再重试。
+   */
+  var SE_RETRY_PATH_PREFIXES = ["/api/workspaceFiles/", "/api/session/page", "/api/officeToPdf/"];
+  var SE_RETRY_DELAY_MS = 300;
+  /**
+   * 路径是否命中幂等读白名单。
+   *
+   * ⚠️ 必须用 `seUpstreamPathOf()` 归一后再匹配 —— 与加密策略(seShouldEncryptHttp)
+   * **同一口径**:device 形态下客户端会把路径改写成 `/remote/<deviceId>/api/...`,
+   * 直接拿 `urlObj.pathname` 匹配会漏掉这类请求(同样是被加密的读,失败同样该重试)。
+   * 匹配规则:目录式前缀(以 "/" 结尾)按前缀;其余(如 `/api/session/page`)要求**精确相等** ——
+   * 这样 `/api/session/pages`、`/api/session/page/extra` 都不会被误命中。
+   */
+  function seRetryableReadPath(fullPath) {
+    var up = "";
+    try { up = seUpstreamPathOf(fullPath); } catch (e) { return false; }
+    var p = String(up || "");
+    var q = p.indexOf("?");
+    if (q !== -1) p = p.slice(0, q);
+    for (var i = 0; i < SE_RETRY_PATH_PREFIXES.length; i++) {
+      var pre = SE_RETRY_PATH_PREFIXES[i];
+      if (pre.charAt(pre.length - 1) === "/") {
+        if (p.indexOf(pre) === 0) return true; // 目录式前缀(/api/workspaceFiles/、/api/officeToPdf/)
+      } else if (p === pre) {
+        return true; // 精确路径(/api/session/page)
+      }
+    }
+    return false;
+  }
+  function seDelay(ms) { return new Promise(function (resolve) { setTimeout(resolve, ms); }); }
+  /** 与 fetch 的 abort 语义一致(调用方已 abort 时不该再重试,直接抛 AbortError)。 */
+  function seAbortSignalError() {
+    try { return new DOMException("The operation was aborted.", "AbortError"); } catch (e) { var err = new Error("The operation was aborted."); err.name = "AbortError"; return err; }
+  }
   /**
    * fetch 包装核心:命中策略 → 密封→发→响应信封解密→重建 Response;
    * 未命中/跨源/无法读取 body/明文响应 → 原样透传(零行为)。
+   * 幂等读路径的网络层失败最多重试一次(见上面 SE_RETRY_* 注释)。
    * @param {function} origFetch
    * @param {{sess: SeSession, origin: string}} ctx
    */
@@ -599,50 +646,69 @@
     }
     var upstream = seUpstreamPathOf(fullPath);
     var plain = seEncodeHttpReqPlain({ method: req.method, path: upstream, headers: seHeadersForEnvelope(req.headers), bodyBytes: bodyBytes });
-    var n = seRandomBytes(SE_NONCE_BYTES);
-    var nonceB64 = seBytesToB64(n);
-    var env = await ctx.sess.seal({ kind: "http", dir: SE_DIR_P2B, counter: 0, data: plain, nonceBytes: n });
-    var outerHeaders = seEnvelopeHeaders(ctx.sess.sessId);
-    var cookieH = seHeaderValueOf(req.headers, "cookie");
-    if (cookieH && req.credentials !== "omit") outerHeaders.cookie = cookieH; // node 测试显式 cookie;浏览器同源自动带
-    var res;
-    try {
-      res = await origFetch(urlObj.href, {
-        method: "POST",
-        headers: outerHeaders,
-        body: JSON.stringify(env),
-        credentials: req.credentials,
-        signal: req.signal
-      });
-    } catch (e) { throw e; }
-    /* router/桥端明文错误页 → 原样透传(零行为)，但**先看一眼**是不是桥端在说"会话我不认识"
-       (x-dsh-e2ee-error)——是的话清掉本机失效交接单并给出明确原因(见 seNoteE2eeError)。 */
-    if (!seIsEnvelopeResponse(res)) { seNoteE2eeError(res, ctx); return res; }
-    var envResp = null;
-    try { envResp = await res.json(); } catch (e) {
-      seNotifyFail("响应信封非法");
-      return seErrorResponse("bad_envelope", "⚠ 无法解密:响应信封非法");
-    }
-    var opened = null;
-    try {
-      opened = await ctx.sess.open({ kind: "http-resp", dir: SE_DIR_B2P, env: envResp, counter: envResp.c == null ? 0 : envResp.c, reqNonceB64: nonceB64 });
-    } catch (e) {
-      var code = e && e.code ? e.code : "auth_failed";
-      seNotifyFail("响应解封失败: " + (e && e.message || code));
-      return seErrorResponse(code, "⚠ 无法解密(" + code + "):密钥不一致、传输被篡改或会话已过期。请返回设备列表重新解锁。");
-    }
-    var rp = null;
-    try { rp = seDecodeHttpRespPlain(opened.data); } catch (e) {
-      seNotifyFail("响应明文非法");
-      return seErrorResponse("bad_plain", "⚠ 无法解密:响应明文非法");
-    }
-    var bodyU8 = rp.bodyBytes instanceof Uint8Array ? rp.bodyBytes : (rp.bodyB64 ? seB64ToBytes(rp.bodyB64) : new Uint8Array(0));
-    if (rp.enc === "gzip" && bodyU8.length) {
-      var un = await seGunzip(bodyU8);
-      if (!un) return seErrorResponse("gunzip", "⚠ 无法解压:响应 gzip 解压失败");
-      bodyU8 = un;
+    var attempts = seRetryableReadPath(fullPath) ? 2 : 1;
+    var lastErr = null;
+    for (var attempt = 0; attempt < attempts; attempt++) {
+      if (attempt > 0) {
+        if (req.signal && req.signal.aborted) throw seAbortSignalError();
+        await seDelay(SE_RETRY_DELAY_MS);
+        if (req.signal && req.signal.aborted) throw seAbortSignalError();
+      }
+      var n = seRandomBytes(SE_NONCE_BYTES);
+      var nonceB64 = seBytesToB64(n);
+      var env = await ctx.sess.seal({ kind: "http", dir: SE_DIR_P2B, counter: 0, data: plain, nonceBytes: n });
+      var outerHeaders = seEnvelopeHeaders(ctx.sess.sessId);
+      var cookieH = seHeaderValueOf(req.headers, "cookie");
+      if (cookieH && req.credentials !== "omit") outerHeaders.cookie = cookieH; // node 测试显式 cookie;浏览器同源自动带
+      var res;
+      try {
+        res = await origFetch(urlObj.href, {
+          method: "POST",
+          headers: outerHeaders,
+          body: JSON.stringify(env),
+          credentials: req.credentials,
+          signal: req.signal
+        });
+      } catch (e) {
+        lastErr = e;
+        if (attempt + 1 < attempts) continue; // 网络层失败 → 白名单读路径再来一次
+        throw e; // 与改动前一致:不吞 fetch 异常(调用方按网络错误处理)
+      }
+      /* router/桥端明文错误页 → 原样透传(零行为)，但**先看一眼**是不是桥端在说"会话我不认识"
+         (x-dsh-e2ee-error)——是的话清掉本机失效交接单并给出明确原因(见 seNoteE2eeError)。
+         注意:这里已经有完整响应体,4xx/5xx 也**不重试**。 */
+      if (!seIsEnvelopeResponse(res)) { seNoteE2eeError(res, ctx); return res; }
+      var envResp = null;
+      try { envResp = await res.json(); } catch (e) {
+        // 信封响应体为空/被截断(网络层) → 白名单读路径再来一次
+        if (attempt + 1 < attempts) continue;
+        seNotifyFail("响应信封非法");
+        return seErrorResponse("bad_envelope", "⚠ 无法解密:响应信封非法");
+      }
+      var opened = null;
+      try {
+        opened = await ctx.sess.open({ kind: "http-resp", dir: SE_DIR_B2P, env: envResp, counter: envResp.c == null ? 0 : envResp.c, reqNonceB64: nonceB64 });
+      } catch (e) {
+        // 密钥不一致/被篡改/会话过期:重试解决不了,保持原有显式失败
+        var code = e && e.code ? e.code : "auth_failed";
+        seNotifyFail("响应解封失败: " + (e && e.message || code));
+        return seErrorResponse(code, "⚠ 无法解密(" + code + "):密钥不一致、传输被篡改或会话已过期。请返回设备列表重新解锁。");
+      }
+      var rp = null;
+      try { rp = seDecodeHttpRespPlain(opened.data); } catch (e) {
+        seNotifyFail("响应明文非法");
+        return seErrorResponse("bad_plain", "⚠ 无法解密:响应明文非法");
+      }
+      var bodyU8 = rp.bodyBytes instanceof Uint8Array ? rp.bodyBytes : (rp.bodyB64 ? seB64ToBytes(rp.bodyB64) : new Uint8Array(0));
+      if (rp.enc === "gzip" && bodyU8.length) {
+        var un = await seGunzip(bodyU8);
+        if (!un) return seErrorResponse("gunzip", "⚠ 无法解压:响应 gzip 解压失败");
+        bodyU8 = un;
+      }
+      return seBuildResponse(rp.status, rp.headers, bodyU8);
     }
-    return seBuildResponse(rp.status, rp.headers, bodyU8);
+    /* 每轮都以 return/throw 收尾,这里只是兜底(避免静态检查报"可能不返回") */
+    throw lastErr || seErr("e2ee_failed", "e2ee: fetch 包装未产生结果");
   }
 
   /* ---- 数据 WS 代理(逐消息信封;上层看到的是解密后的原文) ---- */

package/runtime/clients/dsh-remote/mobile-adapter.mjs

@@ -1048,7 +1048,18 @@ const SCRIPT = `(() => {
         compatOfficial: maCompatOfficial,
         scrim: maScrimStats,
         retry: maRetryStats,
-        load: { slow: maLoadWatch.slow, apiFails: maLoadWatch.apiFails, lastApiStatus: maLoadWatch.lastApiStatus }
+        load: { slow: maLoadWatch.slow, apiFails: maLoadWatch.apiFails, lastApiStatus: maLoadWatch.lastApiStatus },
+        // E2EE 死会话自动恢复 / 回前台重连（2026-10-23）：只作诊断，不参与任何判定。
+        // var 提升在此处可能尚未赋值（maPublishDiag 在恢复层定义之前就会被调用一次）→ 用 typeof 兜住。
+        resume: (typeof maResumeState !== "undefined" && maResumeState)
+          ? {
+              armed: !!maResumeState.armed, done: !!maResumeState.done,
+              reason: maResumeState.reason, lastAt: maResumeState.lastAt,
+              fg: (typeof maFgState !== "undefined" && maFgState)
+                ? { count: maFgState.count, lastAt: maFgState.lastAt, src: maFgState.lastSrc, probing: !!maFgState.probing }
+                : null
+            }
+          : null
       };
     } catch (e) { /* 诊断失败绝不影响页面 */ }
   }
@@ -1704,6 +1715,445 @@ const SCRIPT = `(() => {
     } catch (e) { /* 忽略 */ }
   }, MA_LOAD_WATCH_MS);
 
+  /* ============================================================================
+   * E2EE 死会话自动恢复 + 回到前台重连（2026-10-23，iOS 断线重连体验）
+   *
+   * 现场（iOS 用户反馈）：退出 Safari / 切到别的 App 一两分钟再回来，镜像页几乎必然重载；
+   * 而桥端 E2EE 会话表是**进程内存**（24h TTL + CAP 32 LRU，电脑端重启即丢）—— 重载后
+   * 常撞上「加密会话已失效，需要重新解锁」，旧行为只能回设备列表手动重新解锁。
+   * 本段只做两件事，都**只读**状态（window.__dshE2eeBadge + dsh-e2ee-badge 事件），
+   * 不碰任何加解密逻辑、不重建会话、不自己重连 WS：
+   *
+   *   ① 死会话 → 自动回 /app/?resume=<deviceId>&from=mirror，由 native.html 用
+   *      「记住本机」的派生 MK 静默解锁再回镜像页（全程无手势、无密码输入）；
+   *   ② 从后台恢复（pageshow persisted / visibilitychange）→ 一次轻量探针确认隧道还在；
+   *      失败则唤醒官方客户端（online 事件）并再探一次，仍失败只给**可见**提示
+   *      （复用底部提示条的「重试 / 返回设备列表 / 复制诊断」出口），绝不做静默无限重连。
+   *
+   * 触发条件极窄（业主验收口径：只有"确认 E2EE 不可用"才触发）：
+   *   · 只认镜像页路径 /remote/<deviceId>/(不是镜像页直接什么都不做)；
+   *   · 只认桥端明确答复的「加密会话已失效 / 需要重新解锁」；
+   *   · 纯明文（「未加密」「未解锁」「明文」）默认**绝不**打扰 —— 用户可能主动选了「暂不加密」。
+   *     唯一例外：本页是为了甩掉死会话才被 shim 重载过（sessionStorage 里有它的重载闸门），
+   *     且本机还留着「记住本机」的派生 MK —— 那才是"本该加密、却被自动降级成明文"。
+   * 闸门：本页最多一次 + 60 秒冷却 + 60 秒窗口内最多 2 次（sessionStorage，跨重载仍有效）。
+   *
+   * 注入体纪律：本段不得出现反引号；字符串里不得出现反斜杠转义（模板字符串会先吃一层）。
+   * ========================================================================= */
+
+  /* ===DSH-MA-RESUME-ENGINE-START=== */
+  /* ===DSH-MA-RESUME-PURE-START=== */
+  /** 镜像页设备 id：/remote/<deviceId>/… → deviceId（纯函数；不是镜像页返回空串）。
+   *  设备 id 之后要拼进跳转地址，所以只接受 URL 安全字符，其它一律当没有。 */
+  function maDeviceIdOfMirrorPath(pathname) {
+    try {
+      var parts = String(pathname || "").split("/").filter(Boolean);
+      if (parts[0] !== "remote" || !parts[1]) return "";
+      var id = "";
+      try { id = decodeURIComponent(parts[1]); } catch (e) { id = ""; }
+      return /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(id) ? id : "";
+    } catch (e) { return ""; }
+  }
+
+  /**
+   * 是否该自动恢复（纯函数，便于单测）。输入 E2EE 徽标状态 + 本机上下文。
+   * @param {{mode?:string,text?:string}|null} st  __dshE2eeBadge.state()
+   * @param {{mk?:boolean,deadReloadAt?:number,now?:number}} ctx  mk=有派生 MK;deadReloadAt=死会话重载闸门时间戳
+   * @returns {string} "" 不恢复；"dead_session" 桥端明确说不认这张票；"plaintext_after_dead" 抢修降级后的明文
+   */
+  function maE2eeResumeDecision(st, ctx) {
+    try {
+      if (!st || typeof st !== "object") return "";
+      var mode = String(st.mode || "");
+      var text = String(st.text || "");
+      if (mode === "ok" || !text) return "";
+      var c = ctx && typeof ctx === "object" ? ctx : {};
+      /* ① 桥端明确答复：会话没了 / 需要重新解锁。这是**唯一**的确定信号。 */
+      if (/加密会话已失效|会话已失效|需要重新解锁/.test(text)) return "dead_session";
+      /* ② 明文/未解锁：默认绝不打扰。仅当"本页刚为甩掉死会话被重载过 + 本机有记住的 MK"才抢修 ——
+            这两个条件同时成立时，用户本来应该是加密的，现在只是被自动降级成了明文。 */
+      if (/未加密|未解锁|明文/.test(text)) {
+        var reloadAt = Number(c.deadReloadAt) || 0;
+        var now = Number(c.now) || 0;
+        if (c.mk === true && reloadAt > 0 && now > reloadAt && now - reloadAt < 90 * 1000) {
+          return "plaintext_after_dead";
+        }
+        return "";
+      }
+      return "";
+    } catch (e) { return ""; }
+  }
+  /* ===DSH-MA-RESUME-PURE-END=== */
+
+  var MA_RESUME_DELAY_MS = 400;          // 认出死会话后 400ms 才跳（让 shim 自己的收尾先跑完，避免两路导航抢）
+  var MA_RESUME_COOLDOWN_MS = 60 * 1000; // 两次恢复之间的冷却
+  var MA_RESUME_WINDOW_MS = 60 * 1000;   // 时间窗
+  var MA_RESUME_MAX_IN_WINDOW = 2;       // 窗口内最多 2 次（与 native.html 闸门一致，双层兜底）
+  var MA_RESUME_KEY = "dsh-ma-e2ee-resume";
+  var MA_DEAD_RELOAD_KEY = "dsh-e2ee-dead-reload"; // e2ee-shim 的"每页只重载一次"闸门（只读）
+  var MA_MK_KEY = "dsh-e2ee-mk-v1";                // native.html「记住本机」的派生 MK（只读）
+  var MA_FG_MIN_BG_MS = 8000;            // 后台停留 <8s 不算"断线场景"，不打扰
+  var MA_FG_COOLDOWN_MS = 60 * 1000;     // 回前台恢复的冷却
+  var MA_FG_MAX_PER_PAGE = 3;            // 本页最多 3 次（防抖动/循环）
+  var MA_PROBE_TIMEOUT_MS = 4000;        // 探针超时
+  var MA_PROBE_RETRY_MS = 2500;          // 唤醒官方客户端后再探的间隔
+
+  var maResumeState = { done: false, redirecting: false, lastAt: 0, reason: "", armed: false };
+  var maFgState = { hiddenAt: 0, lastAt: 0, count: 0, probing: false, lastSrc: "" };
+
+  /** 读 E2EE 徽标状态（shim 未注入 → null，全程不动作）。 */
+  function maE2eeStateNow() {
+    try {
+      return window.__dshE2eeBadge && typeof window.__dshE2eeBadge.state === "function"
+        ? window.__dshE2eeBadge.state() : null;
+    } catch (e) { return null; }
+  }
+
+  /** 本机上下文：有没有「记住本机」的 MK、shim 是否刚为死会话重载过（都只读）。 */
+  function maResumeContext() {
+    var mk = false, reloadAt = 0;
+    try { mk = !!(window.localStorage && window.localStorage.getItem(MA_MK_KEY)); } catch (e) { mk = false; }
+    try { reloadAt = Number((window.sessionStorage && window.sessionStorage.getItem(MA_DEAD_RELOAD_KEY)) || 0) || 0; } catch (e2) { reloadAt = 0; }
+    return { mk: mk, deadReloadAt: reloadAt, now: Date.now() };
+  }
+
+  /** 闸门：本页一次 + 冷却 + 时间窗内限次（sessionStorage 跨重载仍有效）。 */
+  function maResumeGatePass(now) {
+    try {
+      if (maResumeState.done || maResumeState.redirecting) return false;
+      if (maResumeState.lastAt && now - maResumeState.lastAt < MA_RESUME_COOLDOWN_MS) return false;
+      var raw = null;
+      try { raw = window.sessionStorage && window.sessionStorage.getItem(MA_RESUME_KEY); } catch (e0) { raw = null; }
+      var hits = null;
+      try { hits = JSON.parse(raw || "[]"); } catch (e1) { hits = []; }
+      if (!Array.isArray(hits)) hits = [];
+      var kept = [];
+      for (var i = 0; i < hits.length; i++) {
+        var t = Number(hits[i]);
+        if (isFinite(t) && now - t >= 0 && now - t < MA_RESUME_WINDOW_MS) kept.push(t);
+      }
+      if (kept.length >= MA_RESUME_MAX_IN_WINDOW) return false;
+      kept.push(now);
+      try { window.sessionStorage && window.sessionStorage.setItem(MA_RESUME_KEY, JSON.stringify(kept.slice(-8))); } catch (e2) { /* 存不下不构成"永不恢复" */ }
+      return true;
+    } catch (e) { return true; }
+  }
+
+  /** 自动回设备列表入口（由 /app/ 用「记住本机」的 MK 静默解锁后回镜像页）。 */
+  function maE2eeTryResume(reason) {
+    try {
+      var dev = maDeviceIdOfMirrorPath(window.location.pathname);
+      if (!dev) return false;
+      var now = Date.now();
+      if (!maResumeGatePass(now)) { maPublishDiag(); return false; }
+      maResumeState.done = true;
+      maResumeState.redirecting = true;
+      maResumeState.lastAt = now;
+      maResumeState.reason = String(reason || "");
+      maPublishDiag();
+      var to = "/app/?resume=" + encodeURIComponent(dev) + "&from=mirror";
+      setTimeout(function () {
+        try { window.location.replace(to); return; } catch (e1) { /* 继续 */ }
+        try { window.location.assign(to); } catch (e2) { /* 继续 */ }
+        try { window.location.href = to; } catch (e3) { /* 放弃（例如沙箱里没有 location） */ }
+      }, MA_RESUME_DELAY_MS);
+      return true;
+    } catch (e) { return false; }
+  }
+
+  function maDelay(ms) {
+    return new Promise(function (resolve) {
+      try { setTimeout(resolve, Number(ms) || 0); } catch (e) { resolve(); }
+    });
+  }
+
+  /** 底部提示条的**临时**用途：回前台重连失败时给一条可见说明（复用既有重试/返回出口）。
+   *  优先级让给首屏慢加载（那条有更高价值，别抢它的文案）；用户关过一次就不再打扰。 */
+  function maShowFgHint(text) {
+    try {
+      if (maLoadWatch.dismissed || maLoadWatch.slow) return;
+      var bar = maLoadWatch.barEl || maLoadMountBar();
+      if (!bar) return;
+      maLoadWatch.fgHint = true;
+      if (maLoadWatch.barTxt) maLoadWatch.barTxt.textContent = String(text || "");
+      bar.hidden = false;
+    } catch (e) { /* 提示失败不影响恢复本身 */ }
+  }
+  function maHideFgHint() {
+    try {
+      if (!maLoadWatch.fgHint) return;
+      maLoadWatch.fgHint = false;
+      maLoadHideBar();
+    } catch (e) { /* 忽略 */ }
+  }
+
+  /** 唤醒官方客户端：派发一次 online 事件（它自己按"网络恢复"重连）—— 只派发，不替它重连。 */
+  function maNudgeOnline() {
+    try {
+      var ev = null;
+      try { ev = new Event("online"); } catch (e0) { ev = null; }
+      if (ev) window.dispatchEvent(ev);
+    } catch (e) { /* 忽略 */ }
+  }
+
+  /**
+   * 轻量探针：**必须过桥**才算数（业主 2026-10-23 指正）。
+   *
+   * 为什么不能用 manifest：relay-router 的设备无关静态资源兜底（serveDeviceFreeAsset）会**本地直出**
+   * manifest.webmanifest / favicon.svg —— 打这些路径只能证明"手机能连上中继"，证明不了
+   * "这台电脑的隧道还活着"，而 iOS 回前台的真实故障恰恰是后者。
+   *
+   * 现在打 「HEAD /remote/<deviceId>/」：走 resolveRoute → authorizeRemote → bridge 的 http 帧 →
+   * 电脑端 dsh 返回 200（HEAD 无 body，成本最低）。判定按业主口径：
+   *   OK   = 拿到响应且 status 不是 502/504（502/504 = 隧道/上游不可达，这才是失败）
+   *          401/403/404 都算"有回应"（cookie 过期或路径不存在不等于隧道断了，加密状态另判）
+   *   FAIL = 网络错误 / 超时 / 502 / 504
+   * 兜底：HEAD 被中间代理/旧环境拒绝时（第一次探针 reject），第二次退化为
+   *   「GET /remote/<deviceId>/favicon.ico」（同样过桥；不在 DEVICE_FREE_ASSETS 白名单里）。
+   *
+   * @param {string} deviceId
+   * @param {boolean} [useGet] true = 走 favicon.ico 的 GET 退化路径
+   */
+  function maProbeMirrorOnce(deviceId, useGet) {
+    var tail = useGet ? "/favicon.ico" : "/";
+    var url = "/remote/" + encodeURIComponent(deviceId) + tail + "?dshProbe=" + Date.now();
+    var ctrl = null;
+    try { ctrl = typeof AbortController === "function" ? new AbortController() : null; } catch (e0) { ctrl = null; }
+    /* accept 用 json 而不是 html：router 的 isDocNavigation 在缺少 sec-fetch-* 的老浏览器上
+       会回落到 accept 判定 —— 带上 html 会被当成"页面导航"，设备离线时改走 302 引导页，
+       探针就永远看不到 502 了（这是这条探针最容易踩的坑）。 */
+    var opts = { method: useGet ? "GET" : "HEAD", cache: "no-store", headers: { accept: "application/json" } };
+    if (ctrl) opts.signal = ctrl.signal;
+    return new Promise(function (resolve) {
+      var settled = false;
+      var timer = 0;
+      var done = function (r) {
+        if (settled) return;
+        settled = true;
+        try { if (timer) clearTimeout(timer); } catch (e1) { /* 忽略 */ }
+        resolve(r);
+      };
+      try {
+        timer = setTimeout(function () {
+          try { if (ctrl) ctrl.abort(); } catch (e2) { /* 忽略 */ }
+          done({ ok: false, why: "timeout" });
+        }, MA_PROBE_TIMEOUT_MS);
+      } catch (e3) { /* 忽略 */ }
+      var p = null;
+      try { p = typeof window.fetch === "function" ? window.fetch(url, opts) : null; } catch (e4) { p = null; }
+      if (!p || typeof p.then !== "function") { done({ ok: false, why: "nocall" }); return; }
+      p.then(function (res) {
+        var status = 0;
+        try { status = Number(res && res.status) || 0; } catch (e5) { status = 0; }
+        // 502/504 = router 或上游明确"这台的隧道不可达"；其余状态码都说明"有回应"
+        done({ ok: status > 0 && status !== 502 && status !== 504, status: status });
+      }, function () { done({ ok: false, why: "reject" }); });
+    });
+  }
+
+  /** 回到前台：确认加密状态 + 一次轻量探针 → 原地重连（online）→ 再探一次 → 可见提示。 */
+  function maForegroundResume(src) {
+    try {
+      if (!maResumeState.armed) return;
+      var dev = maDeviceIdOfMirrorPath(window.location.pathname);
+      if (!dev) return;
+      var now = Date.now();
+      var gap = maFgState.hiddenAt ? now - maFgState.hiddenAt : 0;
+      maFgState.hiddenAt = 0;
+      if (gap < MA_FG_MIN_BG_MS) return;                 // 短切走不算断线
+      if (maFgState.probing) return;                     // 不叠并发
+      if (maFgState.count >= MA_FG_MAX_PER_PAGE) return;  // 本页额度用完就不再自动碰
+      if (maFgState.lastAt && now - maFgState.lastAt < MA_FG_COOLDOWN_MS) return;
+      var st = maE2eeStateNow();
+      if (!st) return;   // shim 未注入（旧 bridge/关闭 E2EE）→ 加密与本次恢复无关，官方客户端自己处理
+      var decision = maE2eeResumeDecision(st, maResumeContext());
+      if (decision) { maE2eeTryResume(decision); return; }  // 确认不可用 → 直接自动恢复（无手势）
+      maFgState.count += 1;
+      maFgState.lastAt = now;
+      maFgState.probing = true;
+      maFgState.lastSrc = String(src || "");
+      var settle = function () { try { maFgState.probing = false; } catch (e0) { /* 忽略 */ } };
+      maProbeMirrorOnce(dev).then(function (r1) {
+        if (r1 && r1.ok) { maHideFgHint(); settle(); return; }
+        maShowFgHint("网络似乎断开了，正在重新连接…");
+        maNudgeOnline();
+        // 第二次探针换 GET favicon.ico：既验证"隧道是否真的断了"，也顺手覆盖 HEAD 不被支持的旧环境
+        return maDelay(MA_PROBE_RETRY_MS).then(function () { return maProbeMirrorOnce(dev, true); }).then(function (r2) {
+          if (r2 && r2.ok) { maHideFgHint(); settle(); return; }
+          maShowFgHint("连接没有恢复。点「重试」重新加载本页，或点「返回设备列表」重新进入。");
+          settle();
+        });
+      }).then(function () { settle(); }, function () { settle(); });
+    } catch (e) { try { maFgState.probing = false; } catch (e2) { /* 忽略 */ } }
+  }
+
+  /** 徽标状态一变就看一眼（纯读，不做别的）。 */
+  function maE2eeOnBadge() {
+    try {
+      var st = maE2eeStateNow();
+      if (!st) return;
+      var decision = maE2eeResumeDecision(st, maResumeContext());
+      if (decision) maE2eeTryResume(decision);
+    } catch (e) { /* 忽略 */ }
+  }
+
+  /** 安装监听（幂等）。**只**在镜像页 /remote/<deviceId>/ 上生效。 */
+  function maArmE2eeResume() {
+    try {
+      if (maResumeState.armed) return;
+      var dev = maDeviceIdOfMirrorPath(window.location.pathname);
+      if (!dev) return;
+      maResumeState.armed = true;
+      var onBadge = function () { maE2eeOnBadge(); };
+      try { document.addEventListener("dsh-e2ee-badge", onBadge); } catch (e1) { /* 忽略 */ }
+      try { window.addEventListener("dsh-e2ee-badge", onBadge); } catch (e2) { /* 忽略 */ }
+      // shim 可能在本层挂牌前就发布了状态（注入顺序：adapter 先、shim 后，通常不会；这里兜底两次）
+      setTimeout(function () { try { maE2eeOnBadge(); } catch (e3) { /* 忽略 */ } }, 800);
+      setTimeout(function () { try { maE2eeOnBadge(); } catch (e4) { /* 忽略 */ } }, 3000);
+      // 回前台：bfcache 恢复走 pageshow(persisted)；普通切后台走 visibilitychange
+      try {
+        window.addEventListener("pageshow", function (ev) {
+          try { if (ev && ev.persisted) maForegroundResume("pageshow"); } catch (e5) { /* 忽略 */ }
+        });
+      } catch (e6) { /* 忽略 */ }
+      try {
+        document.addEventListener("visibilitychange", function () {
+          try {
+            if (document.visibilityState === "hidden") { maFgState.hiddenAt = Date.now(); return; }
+            maForegroundResume("visibilitychange");
+          } catch (e7) { /* 忽略 */ }
+        });
+      } catch (e8) { /* 忽略 */ }
+      maPublishDiag();
+    } catch (e) { /* 恢复层装不上也不能影响页面 */ }
+  }
+
+  try { maArmE2eeResume(); } catch (eResumeArm) { /* 忽略 */ }
+
+  /* ===DSH-MA-RESUME-ENGINE-END=== */
+
+  /* ============================================================================
+   * 上传失败「可读提示」（2026-10-23，文件上传反馈）
+   *
+   * 现场（生产反馈 fb_930b950aed94 + nginx 日志 22 次 502 / 12 次 413）：手机上传失败只看到
+   *   「上传失败，点击重试」。根因在 dsh 上游客户端：dsh-client-file-upload/lib/client.js
+   *   在 status !== 200 时直接抛错并**丢弃响应体**；而中继/桥端本轮已能给出可读原因
+   *   （>64MB 的 413 JSON、上游不可达的分类 502 JSON），这些文字却到不了用户。
+   *
+   * 本层只做一件事：**旁听** dsh 上传 Worker 的完成消息（{kind:"complete",status,body}），
+   * 非 200 时补一条人话提示。不改协议、不拦请求、不重试、不碰 E2EE（Worker 独立作用域，
+   * 上传内容本来就不经 shim —— 那是另案）。
+   * 触发面收窄：只接管 new Worker(..., { name: "dsh-file-upload" })，其它 Worker 原样返回；
+   * 任何异常都退回原生 Worker（上传功能绝不受本层影响）。
+   * ========================================================================= */
+  /* ===DSH-MA-UPLOAD-HINT-PURE-START=== */
+  /** 上传失败状态码 + 响应体 → 人话（纯函数）。空串 = 不提示（成功/交给 dsh 自己）。 */
+  function maUploadFailureHint(status, body) {
+    var s = Number(status) || 0;
+    if (!s || s === 200 || s === 201) return "";
+    var b = String(body == null ? "" : body);
+    if (s === 413 || /payload_too_large|body_too_large|too large|exceeds? byte limit/i.test(b)) {
+      return "上传失败：文件超过 64MB 上限，请压缩后重试，或改用电脑端上传。";
+    }
+    if (s === 502 || s === 504) return "上传失败：与电脑端的连接中断了。请重试；反复失败请确认电脑端 DSH 仍在运行。";
+    if (s === 401 || s === 403) return "上传失败：登录状态已过期，请返回设备列表重新进入后再试。";
+    var m = null;
+    try { m = JSON.parse(b); } catch (e) { m = null; }
+    var msg = "";
+    try { if (m && m.error) msg = String(m.error.message || m.error.code || ""); } catch (e2) { msg = ""; }
+    return "上传失败（HTTP " + s + "）" + (msg ? "：" + msg : "，请重试。");
+  }
+  /* ===DSH-MA-UPLOAD-HINT-PURE-END=== */
+
+  /* ===DSH-MA-UPLOAD-HINT-ENGINE-START=== */
+  var MA_UPLOAD_FAIL_KEY = "dsh-ma-upload-fail";
+  /** 底部一次性提示（自绘、6 秒自动消失、不挡点击；同一批失败只提示一次）。 */
+  function maUploadToast(text) {
+    try {
+      var now = Date.now();
+      var last = 0;
+      try { last = Number(sessionStorage.getItem(MA_UPLOAD_FAIL_KEY)) || 0; } catch (eLast) { last = 0; }
+      if (last && now - last < 4000) return;
+      try { sessionStorage.setItem(MA_UPLOAD_FAIL_KEY, String(now)); } catch (eSet) { /* 忽略 */ }
+      var doc = document;
+      var el = doc.getElementById("dsh-ma-upload-toast");
+      if (el && el.parentNode) el.parentNode.removeChild(el);
+      el = doc.createElement("div");
+      el.id = "dsh-ma-upload-toast";
+      el.setAttribute("role", "status");
+      el.textContent = String(text || "");
+      el.style.cssText = "position:fixed;left:12px;right:12px;bottom:calc(18px + env(safe-area-inset-bottom));z-index:2147483001;"
+        + "padding:10px 14px;border-radius:12px;background:rgba(32,32,32,.94);color:#fff;"
+        + "font:13px/1.5 -apple-system,BlinkMacSystemFont,'PingFang SC','Segoe UI',Roboto,sans-serif;"
+        + "box-shadow:0 6px 24px rgba(0,0,0,.35);pointer-events:none;opacity:0;transition:opacity .2s ease;";
+      (doc.body || doc.documentElement).appendChild(el);
+      setTimeout(function () { try { el.style.opacity = "1"; } catch (eF) { /* 忽略 */ } }, 16);
+      setTimeout(function () {
+        try { el.style.opacity = "0"; } catch (eO) { /* 忽略 */ }
+        setTimeout(function () { try { if (el.parentNode) el.parentNode.removeChild(el); } catch (eR) { /* 忽略 */ } }, 260);
+      }, 6000);
+    } catch (e) { /* 提示失败不影响上传本身 */ }
+  }
+  /** 旁听上传 Worker：只包 onmessage/onerror，其余成员透传（方法绑定到原生对象）。 */
+  function maTapUploadWorker(w) {
+    var proxy = null;
+    var userMsg = null;
+    var userErr = null;
+    var onMsg = function (ev) {
+      try {
+        var d = ev && ev.data;
+        if (d && d.kind === "complete") {
+          var hint = maUploadFailureHint(d.status, d.body);
+          if (hint) maUploadToast(hint);
+        }
+      } catch (eObs) { /* 忽略 */ }
+      if (typeof userMsg === "function") return userMsg.call(proxy, ev);
+      return undefined;
+    };
+    var onErr = function (ev) {
+      if (typeof userErr === "function") return userErr.call(proxy, ev);
+      return undefined;
+    };
+    proxy = new Proxy(w, {
+      get: function (t, k) {
+        if (k === "onmessage") return userMsg || undefined;
+        if (k === "onerror") return userErr || undefined;
+        var v = t[k];
+        return typeof v === "function" ? v.bind(t) : v;
+      },
+      set: function (t, k, v) {
+        if (k === "onmessage") { userMsg = v; t.onmessage = onMsg; return true; }
+        if (k === "onerror") { userErr = v; t.onerror = onErr; return true; }
+        t[k] = v;
+        return true;
+      }
+    });
+    return proxy;
+  }
+  /** 安装（幂等、可在看门狗里重复调用）：只接管 name=dsh-file-upload 的 Worker。 */
+  function maInstallUploadTap() {
+    try {
+      if (typeof window === "undefined" || typeof window.Worker !== "function") return false;
+      var Native = window.Worker;
+      if (Native && Native.__dshMaUploadTap) return true;
+      var Wrapped = new Proxy(Native, {
+        construct: function (Target, args) {
+          var w = Reflect.construct(Target, args);
+          try {
+            var opts = args && args[1];
+            var name = opts && typeof opts === "object" ? String(opts.name || "") : "";
+            if (name !== "dsh-file-upload") return w;
+            return maTapUploadWorker(w);
+          } catch (eTap) { return w; }
+        }
+      });
+      try { Wrapped.__dshMaUploadTap = true; } catch (eMark) { /* 忽略 */ }
+      window.Worker = Wrapped;
+      return true;
+    } catch (e) { return false; }
+  }
+  /* ===DSH-MA-UPLOAD-HINT-ENGINE-END=== */
+
   try {
     const HOST_RE = new RegExp(${JSON.stringify(RUNTIME_HOST_RE.source)});
     const NARROW = () => window.innerWidth <= 820;
@@ -2787,6 +3237,8 @@ const SCRIPT = `(() => {
          旧实现把包装写在 buildRemoteMenu 内部的一次性分支里，那正是"请求明明在打、
          界面却永远测速中"的结构性原因。 */
       try { maInstallNetSampler(); } catch (eSampler0) { /* 忽略 */ }
+      /* 上传失败可读提示（2026-10-23）：与采样器同样"越早越好"，且幂等 —— 看门狗每拍调用无副作用。 */
+      try { maInstallUploadTap(); } catch (eUploadTap0) { /* 忽略 */ }
       /* 悬浮按钮/菜单：任何宽度都要有（电脑端访问镜像页时同样需要返回设备列表的出口）。
          失败也不影响手机端布局适配 —— 两条链路各自独立。 */
       if (!fabDone) { fabDone = true; try { buildRemoteMenu(); } catch (eFabDone) { /* 忽略 */ } }
@@ -3285,6 +3737,7 @@ const SCRIPT = `(() => {
          官方若在运行期替换 fetch 同理），下一拍就会把采样器重新挂回去 —— 幂等，已挂上时零开销。
          同时顺手重绘一次：官方 SPA 换掉菜单子树后，数字不必等下一次请求才回来。 */
       try { maInstallNetSampler(); } catch (eSampler) { /* 忽略 */ }
+      try { maInstallUploadTap(); } catch (eUploadTap) { /* 忽略 */ }
       try { if (maNetRender) maNetRender(); } catch (eNetRender) { /* 忽略 */ }
       try { ensureDrawerChrome(); } catch (eChrome2) { /* 忽略 */ }
       /* 镜像页就绪探测（mirror_load 的量测终点）：pump 本来就被 MutationObserver(子树) + 1s 兜底表