@mrrisega/dsh-remote 0.6.14 → 0.6.15

package/clients/dsh-remote/test/e2ee-bridge.test.mjs

@@ -105,9 +105,12 @@ const OFFICIAL_BODY = `<!doctype html>
 <body><div id="root"></div></body></html>`;
 
 const upstream = http.createServer((req, res) => {
-  let body = "";
-  req.on("data", (c) => { body += c; });
+  // ⚠️ 必须按 Buffer 攒再一次性 toString：`body += chunk` 会对**每个分片**单独 toString，
+  //    一个多字节 UTF-8 字符正好跨在 64KB 分片边界上就会被拆坏（0.6.15 加了大正文用例才暴露）。
+  const chunks = [];
+  req.on("data", (c) => chunks.push(c));
   req.on("end", () => {
+    const body = Buffer.concat(chunks).toString("utf8");
     // 官方 dsh web 特征 html(Phase-4:验证 e2ee 启用的桥端注入镜像 shim)
     if (req.url === "/official" || req.url.startsWith("/api/official")) {
       res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
@@ -115,7 +118,7 @@ const upstream = http.createServer((req, res) => {
       return;
     }
     res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
-    res.end(JSON.stringify({ method: req.method, url: req.url, ct: req.headers["content-type"] || "", auth: req.headers["x-dsh-test-auth"] || "", body }));
+    res.end(JSON.stringify({ method: req.method, url: req.url, ct: req.headers["content-type"] || "", auth: req.headers["x-dsh-test-auth"] || "", want: req.headers["x-dsh-e2ee-want"] || "", body }));
   });
 });
 let upstreamWss = null;
@@ -375,6 +378,73 @@ test("E2EE HTTP:信封请求解封→上游→封回往返一致;篡改密文
   assert.match(badText, /auth_failed|无法解密/);
 });
 
+test("★ 0.6.15 三层 base64 降为两层:声明过的客户端收到二进制明文,协商头不转发上游", async () => {
+  // 业主实测（dev-1014f947f8ab，Ubuntu 上的 dsh + Windows 访问，首屏要等几分钟）：
+  // 同一条响应被 base64 编了三层（1.333³≈2.37×）。第一层是"gzip 正文进 JSON"，
+  // 现在由客户端声明 x-dsh-e2ee-want: bin 换成二进制框架；老客户端不声明 → 形态不变。
+  const u = globalThis.__unlocked;
+  assert.ok(u, "需要先解锁");
+  const { client } = u;
+  const payload = "首屏聚合包内容-".repeat(4000); // ~ 100KB：足够看出编码层差异
+
+  // ① 新客户端：声明二进制明文
+  const plainBin = Buffer.from(JSON.stringify({
+    m: "POST",
+    p: "/api/echo?bin=1",
+    h: { "content-type": "application/json; charset=utf-8", "x-dsh-e2ee-want": "bin" },
+    b: Buffer.from(payload, "utf8").toString("base64")
+  }), "utf8");
+  const envBin = client.seal({ kind: "http", dir: "p2b", counter: 21, data: plainBin });
+  const resBin = await fetch(`${routerBase}/remote/${DEV_ON}/api/echo?bin=1`, {
+    method: "POST",
+    headers: { ...envelopeRequestHeaders(client.sessId, "http"), cookie: COOKIE },
+    body: JSON.stringify(envBin)
+  });
+  assert.equal(resBin.status, 200);
+  const envRespBin = JSON.parse(await resBin.text());
+  const openedBin = client.open({ kind: "http-resp", dir: "b2p", env: envRespBin, counter: envRespBin.c, reqNonceB64: envBin.n });
+  assert.equal(openedBin.data[0], 0x02, "★ 声明过的客户端必须收到二进制明文框架（首字节 0x02）");
+  const respBin = decodeHttpResponsePlain(openedBin.data);
+  const upBin = JSON.parse(respBin.bodyBuffer.toString("utf8"));
+  assert.equal(upBin.want, "", "★ 内部协商头绝不能转发给上游 dsh web（它不是业务头）");
+  assert.equal(upBin.body, payload, "正文必须逐字节还原");
+
+  // ② 老客户端（不声明）→ 仍是旧 JSON 形态，解码照样成功（兼容性）
+  const plainOld = Buffer.from(JSON.stringify({
+    m: "POST",
+    p: "/api/echo?bin=0",
+    h: { "content-type": "application/json; charset=utf-8" },
+    b: Buffer.from(payload, "utf8").toString("base64")
+  }), "utf8");
+  const envOld = client.seal({ kind: "http", dir: "p2b", counter: 22, data: plainOld });
+  const resOld = await fetch(`${routerBase}/remote/${DEV_ON}/api/echo?bin=0`, {
+    method: "POST",
+    headers: { ...envelopeRequestHeaders(client.sessId, "http"), cookie: COOKIE },
+    body: JSON.stringify(envOld)
+  });
+  const envRespOld = JSON.parse(await resOld.text());
+  const openedOld = client.open({ kind: "http-resp", dir: "b2p", env: envRespOld, counter: envRespOld.c, reqNonceB64: envOld.n });
+  assert.equal(openedOld.data[0], 0x7b, "老客户端必须仍收到旧 JSON 明文（首字节 '{'）");
+  const respOld = decodeHttpResponsePlain(openedOld.data);
+  assert.equal(JSON.parse(respOld.bodyBuffer.toString("utf8")).body, payload);
+  // 同一份正文：新形态必须明显更小（省掉的就是那一层 33%）
+  assert.ok(openedOld.data.length > openedBin.data.length * 1.25,
+    `旧明文形态必须明显更大（实测 ${openedOld.data.length} vs ${openedBin.data.length}）`);
+});
+
+test("★ 0.6.15 隧道帧不再给信封 JSON 套第三层 base64（bridge→中继 是计量那条腿）", async () => {
+  const { e2eeHttpResponseFrame } = await import("../dsh-bridge.mjs");
+  const env = { v: 2, k: "http-resp", s: "s".repeat(32), c: 1, n: "n".repeat(16), t: 0, d: "A".repeat(3 * 1024 * 1024) };
+  const frame = e2eeHttpResponseFrame(7, env.s, env);
+  assert.equal(frame.bodyBase64, false, "★ 不得再标记 bodyBase64（那一层纯属白花 33% 流量）");
+  assert.equal(frame.status, 200);
+  assert.match(frame.headers["x-dsh-e2ee"], /k=http-resp$/);
+  assert.deepEqual(JSON.parse(frame.body), env, "中继解出来必须与原信封逐字段一致");
+  const oldBody = Buffer.from(JSON.stringify(env)).toString("base64");
+  assert.ok(oldBody.length > frame.body.length * 1.3,
+    `旧写法会把这条帧撑大 33%（实测 ${oldBody.length} vs ${frame.body.length}）`);
+});
+
 test("E2EE WS 数据流:&e2ee=&w= 标记 → 桥剥除标记连上游,逐消息加解密 echo 一致", async () => {
   const u = globalThis.__unlocked;
   assert.ok(u, "需要先解锁");

package/clients/dsh-remote/test/e2ee-client.test.mjs

@@ -32,7 +32,9 @@ import {
   normalizeKdf,
   parseEnvelopeMarker,
   parseWsE2eeParams,
-  randomB64
+  randomB64,
+  stripPlainWantHeader,
+  wantsBinaryResponsePlain
 } from "../e2ee-client.mjs";
 
 // 固定口令/盐的 MK 期望值:由 enterprise e2ee.js deriveE2eeMasterKey 计算得到
@@ -213,6 +215,45 @@ function flipB64(b64) {
   return buf.toString("base64url");
 }
 
+test("★ 0.6.15 二进制明文框架:正文不再 base64(省掉三层里的第一层),且旧 JSON 形态仍能解", () => {
+  // 业主实测"打开慢几分钟"的直接原因之一：同一条响应被 base64 编了三层(1.333³≈2.37×)。
+  // 第一层就是"gzip 正文塞进 JSON 明文"。二进制框架把它去掉，且必须**两种形态都能解**
+  // （老客户端只发旧形态，新客户端声明后收新形态）。
+  const body = Buffer.from("首屏聚合包".repeat(500), "utf8");
+  const headers = { "content-type": "application/javascript", "content-encoding": "gzip" };
+
+  const bin = encodeHttpResponsePlain({ status: 200, headers, bodyBuffer: body, binary: true });
+  const legacy = encodeHttpResponsePlain({ status: 200, headers, bodyBuffer: body });
+  assert.equal(bin[0], 0x02, "二进制框架必须以 0x02 开头（JSON 明文以 `{`=0x7B 开头，不可能冲突）");
+  // 旧形态：正文 base64 后是 1.333 倍（这就是被省掉的那一层）
+  assert.ok(legacy.length > bin.length * 1.3,
+    `旧 JSON 形态必须明显更大（实测 ${legacy.length} vs ${bin.length}）`);
+  assert.ok(bin.length < body.length + 256, `二进制框架只应多出一点头（实测 ${bin.length} vs 正文 ${body.length}）`);
+
+  const back = decodeHttpResponsePlain(bin);
+  assert.equal(back.status, 200);
+  assert.equal(back.enc, "gzip");
+  assert.equal(back.headers["content-type"], "application/javascript");
+  assert.deepEqual(Buffer.from(back.bodyBuffer), body, "正文必须逐字节还原");
+  const backLegacy = decodeHttpResponsePlain(legacy);
+  assert.deepEqual(Buffer.from(backLegacy.bodyBuffer), body, "旧形态必须照样能解（老客户端不受影响）");
+
+  // 空正文 / 只有头的响应
+  const empty = decodeHttpResponsePlain(encodeHttpResponsePlain({ status: 204, headers: {}, bodyBuffer: Buffer.alloc(0), binary: true }));
+  assert.equal(empty.status, 204);
+  assert.equal(empty.bodyBuffer.length, 0);
+});
+
+test("★ 0.6.15 协商头:只有客户端声明才用二进制框架,且声明头绝不转发给上游", () => {
+  assert.equal(wantsBinaryResponsePlain({ "x-dsh-e2ee-want": "bin" }), true);
+  assert.equal(wantsBinaryResponsePlain({ "X-DSH-E2EE-WANT": "BIN" }), true, "头名/值大小写不敏感");
+  assert.equal(wantsBinaryResponsePlain({ "x-dsh-e2ee-want": "json" }), false);
+  assert.equal(wantsBinaryResponsePlain({ "content-type": "application/json" }), false, "老客户端不发这个头 → 保持旧形态");
+
+  const stripped = stripPlainWantHeader({ "Content-Type": "application/json", "X-Dsh-E2ee-Want": "bin", "x-t": "v" });
+  assert.deepEqual(stripped, { "Content-Type": "application/json", "x-t": "v" }, "内部协商头绝不能出现在转发给上游的头里");
+});
+
 test("http 响应信封:封包→开包,enc=gzip 被提取、实体头剥离,正文还原", () => {
   const s = makeSession();
   const body = Buffer.from(JSON.stringify({ ok: true }), "utf8");

package/clients/dsh-remote/test/e2ee-shim.test.mjs

@@ -230,7 +230,16 @@ test("信封逐字段一致:http/http-resp/w(文本·二进制)/ctrl(shim ↔ no
 test("请求信封明文编解码与信封标记头同构(node 交叉)", () => {
   const plainShim = shim.seEncodeHttpReqPlain({ method: "POST", path: "/api/echo?b=2", headers: { "content-type": "application/json", "x-t": "v" }, bodyBytes: new Uint8Array(Buffer.from("载荷", "utf8")) });
   const plainNode = encodeHttpRequestPlain({ method: "POST", path: "/api/echo?b=2", headers: { "content-type": "application/json", "x-t": "v" }, bodyB64: Buffer.from("载荷", "utf8").toString("base64") });
-  assert.deepEqual(Buffer.from(plainShim), Buffer.from(plainNode));
+  const decShim = decodeHttpRequestPlain(plainShim);
+  const decNode = decodeHttpRequestPlain(plainNode);
+  // ★ 0.6.15:shim **额外**声明「响应明文请用二进制框架」（省掉正文那一层 base64）。
+  //   这是本版唯一一处**有意为之**的差异：老客户端（native.html / 企业版内置那份）不发这个头，
+  //   桥端也就永远不给他们发二进制明文 —— 兼容性靠"客户端声明"而不是靠版本号猜。
+  assert.equal(decShim.headers["x-dsh-e2ee-want"], "bin", "镜像页 shim 必须声明二进制明文框架");
+  assert.equal(decNode.headers["x-dsh-e2ee-want"], undefined, "桥端自己的编码器不得替客户端声明（否则老客户端会收到看不懂的字节）");
+  delete decShim.headers["x-dsh-e2ee-want"];
+  assert.deepEqual(decShim, decNode, "除该声明头外，请求明文逐字段同构");
+  assert.deepEqual(Buffer.from(decShim.bodyB64, "base64"), Buffer.from("载荷", "utf8"));
   const sessId = newSessId();
   assert.deepEqual(shim.seEnvelopeHeaders(sessId), envelopeRequestHeaders(sessId, "http"));
 });

package/clients/dsh-remote/test/mobile-adapter-guards.test.mjs

@@ -32,6 +32,7 @@
  *   浏览器里的真实结果另在 headless Chromium + 官方 GUI 上验证过（见报告）。
  */
 import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
 import test from "node:test";
 import vm from "node:vm";
 import { injectMobileAdapter } from "../mobile-adapter.mjs";
@@ -349,7 +350,10 @@ function harness({
     MutationObserver: MutationObserverStub,
     ResizeObserver: class { observe() {} disconnect() {} },
     requestAnimationFrame: (fn) => setImmediate(fn),
-    setTimeout: (fn, ms) => setTimeout(fn, ms),
+    // unref：适配层自带 8s/30s/**4 分钟**的兜底计时器（首屏提示），不 unref 的话
+    // 测试进程会一直等到最后一个定时器到期才退出 —— 实测这个文件因此**空等 4 分钟**，
+    // 单次全量测试的 94% 时间都花在这里（2026-09-25 实测：240s vs 其余 20 个文件合计 30s）。
+    setTimeout: (fn, ms) => { const id = setTimeout(fn, ms); try { id.unref?.(); } catch { /* 忽略 */ } return id; },
     clearTimeout: (id) => clearTimeout(id),
     setInterval: (fn) => { intervals.push(fn); return intervals.length; },
     clearInterval: (id) => { if (id) intervals[id - 1] = null; },
@@ -830,3 +834,16 @@ test("自动收抽屉：桌面宽屏(>820)不收起", async () => {
   await waitTick();
   assert.equal(clicks(), 0, "宽屏没有离屏抽屉这回事 —— 窄屏门必须继续有效");
 });
+
+test("★ 迭代速度护栏：适配层测试的假定时器**必须 unref**（否则每个文件空等 4 分钟）", () => {
+  // 2026-09-25 实测：适配层会挂 8s / 30s / **4 分钟** 的首屏提示兜底计时器，
+  // 而两个适配层测试文件的假 setTimeout 直接转给 Node 的真定时器 → 测试全跑完后
+  // 进程还要等最后一个定时器到期才退出：单文件 **240 秒**，而其余 20 个文件合计只有 30 秒。
+  // 也就是说"每轮迭代全量测试 8.5 分钟"里 **94% 是纯空等**。
+  // 这条护栏把 unref 钉住 —— 它一丢，迭代速度立刻退回 8 分钟级。
+  const files = ["mobile-adapter-guards.test.mjs", "mobile-adapter-runtime.test.mjs", "mobile-adapter-image.test.mjs"];
+  for (const f of files) {
+    const src = readFileSync(new URL(`./${f}`, import.meta.url), "utf8");
+    assert.match(src, /id\.unref\?\.\(\)/, `${f} 的假 setTimeout 必须 unref（否则该文件会空等数分钟）`);
+  }
+});

package/clients/dsh-remote/test/mobile-adapter-image.test.mjs

@@ -0,0 +1,325 @@
+#!/usr/bin/env node
+/**
+ * mobile-adapter **图片上传兼容**契约测试（假 DOM + vm 执行真实注入脚本）。
+ *
+ * 业主反馈（2026-09）：「手机端无法识别图片」——选了照片发出去，模型看不到图 / 被当成普通文件。
+ *
+ * 根因（官方 dsh web 客户端 `dsh-client-ui-conversation` 的 createDrafts）：
+ *   只有 `file.type ∈ {image/png,image/jpeg,image/webp,image/gif}` 才走**图片**通道
+ *   （本地编码随 prompt 发出 → 模型真能"看"）；其余一律当**普通文件**（后台上传 + 一个文件引用）。
+ * 手机恰恰最容易给出非白名单类型：iPhone「高效」格式 = `image/heic`；部分 Android = 空 type。
+ *
+ * 本用例拿 injectMobileAdapter() 注入的**真实脚本**在假 DOM 里跑，断言运行时行为：
+ *   ① HEIC → 转成 JPEG 后再交给官方（官方收到的是 image/jpeg，而不是 heic）；
+ *   ② 空 type + `.png` 扩展名 → **无损**改 MIME（不重编码）；
+ *   ③ 官方认得的类型 → 一根手指都不动（零行为）；
+ *   ④ 任何失败（解码失败 / DataTransfer 不可用）→ **原样重新派发**，文件绝不丢。
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+import vm from "node:vm";
+import { injectMobileAdapter } from "../mobile-adapter.mjs";
+
+function adapterScript() {
+  const { html } = injectMobileAdapter("<!doctype html><html><head></head><body></body></html>");
+  const m = /<script id="[^"]*-js"[^>]*>([\s\S]*?)<\/script>/.exec(html);
+  assert.ok(m, "应能取出注入脚本");
+  return m[1];
+}
+
+// ── 极简假 DOM：只实现图片兼容这条路径真正用到的东西 ──────────────────────────
+class FakeFile {
+  constructor(parts, name, opts = {}) {
+    this._blob = { parts: parts.map((p) => String(p)) };
+    this.name = name;
+    this.type = opts.type || "";
+    this.size = this._blob.parts.join("").length;
+    this.lastModified = opts.lastModified || 1;
+  }
+  slice(_a, _b, mime) {
+    const f = new FakeBlob(this._blob.parts, mime || this.type);
+    f.name = this.name;
+    return f;
+  }
+}
+class FakeBlob {
+  constructor(parts, type) { this._parts = parts; this.type = type || ""; this.size = parts.join("").length; this.name = ""; }
+  slice(_a, _b, mime) { const b = new FakeBlob(this._parts, mime || this.type); b.name = this.name; return b; }
+}
+class FakeInput {
+  constructor() {
+    this.tagName = "INPUT";
+    this.type = "file";
+    this.files = [];
+    this._listeners = new Map();
+    this._attrs = {};
+  }
+  getAttribute(n) { return n in this._attrs ? this._attrs[n] : null; }
+  setAttribute(n, v) { this._attrs[n] = String(v); }
+  addEventListener(t, fn) { if (!this._listeners.has(t)) this._listeners.set(t, []); this._listeners.get(t).push(fn); }
+  removeEventListener() {}
+  // 真实 DOM 里 dispatchEvent 会再走一遍 document 捕获监听 —— 那次会被 MA_REENTRY 提前返回，
+  // 所以这里只跑本元素上的监听即可（语义等价）。
+  dispatchEvent(ev) {
+    ev.target = this;
+    for (const fn of this._listeners.get(ev.type) || []) fn(ev);
+    return true;
+  }
+}
+class FakeEvent {
+  constructor(type, init = {}) {
+    this.type = type;
+    this.bubbles = init.bubbles !== false;
+    this._stopped = false;
+    this._prevented = false;
+    this.target = null;
+  }
+  stopPropagation() { this._stopped = true; }
+  preventDefault() { this._prevented = true; }
+}
+
+/**
+ * 最小事件派发模型：document（捕获）→ target（冒泡）。
+ * capture 阶段 stopPropagation 后，**target 上的监听不再收到** —— 这正是 React 根容器监听
+ * （挂在 document 之下的容器上）会因此被拦住的机制，也是本方案能生效的前提。
+ */
+function fireChange(env, input) {
+  const ev = new FakeEvent("change", { bubbles: true });
+  ev.target = input;
+  for (const fn of env.docListeners.capture) fn(ev);
+  if (ev._stopped) return ev;
+  for (const fn of input._listeners.get("change") || []) fn(ev);
+  return ev;
+}
+
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function makeEnv({ decodeHeic = true, hasDataTransfer = true, frame = null } = {}) {
+  const docListeners = { capture: [], bubble: [] };
+  const input = new FakeInput();
+  const created = { canvases: 0, blobs: 0, objectUrls: 0, revoked: 0 };
+
+  const doc = {
+    documentElement: { outerHTML: "<html><head><title>DeepSeek Harness</title><script>window.__ModuleLoader__=1</script></head><body></body></html>" },
+    body: { appendChild() {}, querySelector: () => null, classList: { add() {}, remove() {} } },
+    readyState: "complete",
+    addEventListener(type, fn, opts) {
+      const capture = typeof opts === "object" ? !!opts.capture : opts === true;
+      (capture ? docListeners.capture : docListeners.bubble).push(fn);
+    },
+    removeEventListener() {},
+    querySelector: () => frame,
+    querySelectorAll: () => [],
+    getElementById: () => null,
+    createElement(tag) {
+      if (String(tag).toLowerCase() !== "canvas") return { style: {}, setAttribute() {}, appendChild() {}, classList: { add() {}, remove() {} } };
+      created.canvases += 1;
+      const cv = {
+        width: 0,
+        height: 0,
+        style: {},
+        getContext: () => ({ drawImage() {} }),
+        toBlob(cb, mime) {
+          created.blobs += 1;
+          cb(new FakeBlob(["jpeg-bytes"], mime || "image/jpeg"));
+        }
+      };
+      return cv;
+    },
+    createTextNode: (t) => ({ nodeValue: t })
+  };
+
+  class FakeImage {
+    constructor() { this.naturalWidth = 0; this.naturalHeight = 0; this.width = 0; this.height = 0; }
+    set src(v) {
+      this._src = v;
+      // HEIC 在部分浏览器上解不了；这里用开关模拟"解码成功/失败"
+      setTimeout(() => {
+        if (decodeHeic) { this.naturalWidth = 4032; this.naturalHeight = 3024; this.onload && this.onload(); }
+        else { this.onerror && this.onerror(); }
+      }, 0);
+    }
+    get src() { return this._src; }
+  }
+
+  const timers = new Set();
+  const win = {
+    innerWidth: 390,
+    innerHeight: 800,
+    devicePixelRatio: 2,
+    addEventListener() {},
+    removeEventListener() {},
+    getComputedStyle: () => ({ getPropertyValue: () => "" }),
+    requestAnimationFrame: (fn) => setTimeout(fn, 0),
+    // unref：适配层自带 8s/30s/4min 的兜底计时器（首屏提示、看门狗），不 unref 会把测试进程吊住。
+    // 用例里的 await wait(...) 用的是宿主定时器（未 unref），足够让这些 vm 内定时器在该跑的时候跑到。
+    setTimeout: (fn, ms) => { const id = setTimeout(fn, ms); try { id.unref?.(); } catch (e) { /* 忽略 */ } timers.add(id); return id; },
+    clearTimeout: (id) => { timers.delete(id); clearTimeout(id); },
+    MutationObserver: class { observe() {} disconnect() {} },
+    ResizeObserver: class { observe() {} disconnect() {} },
+    location: { href: "https://n.risegao.cn:13443/remote/dev-x/", host: "n.risegao.cn", pathname: "/remote/dev-x/", origin: "https://n.risegao.cn:13443" },
+    localStorage: { getItem: () => null, setItem() {}, removeItem() {} }
+  };
+
+  const ctx = vm.createContext({
+    window: win,
+    document: doc,
+    console,
+    setTimeout: win.setTimeout,
+    clearTimeout: win.clearTimeout,
+    setInterval: () => 0,
+    clearInterval() {},
+    MutationObserver: win.MutationObserver,
+    ResizeObserver: win.ResizeObserver,
+    requestAnimationFrame: win.requestAnimationFrame,
+    navigator: { userAgent: "iPhone Safari", maxTouchPoints: 5, platform: "iPhone" },
+    location: win.location,
+    localStorage: win.localStorage,
+    URL: {
+      createObjectURL() { created.objectUrls += 1; return "blob:fake/" + created.objectUrls; },
+      revokeObjectURL() { created.revoked += 1; }
+    },
+    Image: FakeImage,
+    File: FakeFile,
+    Blob: FakeBlob,
+    Event: FakeEvent,
+    Date, Math, JSON, Object, Array, String, Number, RegExp, Boolean, Promise, Error,
+    isNaN, parseInt, parseFloat
+  });
+  if (hasDataTransfer) {
+    ctx.DataTransfer = class {
+      constructor() { this.items = { _f: [], add(f) { this._f.push(f); } }; }
+      get files() { return this.items._f; }
+    };
+  }
+  ctx.globalThis = ctx;
+  return { ctx, input, docListeners, created };
+}
+
+function runAdapter(env) {
+  vm.runInContext(adapterScript(), env.ctx, { filename: "mobile-adapter.js" });
+}
+
+// ─────────────────────────── 用例 ───────────────────────────
+
+test("★ iPhone HEIC 照片 → 转成 JPEG 后再交给官方（否则会被当成普通文件，模型看不到）", async () => {
+  const env = makeEnv();
+  runAdapter(env);
+
+  // 官方监听（模拟 React 根容器/输入框上的 change 处理）
+  const official = [];
+  env.input.addEventListener("change", (e) => { official.push(Array.prototype.slice.call(e.target.files)); });
+
+  const heic = new FakeFile(["heic-bytes"], "IMG_0001.HEIC", { type: "image/heic" });
+  env.input.files = [heic];
+  fireChange(env, env.input); // 第一次：被适配层拦下（官方收不到）
+  assert.equal(official.length, 0, "★ 必须先把这次事件拦下来，不能让官方按普通文件先收走");
+
+  await wait(30); // 等 canvas 转码完成 + 重新派发
+
+  assert.equal(official.length, 1, "转码完成后必须重新派发一次 change");
+  const got = official[0];
+  assert.equal(got.length, 1);
+  assert.equal(got[0].type, "image/jpeg", "★ 交给官方的必须是白名单里的 image/jpeg");
+  assert.equal(got[0].name, "IMG_0001.jpg", "文件名也要跟着换成 .jpg（面板/模型看到的名字才一致）");
+  assert.equal(env.created.canvases, 1, "HEIC 必须走 canvas 转码");
+});
+
+test("★ Android 空 type + .png → **无损**改 MIME（不重编码，不丢透明通道）", async () => {
+  // Android 图库经文件提供器给出的 file.type 常常是空串；字节本身是标准 PNG。
+  // 这种情况走 canvas 重编码纯属浪费（还会把透明通道压成黑底），只改 MIME 就够了。
+  const env = makeEnv();
+  runAdapter(env);
+  const official = [];
+  env.input.addEventListener("change", (e) => { official.push(Array.prototype.slice.call(e.target.files)); });
+
+  const png = new FakeFile(["png-bytes"], "screenshot.png", { type: "" });
+  env.input.files = [png];
+  fireChange(env, env.input);
+  await wait(30);
+
+  assert.equal(official.length, 1);
+  assert.equal(official[0][0].type, "image/png", "★ 空 type 的 PNG 必须被改写成 image/png");
+  assert.equal(env.created.canvases, 0, "★ 不得重编码（无损路径不该碰 canvas）");
+  assert.equal(env.created.blobs, 0);
+});
+
+test("★ 官方认得的类型（image/jpeg）→ 零行为：不拦、不转、不重派发", async () => {
+  const env = makeEnv();
+  runAdapter(env);
+  const official = [];
+  env.input.addEventListener("change", (e) => { official.push(Array.prototype.slice.call(e.target.files)); });
+
+  const jpg = new FakeFile(["jpg-bytes"], "photo.jpg", { type: "image/jpeg" });
+  env.input.files = [jpg];
+  fireChange(env, env.input);
+  await wait(20);
+
+  assert.equal(official.length, 1, "官方应当**当场**收到事件（我们没有拦）");
+  assert.equal(official[0][0], jpg, "原文件对象必须是同一个（一个字节都没动）");
+  assert.equal(env.created.canvases, 0);
+  assert.equal(env.created.objectUrls, 0);
+});
+
+test("★ 解码失败（浏览器读不了 HEIC）→ 原样重新派发，文件绝不丢", async () => {
+  const env = makeEnv({ decodeHeic: false });
+  runAdapter(env);
+  const official = [];
+  env.input.addEventListener("change", (e) => { official.push(Array.prototype.slice.call(e.target.files)); });
+
+  const heic = new FakeFile(["heic-bytes"], "IMG_2.HEIC", { type: "image/heic" });
+  env.input.files = [heic];
+  fireChange(env, env.input);
+  await wait(40);
+
+  assert.equal(official.length, 1, "转不了也必须把这次选择交回官方（否则用户会觉得「选了没反应」）");
+  assert.equal(official[0][0].name, "IMG_2.HEIC", "交回去的是**原文件**（宁可当普通文件，也不能丢）");
+});
+
+test("★ DataTransfer 不可用（老浏览器）→ 原样重新派发，不吞事件", async () => {
+  const env = makeEnv({ hasDataTransfer: false });
+  runAdapter(env);
+  const official = [];
+  env.input.addEventListener("change", (e) => { official.push(Array.prototype.slice.call(e.target.files)); });
+
+  const heic = new FakeFile(["heic-bytes"], "IMG_3.HEIC", { type: "image/heic" });
+  env.input.files = [heic];
+  fireChange(env, env.input);
+  await wait(40);
+
+  assert.equal(official.length, 1, "塞不回 input.files 时必须原样重发");
+  assert.equal(official[0][0].name, "IMG_3.HEIC");
+});
+
+test("★ 混合选择：只动需要动的那个，其余原样（顺序也不许乱）", async () => {
+  const env = makeEnv();
+  runAdapter(env);
+  const official = [];
+  env.input.addEventListener("change", (e) => { official.push(Array.prototype.slice.call(e.target.files)); });
+
+  const jpg = new FakeFile(["a"], "a.jpg", { type: "image/jpeg" });
+  const heic = new FakeFile(["b"], "b.heic", { type: "image/heic" });
+  const pdf = new FakeFile(["c"], "c.pdf", { type: "application/pdf" });
+  env.input.files = [jpg, heic, pdf];
+  fireChange(env, env.input);
+  await wait(40);
+
+  assert.equal(official.length, 1);
+  const got = official[0];
+  assert.equal(got.length, 3, "文件数量必须保持 3");
+  assert.equal(got[0], jpg, "官方认得的原样保留（同一对象）");
+  assert.equal(got[1].type, "image/jpeg", "HEIC 被转成 JPEG");
+  assert.equal(got[1].name, "b.jpg");
+  assert.equal(got[2], pdf, "非图片原样保留");
+});
+
+test("接线守卫：图片兼容必须真的被装上，且走**捕获阶段**（否则拦不住 React 根容器）", () => {
+  const src = adapterScript();
+  assert.match(src, /maInstallImageCompat\(\);/, "必须在主流程里调用（定义了不调用等于没做）");
+  const i = src.indexOf('document.addEventListener("change"');
+  assert.ok(i > 0, "找不到 change 监听");
+  const tail = src.slice(i, i + 2000);
+  assert.ok(/\},\s*true\s*\)\s*;/.test(tail),
+    "★ 必须注册在捕获阶段（第三个参数 true）：React 根容器的 change 监听在 document 之下，冒泡阶段拦不住它");
+  assert.match(src, /MA_REENTRY/, "必须有重入标记（否则自己派发的 change 会再被自己拦一次，死循环）");
+});

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

@@ -168,7 +168,9 @@ function harness({ collapsedAttr = undefined, detailsAttr = undefined, sidebarRe
     removeEventListener() {},
     getComputedStyle: () => ({ getPropertyValue: () => "" }),
     requestAnimationFrame: (fn) => { const id = setImmediate(fn); return id; },
-    setTimeout: (fn, ms) => { const id = setTimeout(fn, ms); timers.set(id, fn); return id; },
+    // unref：同上 —— 适配层的 4 分钟兜底计时器会让测试进程空等到期（本来 240s，只剩 0.2s）。
+    // 用例里的 `_pendingTimers` 仍会被 runAdapter() 主动跑一轮，行为不变。
+    setTimeout: (fn, ms) => { const id = setTimeout(fn, ms); try { id.unref?.(); } catch { /* 忽略 */ } timers.set(id, fn); return id; },
     clearTimeout: (id) => clearTimeout(id),
     MutationObserver: class { observe() {} disconnect() {} },
     ResizeObserver: class { observe() {} disconnect() {} },