@mrrisega/dsh-remote 0.7.5-beta.1 → 0.7.5

package/packages/dsh-remote-web/runtime/clients/dsh-remote/e2ee-client.mjs

@@ -644,6 +644,11 @@ export class E2eeService {
     this.sessions = new Map(); // sessId → E2eeSession
     this.ctrlCounters = new Map(); // sessId → { p2b: SequenceGuard, b2p: SequenceGuard }
     this.httpNonces = new HttpNonceGuard();
+    // ── 会话持久化(可选,见文件末尾「会话持久化」段)──
+    this.storeDir = "";
+    this.storeTimer = null;
+    this.storeErrorLogged = false;
+    this.lastStoreReason = "";
   }
 
   /** 静态工厂:启动派生(失败即禁用并说明原因;绝不抛)。 */
@@ -718,6 +723,130 @@ export class E2eeService {
     return s || null;
   }
 
+  /* ── 会话持久化(2026-10-23)────────────────────────────────────────────────────
+   *
+   * 【为什么】生产日志：bridge 重启/崩溃后，手机端保存的 sessId 在内存表里找不到 →
+   *   每个请求 502 `unknown_session`、每条数据 WS 被 1008 `e2ee_session_locked` 拒，
+   *   用户被迫回设备列表重新解锁（实测某设备 3964 次）。
+   * 【怎么存】只存**不可推导的会话材料**（SHK / saltH / 验证标志 / 时间戳 / ctrl 计数器），
+   *   用 MK 派生出的 storeKey 做 AES-256-GCM 加密后落盘到 relay 数据目录
+   *   `.e2ee-sessions.enc`（0600，原子写）。文件里没有 MK、没有密码、没有 storeKey ——
+   *   拿到文件也解不开（同一份文件在不同账号/改密后的 MK 下 GCM 认证必失败）。
+   * 【失效纪律】解不开 / 版本不符 / salt 变了 → 丢弃文件 + 清空内存会话，并让上层给手机
+   *   回 `retryable:true, action:"rehandshake"` 的信号（自动重握手，而不是反复撞死票）。
+   *   HTTP 的防重放 nonce 窗口**不**持久化：它只有 5 分钟，重启丢窗的代价是"同一请求可能
+   *   在这 5 分钟内被重放一次"，而重放的前提是攻击者已经拿到那条完整密文请求 —— 与把
+   *   整份会话密钥落盘相比不改变信任边界（见 docs/e2ee-protocol.md §9.1）。
+   */
+  attachStore(dir, { enabled = true, flushMs = 60_000 } = {}) {
+    if (!enabled) return { restored: 0, discarded: "", skipped: "disabled" };
+    if (!this.enabled) return { restored: 0, discarded: "", skipped: "e2ee_disabled" };
+    if (!dir) return { restored: 0, discarded: "", skipped: "no_dir" };
+    this.storeDir = String(dir);
+    const r = this.restoreFromStore();
+    if (flushMs > 0) {
+      try {
+        this.storeTimer = setInterval(() => this.flushStore(), flushMs);
+        this.storeTimer.unref?.();
+      } catch { /* 定时器不可用 → 只有退出时 flush(不致命) */ }
+    }
+    return r;
+  }
+
+  /** 退出/测试用:停掉周期落盘。 */
+  disposeStore() {
+    if (this.storeTimer) { try { clearInterval(this.storeTimer); } catch { /* 忽略 */ } }
+    this.storeTimer = null;
+  }
+
+  /** 从磁盘恢复会话(同步、绝不抛)。返回 { restored, discarded, skipped? }。 */
+  restoreFromStore() {
+    if (!this.storeDir || !this.enabled) return { restored: 0, discarded: "" };
+    const loaded = loadSessionStore(this.storeDir, this.mk);
+    if (!loaded.ok) {
+      if (loaded.reason === "absent") return { restored: 0, discarded: "" };
+      // 解不开/损坏:删掉它，别让下一位继续撞。原因留给上层打日志 + 给手机 rehandshake 信号。
+      clearSessionStore(this.storeDir);
+      this.lastStoreReason = loaded.reason;
+      return { restored: 0, discarded: loaded.reason };
+    }
+    const payload = loaded.payload || {};
+    if (Number(payload.v) !== SESSION_STORE_VERSION || String(payload.salt || "") !== String(this.salt || "")) {
+      clearSessionStore(this.storeDir);
+      this.lastStoreReason = "params_changed";
+      return { restored: 0, discarded: "params_changed" };
+    }
+    const now = Date.now();
+    this.sessions.clear();
+    this.ctrlCounters.clear();
+    for (const row of Array.isArray(payload.sessions) ? payload.sessions : []) {
+      try {
+        const sessId = String(row && row.s || "");
+        if (!SESS_ID_RE.test(sessId)) continue;
+        const usedAt = Number(row.usedAt) || 0;
+        if (!usedAt || now - usedAt > SESSION_TTL_MS) continue; // 过期(sliding TTL)
+        const session = new E2eeSession({
+          sessId,
+          shk: Buffer.from(String(row.shk || ""), "base64url"),
+          saltH: Buffer.from(String(row.saltH || ""), "base64url"),
+          profile: String(row.profile || this.profile),
+          epoch: Number(row.epoch) || 0
+        });
+        session.verified = row.verified === true;
+        session.createdAt = Number(row.createdAt) || usedAt;
+        session.usedAt = usedAt;
+        this.sessions.set(sessId, session);
+        const guards = { p2b: new SequenceGuard(), b2p: new SequenceGuard() };
+        if (Number.isInteger(row.p2b)) guards.p2b.last = row.p2b;
+        if (Number.isInteger(row.b2p)) guards.b2p.last = row.b2p;
+        this.ctrlCounters.set(sessId, guards);
+      } catch { /* 单条坏 → 跳过,不影响其它会话 */ }
+    }
+    this.prune();
+    return { restored: this.sessions.size, discarded: "" };
+  }
+
+  /**
+   * 落盘一次(同步、绝不抛)。force=false 时只在 storeDir 存在时写。
+   * 写失败只记一次日志:会话库不是主链路,不能因为它把隧道拖挂。
+   */
+  flushStore() {
+    if (!this.storeDir || !this.enabled) return { ok: false, skipped: true };
+    try {
+      const payload = {
+        v: SESSION_STORE_VERSION,
+        profile: this.profile,
+        epoch: this.epoch,
+        salt: this.salt,
+        at: Date.now(),
+        sessions: [...this.sessions.values()].map((s) => ({
+          s: s.sessId,
+          shk: s.shk.toString("base64url"),
+          saltH: s.saltH.toString("base64url"),
+          profile: s.profile,
+          epoch: s.epoch,
+          verified: s.verified === true,
+          createdAt: s.createdAt,
+          usedAt: s.usedAt,
+          p2b: this.ctrlCounters.get(s.sessId)?.p2b?.last ?? -1,
+          b2p: this.ctrlCounters.get(s.sessId)?.b2p?.last ?? -1
+        }))
+      };
+      return saveSessionStore(this.storeDir, this.mk, payload);
+    } catch (e) {
+      if (!this.storeErrorLogged) {
+        this.storeErrorLogged = true;
+        console.warn(`[e2ee] 会话库落盘失败(不影响隧道,仅本次重启需重新解锁): ${e?.code || e?.message || e}`);
+      }
+      return { ok: false, error: String(e?.code || e?.message || e) };
+    }
+  }
+
+  /** 新会话建立/验证通过后立即落盘(解锁不常有,同步写 2KB 可接受;崩溃也不丢新会话)。 */
+  persistSoon() {
+    try { this.flushStore(); } catch { /* 已内部兜底 */ }
+  }
+
   /**
    * 桥端应答 e2ee-hello(§5.2 步骤 1→2)。
    * @returns {{session:E2eeSession, ack:object}} 或抛 E2eeError
@@ -747,6 +876,7 @@ export class E2eeService {
     const session = new E2eeSession({ sessId, shk, saltH, profile: this.profile, epoch: this.epoch });
     this.sessions.set(sessId, session);
     this.ctrlCounters.set(sessId, { p2b: new SequenceGuard(), b2p: new SequenceGuard() });
+    this.persistSoon(); // 新会话立刻落盘:紧接着的 bridge 崩溃不该让手机重新解锁
     const ack = {
       v: E2EE_VERSION,
       type: CTRL_HELLO_ACK,
@@ -784,6 +914,7 @@ export class E2eeService {
       data: JSON.stringify({ p: "dsh-e2ee-probe-ok", t: pt.t ?? 0, c: 0 })
     });
     this.ctrlCounters.set(sessId, guards);
+    this.persistSoon(); // verified 也落盘:重启后数据 WS 直接可用,不必再探测
     return { reply, session };
   }
 
@@ -797,6 +928,126 @@ export class E2eeService {
   }
 }
 
+// ============================================================
+// 会话持久化原语(2026-10-23;方案/信任边界见 E2eeService.attachStore 上方长注释)
+// ============================================================
+
+export const SESSION_STORE_VERSION = 1;
+export const SESSION_STORE_FILE = ".e2ee-sessions.enc";
+/** 会话库 AAD(域分隔;换格式/换用途必须改它,旧文件自动解不开 → 丢弃重握手)。 */
+export const SESSION_STORE_AAD = Buffer.from(`${E2EE_DOMAIN}\x00sessions-store-v1`, "utf8");
+
+/** 会话库路径(与 .e2ee-state.json 同级,relay 数据目录)。 */
+export function sessionStorePath(dir) {
+  return `${String(dir || "").replace(/[\\/]+$/, "")}/${SESSION_STORE_FILE}`;
+}
+
+/**
+ * 由 MK 派生会话库密钥:
+ *   storeKey = HKDF-SHA256(ikm=MK, salt=sha256("dsh-e2ee/v1\0sessions-store-salt"),
+ *                          info="dsh-e2ee/v1\0sessions-store", 32)
+ * 与 SHK/子密钥域完全隔离;storeKey 只驻内存,绝不写文件、不写日志。
+ */
+export function deriveSessionStoreKey(mk) {
+  if (!Buffer.isBuffer(mk) || mk.length !== MK_BYTES) throw new E2eeError("bad_mk", "e2ee: 会话库 MK 非法");
+  const salt = sha256(Buffer.from(`${E2EE_DOMAIN}\x00sessions-store-salt`, "utf8"));
+  return Buffer.from(hkdfSync("sha256", mk, salt, Buffer.from(`${E2EE_DOMAIN}\x00sessions-store`, "utf8"), MK_BYTES));
+}
+
+/** 加密会话库 → 可直接 JSON.stringify 的对象(明文永不落盘)。 */
+export function encryptSessionStore(mk, payload) {
+  const key = deriveSessionStoreKey(mk);
+  const iv = randomBytes(NONCE_BYTES);
+  const plaintext = Buffer.from(JSON.stringify(payload), "utf8");
+  const c = createCipheriv("aes-256-gcm", key, iv);
+  c.setAAD(SESSION_STORE_AAD);
+  const ct = Buffer.concat([c.update(plaintext), c.final()]);
+  return {
+    v: SESSION_STORE_VERSION,
+    alg: "aes-256-gcm",
+    iv: iv.toString("base64url"),
+    tag: c.getAuthTag().toString("base64url"),
+    ct: ct.toString("base64url")
+  };
+}
+
+/** 解密会话库;任何异常都抛 E2eeError(调用方据此丢弃文件)。 */
+export function decryptSessionStore(mk, blob) {
+  if (!blob || typeof blob !== "object") throw new E2eeError("bad_store", "e2ee: 会话库格式非法");
+  if (Number(blob.v) !== SESSION_STORE_VERSION) throw new E2eeError("bad_store", `e2ee: 会话库版本 ${blob.v} 不受支持`);
+  if (String(blob.alg || "") !== "aes-256-gcm") throw new E2eeError("bad_store", "e2ee: 会话库算法不受支持");
+  const key = deriveSessionStoreKey(mk);
+  const iv = Buffer.from(String(blob.iv || ""), "base64url");
+  const tag = Buffer.from(String(blob.tag || ""), "base64url");
+  const ct = Buffer.from(String(blob.ct || ""), "base64url");
+  if (iv.length !== NONCE_BYTES || tag.length !== TAG_BYTES) throw new E2eeError("bad_store", "e2ee: 会话库 nonce/tag 非法");
+  const d = createDecipheriv("aes-256-gcm", key, iv);
+  d.setAAD(SESSION_STORE_AAD);
+  d.setAuthTag(tag);
+  let plaintext;
+  try {
+    plaintext = Buffer.concat([d.update(ct), d.final()]); // 认证失败(MK 变了/被篡改)在这里抛
+  } catch {
+    throw new E2eeError("store_auth_failed", "e2ee: 会话库无法解密(MK 已变或文件损坏)");
+  }
+  try {
+    return JSON.parse(plaintext.toString("utf8"));
+  } catch {
+    throw new E2eeError("bad_store", "e2ee: 会话库明文不是 JSON");
+  }
+}
+
+/** 原子写会话库(mkdir + tmp 文件 + rename;0600)。失败抛(上层兜)。 */
+export function saveSessionStore(dir, mk, payload) {
+  if (!dir) throw new E2eeError("no_store_dir", "e2ee: 会话库目录未设置");
+  const file = sessionStorePath(dir);
+  const body = JSON.stringify(encryptSessionStore(mk, payload));
+  const tmp = `${file}.tmp-${process.pid}`;
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(tmp, body, { mode: 0o600 });
+  try { fs.chmodSync(tmp, 0o600); } catch { /* Windows 上可能不支持 */ }
+  fs.renameSync(tmp, file); // rename 原子:不会读到半截文件
+  return { ok: true, bytes: body.length, file };
+}
+
+/** 读会话库。返回 { ok, reason: absent|unreadable|corrupt|key_mismatch, payload }(绝不抛)。 */
+export function loadSessionStore(dir, mk) {
+  const file = sessionStorePath(dir);
+  let raw;
+  try {
+    raw = fs.readFileSync(file, "utf8");
+  } catch (e) {
+    return { ok: false, reason: e?.code === "ENOENT" ? "absent" : "unreadable", payload: null, file };
+  }
+  let blob;
+  try {
+    blob = JSON.parse(raw);
+  } catch {
+    return { ok: false, reason: "corrupt", payload: null, file };
+  }
+  try {
+    return { ok: true, reason: "", payload: decryptSessionStore(mk, blob), file };
+  } catch (e) {
+    return {
+      ok: false,
+      reason: e?.code === "store_auth_failed" ? "key_mismatch" : "corrupt",
+      payload: null,
+      file
+    };
+  }
+}
+
+/** 删除会话库(丢弃死会话时用;返回是否真的删掉)。 */
+export function clearSessionStore(dir) {
+  if (!dir) return false;
+  try {
+    fs.rmSync(sessionStorePath(dir), { force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /** 把 E2EE 开关状态写入 relayDir/.e2ee-state.json(供 Phase-4 面板 UI 读取)。 */
 export function writeE2eeStateFile(dir, state) {
   try {

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

@@ -3973,6 +3973,267 @@ const SCRIPT = `(() => {
         } catch (ePs) { /* 忽略 */ }
       });
     } catch (ePs2) { /* 忽略 */ }
+  /* ===DSH-MA-SINGLEPAGE-START===
+     同一设备只允许一个镜像页（2026-10-23，生产现场：手机端会出现同一 deviceId 的两个镜像页
+     并发，互相取消资源加载 → 两边都一直转圈）。
+
+     做法（同步优先，绝不拖慢首个页面）：
+       1. 只对 /remote/<deviceId>/ 形态的镜像页生效；设备列表/登录页不参与。
+       2. **同步租约**：localStorage 里一条 {id, at}，本页心跳每 2s 刷新。读到"别人的租约且新鲜
+          （<6s）"→ 立刻进 blocked 态（不依赖任何异步 API 就能把第二页按住）。
+       3. 再叠加 BroadcastChannel：新页 claim / takeover / release 实时互通，
+          老页收到 claim/takeover 立刻让路（显示"已切到另一窗口"）。
+       4. 有 Web Locks 时再拿一把同名锁兜底（双开竞态的最后仲裁者）。
+       5. blocked 态 = window.stop() + 拦掉 fetch/XHR send/WebSocket + 全屏提示（带"在本窗口继续"
+          按钮，点了通知旧页让路 → 本页重载接管）。同时每 2s 复查租约：旧页关掉/失联后自动恢复。
+       6. 老浏览器（没有 localStorage/BroadcastChannel，如部分隐私模式）→ 直接不启用，
+          保持既有行为（宁可不管，也绝不能把唯一页面锁死）。
+
+     注入体纪律：本段不得出现反引号，只用 ES5 语法。 */
+  function maSinglePageGuard() {
+    try {
+      var LS_KEY_PREFIX = "dsh-remote-mirror-page:";
+      var BC_PREFIX = "dsh-remote-mirror-page-bc:";
+      var LEASE_TTL_MS = 6000;
+      var BEAT_MS = 2000;
+      var LOCK_PREFIX = "dsh-remote-mirror-lock:";
+      var OVERLAY_ID = "dsh-ma-singlepage";
+      var BTN_ID = "dsh-ma-singlepage-takeover";
+
+      var loc = (typeof location !== "undefined" && location) ? location : (window.location || null);
+      if (!loc) return;
+      // 只认 /remote/<deviceId>/ 形态（用 split 解析：注入体是模板字符串，正则里的 \/ 会被吃掉）
+      var seg = String(loc.pathname || "").split("/").filter(Boolean);
+      if (seg[0] !== "remote" || !seg[1]) return;
+      var dev = "";
+      try { dev = decodeURIComponent(seg[1]); } catch (eDec) { dev = ""; }
+      if (!dev || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(dev)) return;
+      var key = LS_KEY_PREFIX + dev;
+      var takeoverKey = key + ":takeover";
+      var self = "p" + Date.now().toString(36) + Math.random().toString(36).slice(2, 10);
+
+      var ls = null;
+      try { ls = window.localStorage || null; } catch (e0) { ls = null; }
+      var bc = null;
+      try {
+        if (typeof window.BroadcastChannel === "function") bc = new window.BroadcastChannel(BC_PREFIX + dev);
+      } catch (e1) { bc = null; }
+      if (!ls || !bc) return; // 老浏览器/隐私模式:不改变既有行为(不锁)
+
+      var state = "checking";
+      var beatTimer = 0;
+      var pollTimer = 0;
+      var claimedAt = 0;
+
+      function publish(s) {
+        state = s;
+        try {
+          window.__dshSinglePage = { state: s, device: dev };
+        } catch (eP) { /* 忽略 */ }
+      }
+
+      function readLease() {
+        try {
+          var raw = ls.getItem(key);
+          if (!raw) return null;
+          var v = JSON.parse(raw);
+          if (!v || typeof v.id !== "string") return null;
+          return { id: v.id, at: Number(v.at) || 0 };
+        } catch (eR) { return null; }
+      }
+      function writeLease() {
+        try { ls.setItem(key, JSON.stringify({ id: self, at: Date.now() })); } catch (eW) { /* 忽略 */ }
+      }
+      function releaseLease() {
+        try {
+          var cur = readLease();
+          if (cur && cur.id === self) ls.removeItem(key);
+        } catch (eL) { /* 忽略 */ }
+      }
+      function readTakeover() {
+        try { return Number(ls.getItem(takeoverKey)) || 0; } catch (eT) { return 0; }
+      }
+      function markTakeover() {
+        try { ls.setItem(takeoverKey, String(Date.now())); } catch (eM) { /* 忽略 */ }
+      }
+
+      function post(msg) {
+        try { bc.postMessage(msg); } catch (ePo) { /* 忽略 */ }
+      }
+
+      function reload() {
+        try {
+          if (typeof loc.reload === "function") { loc.reload(); return; }
+          loc.href = loc.href;
+        } catch (eRel) { /* 忽略 */ }
+      }
+
+      /* ---- 第二页：即刻停掉加载 + 全屏提示（唯一出口是「在本窗口继续」或回原窗口）---- */
+      function installNetworkStop() {
+        try { if (typeof window.stop === "function") window.stop(); } catch (eS) { /* 忽略 */ }
+        try {
+          if (typeof window.fetch === "function") {
+            window.fetch = function () {
+              return Promise.reject(new Error("dsh-single-page: 同一设备的镜像页已在另一个窗口打开，本页已停用"));
+            };
+          }
+        } catch (eF) { /* 忽略 */ }
+        try {
+          var proto = window.XMLHttpRequest && window.XMLHttpRequest.prototype;
+          if (proto && typeof proto.send === "function") {
+            proto.send = function () { try { this.abort(); } catch (eX) { /* 忽略 */ } };
+          }
+        } catch (eXhr) { /* 忽略 */ }
+        try {
+          if (typeof window.WebSocket === "function") {
+            var WsBlocked = function () {
+              throw new Error("dsh-single-page: 同一设备的镜像页已在另一个窗口打开，本页已停用");
+            };
+            WsBlocked.prototype = window.WebSocket.prototype;
+            window.WebSocket = WsBlocked;
+          }
+        } catch (eWs) { /* 忽略 */ }
+      }
+
+      function buildOverlay() {
+        try {
+          if (!document || !document.body) return;
+          if (document.getElementById && document.getElementById(OVERLAY_ID)) return;
+          var wrap = document.createElement("div");
+          wrap.id = OVERLAY_ID;
+          wrap.setAttribute("data-dsh-single-page", "blocked");
+          wrap.style.cssText = "position:fixed;left:0;top:0;right:0;bottom:0;z-index:2147483001;"
+            + "background:#0f1115;color:#e8eaed;display:flex;align-items:center;justify-content:center;"
+            + "padding:24px;box-sizing:border-box;font-family:-apple-system,BlinkMacSystemFont,Segoe UI,sans-serif;";
+          wrap.innerHTML = '<div style="max-width:420px;text-align:center;line-height:1.7">'
+            + '<div style="font-size:18px;font-weight:600;margin-bottom:10px">该设备已在本浏览器另一个窗口打开</div>'
+            + '<div style="font-size:14px;color:#9aa0a6;margin-bottom:18px">两个镜像页同时加载会互相取消资源加载，'
+            + '导致两边都卡住。请回到原来那个窗口继续使用。</div>'
+            + '<button id="' + BTN_ID + '" style="border:0;border-radius:10px;padding:12px 18px;'
+            + 'font-size:15px;background:#3b82f6;color:#fff;width:100%">在本窗口继续（切换到本页）</button>'
+            + '</div>';
+          document.body.appendChild(wrap);
+          var btn = document.getElementById ? document.getElementById(BTN_ID) : null;
+          if (btn && typeof btn.addEventListener === "function") btn.addEventListener("click", takeover, false);
+        } catch (eOv) { /* 提示失败也不影响"已停用"这个事实 */ }
+      }
+
+      function showOverlay() {
+        try {
+          if (document && document.body) buildOverlay();
+          else if (document && typeof document.addEventListener === "function") {
+            document.addEventListener("DOMContentLoaded", buildOverlay, false);
+          }
+        } catch (eShow) { /* 忽略 */ }
+      }
+
+      function becomeBlocked(why) {
+        if (state === "blocked") return;
+        publish("blocked");
+        try { if (beatTimer) { clearInterval(beatTimer); beatTimer = 0; } } catch (eB) { /* 忽略 */ }
+        releaseLease();
+        installNetworkStop();
+        showOverlay();
+        try {
+          if (!pollTimer) {
+            pollTimer = setInterval(function () {
+              var l = readLease();
+              var now = Date.now();
+              if (l && l.id !== self && now - l.at < LEASE_TTL_MS) return; // 人家还活着
+              // 原来的窗口关了/失联:允许自己接管(先打 takeover 标记,避免重载后又被自己挡住)
+              try { if (pollTimer) { clearInterval(pollTimer); pollTimer = 0; } } catch (eC) { /* 忽略 */ }
+              markTakeover();
+              reload();
+            }, 2000);
+          }
+        } catch (ePoll) { /* 忽略 */ }
+        if (window.console && console.info) console.info("[dsh-mobile-adapter] 单镜像页:第二页已停用(" + why + ")");
+      }
+
+      function takeover() {
+        post({ k: "takeover", id: self, at: Date.now() });
+        markTakeover();
+        // 给旧页 400ms 收消息、释放租约、让出资源，然后本页重载（重载后按 takeover 标记直接接管）
+        setTimeout(reload, 400);
+      }
+
+      function beat() {
+        writeLease();
+      }
+
+      function becomeActive() {
+        publish("active");
+        claimedAt = Date.now();
+        // takeover 标记只用于「重载后允许接管一次」：拿到租约后立刻消费掉，
+        // 否则它在 15s 有效期内会让第三个页面也以为自己可以接管（并发又回来了）。
+        try { ls.removeItem(takeoverKey); } catch (eCl) { /* 忽略 */ }
+        writeLease();
+        try {
+          if (!beatTimer) beatTimer = setInterval(beat, BEAT_MS);
+        } catch (eBt) { /* 忽略 */ }
+        post({ k: "claim", id: self, at: claimedAt });
+        // Web Locks 兜底（可用时）：并发双开时只有拿到锁的那个页面继续
+        try {
+          var nav = window.navigator;
+          if (nav && nav.locks && typeof nav.locks.request === "function") {
+            nav.locks.request(LOCK_PREFIX + dev, { ifAvailable: true }, function (lock) {
+              if (!lock) { becomeBlocked("web_locks_busy"); return undefined; }
+              return new Promise(function () { /* 持有到页面结束 */ });
+            }).catch(function () { /* 不支持 ifAvailable/被拒 → 租约已足够 */ });
+          }
+        } catch (eLocks) { /* 忽略 */ }
+        // 让路：另一页 claim（它后发/并发）或要求接管
+        try {
+          bc.onmessage = function (ev) {
+            var msg = ev && ev.data;
+            if (!msg || typeof msg !== "object") return;
+            if (msg.id === self) return;
+            if (msg.k === "takeover") {
+              becomeBlocked("takeover");
+              return;
+            }
+            if (msg.k === "claim" && Number(msg.at) >= claimedAt) {
+              // 同一时刻两个页面都认为自己是活跃页（同步租约竞态）→ 按 id 字典序让一个走
+              if (Number(msg.at) === claimedAt && String(msg.id) < String(self)) return;
+              becomeBlocked("other_claim");
+            }
+          };
+        } catch (eMsg) { /* 忽略 */ }
+        try {
+          window.addEventListener("pagehide", function () {
+            if (state !== "active") return;
+            // 进 bfcache / 切走：让出租约，别让另一个页面（或用户重开）被一张"僵尸租约"挡住
+            releaseLease();
+            post({ k: "release", id: self, at: Date.now() });
+            if (beatTimer) { try { clearInterval(beatTimer); } catch (eBt2) { /* 忽略 */ } beatTimer = 0; }
+            try { bc.onmessage = null; } catch (eBc2) { /* 忽略 */ } // 卸载旧监听，避免和 pageshow 后的新实例抢状态
+            publish("inactive");
+          });
+          // bfcache 回来：可能已经过了很久、也可能别的页面已经接管 → 重新判一次（幂等）
+          window.addEventListener("pageshow", function (ev) {
+            if (!ev || !ev.persisted) return;
+            if (state === "active") return;
+            try { maSinglePageGuard(); } catch (ePs) { /* 忽略 */ }
+          });
+        } catch (ePh) { /* 忽略 */ }
+      }
+
+      /* ---- 启动：同步租约判定（关键：不 await，第二页在网络请求发出前就被按住）---- */
+      var now = Date.now();
+      var lease = readLease();
+      var tko = readTakeover();
+      var takeoverFresh = tko > 0 && now - tko < 15000 && tko <= now + 60000;
+      var foreignFresh = lease && lease.id !== self && lease.at <= now + 60000 && now - lease.at < LEASE_TTL_MS;
+      if (foreignFresh && !takeoverFresh) {
+        becomeBlocked("lease_held");
+        return;
+      }
+      becomeActive();
+    } catch (e) { /* 守卫绝不能把页面拖挂 */ }
+  }
+  maSinglePageGuard();
+  /* ===DSH-MA-SINGLEPAGE-END=== */
+
   } catch (e) { if (window.console) console.warn("[dsh-mobile-adapter]", e && e.message); }
 })();`;