dsh-mpkg-wallpaper 3.13.8 → 3.13.9

package/README.en.md

@@ -400,6 +400,7 @@ Start here when something is wrong: one click sends state back to the local host
 | `?mpwstore=0\|mem` | Disable the in-frame storage facade / keep it in memory without persisting |
 | `?mpwpersist=legacy` | Settings persistence back to the old behaviour |
 | `?bgwrapfix=legacy`, `?hdrfrostwatch=off` | Wallpaper-layer visibility / frost watchdog |
+| `?hiddengate=legacy` | **Whole hidden-gate family back to the old behaviour** (no more blocking our autoplay/retries while the page is hidden, frozen or background-reloaded; for A/B and emergencies. Default = never start playback while hidden, stop every sound surface we own when hidden, resume per policy on return; see [`docs/WALLPAPER-LIFECYCLE.md`](docs/WALLPAPER-LIFECYCLE.md) §6.4) |
 
 ### Renderer-side diagnostics flags (pure Scene wallpapers)
 

package/README.md

@@ -401,6 +401,7 @@ node tools/build-bundle.mjs
 | `?mpwstore=0\|mem` | 关帧内存储 facade / 只留内存不落盘 |
 | `?mpwpersist=legacy` | 设置持久化回旧行为 |
 | `?bgwrapfix=legacy`、`?hdrfrostwatch=off` | 壁纸层可见性 / 磨砂看门狗 |
+| `?hiddengate=legacy` | **隐藏闸门整族回旧行为**（后台挂载/冻结/切页时不再拦我们的起播与重试；A/B 与线上救急用。默认档＝页面隐藏时一律不起播、隐藏时停住所有我们的出声面、回到可见按当时策略恢复；详见 [`docs/WALLPAPER-LIFECYCLE.md`](docs/WALLPAPER-LIFECYCLE.md) §6.4） |
 
 ### 渲染器侧诊断开关（纯 Scene 壁纸）
 

package/lib/client.js

@@ -147,7 +147,13 @@ function mpwTrace(ev, data) {
 					count("retries");
 					try { console.warn("[dsh-mpkg-wallpaper] 🔁 " + tag + " rs=0 无元数据 → 第 " + tries + "/" + RETRY_MAX + " 次补 load()（上游 Firefox Bug " + BUG + "；依据渲染器仓探针 tests/mpkg-videobase-recovery-probe.mjs：只补一次 load() 即恢复）"); } catch (e) {}
 					try { el.load() } catch (e) {}
-					try { const p = el.play(); if (p && typeof p.catch === "function") p.catch(() => {}) } catch (e) {}
+					/* H(2026-09-25) hidden 期间**只补 load()、不起播**（补 load 是为了解上游 Bug 2056444 的
+					   元数据挂起；起播要等可见 —— 见 mpwHiddenBootGate 那一节）。
+					   写法用 `typeof … === "function"` 是**故意的**：本块被 tools/blob-media-retry-test.mjs
+					   按 BEGIN/END 标记**整段切出来独立求值**（那条判据 S1-4 明确要求"不依赖闭包里的其它名字"）
+					   ⇒ 生产里它是闭包函数、照常过闸；切出来跑时它是 undefined、行为与修前逐字一致。
+					   "这一发真的接上了闸门"由 tools/hidden-gate-test.mjs 的源码锚点单独钉住（删掉即红）。 */
+					if (!(typeof mpwPlayBlockedBy === "function" && mpwPlayBlockedBy("blob-retry"))) { try { const p = el.play(); if (p && typeof p.catch === "function") p.catch(() => {}) } catch (e) {} }
 					timer = setTimeout(tick, RETRY_GAP_MS);
 				} catch (e) {}
 			};
@@ -819,7 +825,9 @@ function sectionSigNow() {
 							img.src = desired;
 							try { img.load && img.load() } catch {}
 						}
-						if (video) { try { video.load(); const p = video.play(); if (p && p.catch) p.catch(() => {}) } catch {} }
+						/* H(2026-09-25) 这条 120ms 延迟重放是**后台重载**那条路上最容易漏的一发：它不查 hidden，
+						   而 `video.load()` 之后的 `play()` 正是"挂载期起播"的形态（hidden 时不 play）。 */
+						if (video) { try { video.load(); if (!mpwPlayBlockedBy("auto-refresh")) { const p = video.play(); if (p && p.catch) p.catch(() => {}) } } catch {} }
 						try { applyFromStorage(); } catch (e) { mpwErr("applyFromStorage(autoRefresh 延迟重放)", e); }
 					} catch (e) {}
 				}, 120);
@@ -3517,7 +3525,9 @@ function mpwThumbFail(el, why) {
 			// 无条件 play()，把用户手动暂停解开（用户实测"暂停后开启效果又解开暂停"）。
 			// ①(NP-4) 门控**在 npPrimePlay 里**（它自己判 wallUserPaused/powPaused），
 			//   并且把"静音/电平落点"挪到**起播成功之后**（顺序根因见 npPrimePlay 注释）。
-			try { npPrimePlay(video); } catch {}
+			// H(2026-09-25) 再加一道**挂载期**闸门（在 npPrimePlay 之前）：挂载完成时页面隐藏 ⇒
+			//   一律不起播，只记一条台账，等第一次可见时按当时策略恢复（见 mpwHiddenBootGate）。
+			if (!mpwHiddenBootGate("showVideoEl")) { try { npPrimePlay(video); } catch {} }
 			/* ②(2026-09-20 审计第 2 条) 视频档同样验活：源不可用 ⇒ 撤 src + 记状态 + 层隐藏
 			   （否则是一块黑屏，用户分不清"视频坏了"和"壁纸就是这个颜色"）。 */
 			try {
@@ -4514,6 +4524,11 @@ function mpwThumbFail(el, why) {
 			// ①(修正) frame.muted 逻辑曾写反（!(mute) → 默认反而出声）；现在正向。
 			applyWebMute(frame);
 			frame.style.display = "";
+			/* H(2026-09-25) **挂载期隐藏 ⇒ 帧一律先 park**：web/场景壁纸的作者脚本在 load 之后会
+			   自己起播（`?audio=1` 的场景音轨、web 壁纸的 BGM），而这条路上我们**没有** play()
+			   可拦（声音是帧内作者发起的）⇒ 唯一能做的就是挂载后立刻把这一页收起来。
+			   `applyWebMute` 里已按 hidden 下发 park（含渲染器图级通道 + shim 通道），这里补记台账。 */
+			try { if (String(frame.getAttribute("src") || "") && mpwHiddenBootGate("showWebEl")) pauseWebFrame(); } catch (e) {}
 			// ⑳(新) web 壁纸倍速：iframe 内 <video> 的 playbackRate（同源可访问；
 			// 部分 web 壁纸用 canvas/WebGL 渲染无 <video>，静默跳过）
 			try { applyWebSpeed(frame); } catch {}
@@ -4631,6 +4646,29 @@ function mpwThumbFail(el, why) {
 				/* ①(2026-09-25 任务 ㉑ 追加) 帧内音频归属/暂停状态也要跟着走：`npFrameSoundBlocked()` 为真
 				   （卡片暂停/我们真的在放音）时，把这一页**收起来**（停源），否则只是压增益。 */
 				try { if (npFrameSoundBlocked()) sendRendererAudioPolicy(frame, true, true, "np-owns"); } catch {}
+				/* H(2026-09-25) **隐藏/冻结 ⇒ 帧一律 park**：这是"web 帧 / 场景帧（`?audio=1`）在后台
+				   挂载时仍起播"那条路的唯一落点（跨源帧读不到 contentDocument、`frame.muted` 对 iframe
+				   本来就不是标准属性、shim 只覆盖 shim 帧）。park 会走渲染器侧 pause + ctx.suspend。
+				   只在**真的挂了帧**（有 src）时下发，避免对空帧刷 shim 失败台账。 */
+				try {
+					if (frame && String(frame.getAttribute("src") || "") && mpwHiddenAudioBlock()) {
+						if (sendRendererAudioPolicy(frame, true, true, "hidden-park")) {
+							mpwHiddenLedgerPush("frame-park", { src: String(frame.getAttribute("src") || "").slice(0, 60) });
+						}
+					}
+				} catch (e) {}
+				/* H(2026-09-25 ③) **如实标注"这个帧我们够不着"**：不透明源（sandbox 无 allow-same-origin）
+				   且不是 shim 帧 ⇒ `contentDocument` 为 null、shim 通道不存在、`frame.muted` 又是空写 ⇒
+				   我们对它**一个字节都控制不了**。这里只记账（绝不假装"已经静音了"），并写进
+				   `window.__mpwUnreachableFrames` 供真机归因（owner=frame、无可用通道）。 */
+				try {
+					if (frame && String(frame.getAttribute("src") || "") && !frame.contentDocument && !mpwWebShimUrl(frame.getAttribute("src"))) {
+						const rec = { at: Date.now(), src: String(frame.getAttribute("src") || "").replace(/token=[^&]*/, "token=…").slice(0, 90), why: "opaque-origin/no-shim → 我们的静音与暂停都到不了这个帧" };
+						const a = window.__mpwUnreachableFrames || (window.__mpwUnreachableFrames = []);
+						a.push(rec); if (a.length > 8) a.shift();
+						if (!mpwHiddenLedgerSeen("frame-mute-unreachable")) mpwHiddenLedgerPush("frame-mute-unreachable", { src: rec.src });
+					}
+				} catch (e) {}
 				// ①(2026-09-16 I 项) shim 通道：帧内静音由 shim 执行（不透明源读不到帧内元素）
 				if (frame && mpwWebShimUrl(frame.getAttribute("src"))) {
 					const want = { muted: mute, speed: npPolicySpeed(), volume: npWantVolume() };
@@ -4795,13 +4833,157 @@ function mpwThumbFail(el, why) {
 				return s.powPauseHidden !== void 0 ? !!s.powPauseHidden : DEFAULT_POW_PAUSE_HIDDEN;
 			} catch (e) { return DEFAULT_POW_PAUSE_HIDDEN }
 		}
-		function mpwHiddenAudioBlock() {
+		/* ══════════════════════════════════════════════════════════════════════════════════
+		   H(2026-09-25 真机修复)「**后台挂载期起播**」—— C 那一轮的三个缺口
+		   ──────────────────────────────────────────────────────────────────────────────────
+		   现场（用户新报，与 C 那次**不同**）：
+		     「后台只有 Termux + Via 在跑；在哔哩哔哩 App 里看视频时**突然冒出声音**，与 B 站音频
+		       叠加（B 站没被暂停）；回到 Via 发现 DSH 页面**需要重新加载**（= 页面此前被 Android
+		       冻结/丢弃/静默重载过）」。
+		   三个现场特征指向**同一条链**：Android 把后台标签冻结→丢弃→**在后台重新加载**，
+		   于是我们的插件在 `document.hidden === true` 的状态下**走了一遍完整挂载** ——
+		     · ① `visibilitychange` **可能根本不派发**（页面一挂载就已经是 hidden）⇒ 只挂在事件上的
+		          `powPauseHidden` 那一路（`setupPowerSave` 里的 `updatePowerPause()`）没跑，
+		          `powPaused` 仍是 **false**；
+		     · ② 各路挂载/重试路径的 `play()` 里，只有 `npPrimePlay` / `resumeWallpaperVideo` 查了
+		          `mpwHiddenAudioBlock()`；**其余 14 处只查 `!(wallUserPaused || powPaused)`，一处都
+		          没查 `document.hidden`**（C 那轮只收口了"补起播"三条，见下表）；
+		     · ③ `powPaused` 是**快照**：C 的判据是"上一轮省电跑过"，冻结/丢弃后台重载这条路上它
+		          从来没被置真 ⇒ C 的闸门在**这一条路径上等于没有**。
+		   修法（与 C 同一个判据 `mpwHiddenAudioBlock()`，只是把落点补全 + 补启动期状态机）：
+		     ① 启动期：挂载完成时 `document.hidden === true` ⇒ **一律不起播**（视频/BGM/web 帧/
+		        场景帧/`npPrimePlay` 全部），只记**一条**台账；等到第一次
+		        `visibilitychange → visible`（或用户手势）再**按当时策略**恢复。
+		        两种状态**必须可区分**（现场排障就靠这个）：
+		          · `never-started`（`mpwHiddenBootBlocked`）：从没起播过 ⇒ 回到可见时**可以**起播；
+		          · `paused-by-hidden`（`mpwHiddenPausedByUs`）：隐藏前在播、被我们停的 ⇒ 回来按
+		            原状态续播（`powHidWallWasPlaying` 那条既有语义，不动）。
+		     ② 隐藏/冻结/丢弃：`visibilitychange`(hidden) / `pagehide` / **`freeze`**（新增；不存在就
+		        静默跳过）时把**所有我们的出声面**停住：`video.pause()`、web 帧下发 `park`、
+		        场景帧下发 `park`（`sendRendererAudioPolicy(frame,true,true,…)`）。
+		        `AudioContext.suspend()`：**我们自己的面里没有 AudioContext**（唯一的 WebAudio 是
+		        帧内作者的，跨源只能靠 `park` 让渲染器自己 suspend；总线的既有决定是"压增益而不是
+		        suspend"，理由见 `MPW-AUDIO-BUS` 的注释）⇒ 不碰别人的 ctx，只**如实记账**。
+		     ③ 只对**我们自己的面**负责：第三方（鲸鱼挂件等）一个字节都不碰，但审计里如实标 owner，
+		        且"hidden 期间起播"这条**无论 owner 是谁都记一条**（含 owner/src/栈，见 `mpwAuditPush`）。
+		   语义与开关（两条逃生门，都登记在文档里）：
+		     · 复用既有设置项 `powPauseHidden`：显式关掉 ⇒ 本闸门一并失效（= "切页也出声是我选的"）；
+		     · 新增 `?hiddengate=legacy`（URL，刷新即生效）：**整族**回到没有 hidden 闸门的旧行为，
+		       A/B 对照与线上救急用（见 README「插件侧 URL 逃生口」表 + docs/WALLPAPER-LIFECYCLE.md）。
+		   判据（离线、无浏览器）：`node tools/hidden-gate-test.mjs`（含变异自证：删掉任一新增门控 ⇒ 必红）。
+		   ══════════════════════════════════════════════════════════════════════════════════ */
+		function mpwHiddenGateLegacy() {
+			try { return new URLSearchParams(location.search).get("hiddengate") === "legacy" } catch (e) { return false }
+		}
+		let mpwHiddenFrozen = false;         // 见过 freeze（Android 冻结）⇒ 视为隐藏，直到 resume/可见
+		let mpwHiddenBootBlocked = false;    // 挂载期因隐藏被挡住（**从没起播过**）
+		let mpwHiddenPausedByUs = false;     // 隐藏时我们按下的暂停（**被隐藏暂停过**）
+		let mpwHiddenBootLogged = false;     // 启动期那条台账只记一次（"只记一条"）
+		let mpwHiddenLedger = [];            // 有界台账（≤64，真机可读：window.__mpwHiddenLedger）
+		/** 台账：**只记账、零行为影响**。真机上"这次到底谁起的 / 为什么没起"就靠它。
+		 *  **合并规则**（必须）：有些调用点是 800ms/2s 周期驱动的（`applyWebMute` / `npApplyFrameMute`）
+		 *  ⇒ 同一 `(kind, where, src)` 在 2s 内只留第一条，否则 64 条的环会被"同一件事"刷满，
+		 *  真正要看的那几条（`boot-hidden-no-autoplay` / `pause` / `hidden-play`）会被挤出去。 */
+		function mpwHiddenLedgerPush(kind, extra) {
+			try {
+				const x = extra || {};
+				const last = mpwHiddenLedger[mpwHiddenLedger.length - 1];
+				if (last && last.kind === String(kind || "") && last.where === x.where && last.src === x.src
+					&& (Date.now() - Number(last.t || 0)) < 2000) return last;
+				const rec = Object.assign({ t: Date.now(), kind: String(kind || ""),
+					hidden: (() => { try { return document.hidden === true } catch (e) { return null } })(),
+					vis: (() => { try { return String(document.visibilityState || "") } catch (e) { return "" } })(),
+					pow: !!powPaused, block: null, bootBlocked: !!mpwHiddenBootBlocked, pausedByUs: !!mpwHiddenPausedByUs,
+					frozen: !!mpwHiddenFrozen, legacy: mpwHiddenGateLegacy(), gateOn: mpwHiddenPauseOn(),
+				}, extra || {});
+				try { rec.block = mpwHiddenAudioBlock() } catch (e) {}
+				mpwHiddenLedger.push(rec);
+				if (mpwHiddenLedger.length > 64) mpwHiddenLedger.splice(0, mpwHiddenLedger.length - 64);
+				try { window.__mpwHiddenLedger = mpwHiddenLedger } catch (e) {}
+				return rec;
+			} catch (e) { return null }
+		}
+		/** 台账去重读法：同类事件只记第一条（周期函数每 800ms 调一次，不刷屏）。 */
+		function mpwHiddenLedgerSeen(kind) {
+			try { for (let i = 0; i < mpwHiddenLedger.length; i++) if (mpwHiddenLedger[i] && mpwHiddenLedger[i].kind === kind) return true; } catch (e) {}
+			return false;
+		}
+		/** `document.hidden` 的**实时**读法（不依赖任何事件）：冻结/丢弃/后台重载三条路都要它。 */
+		function mpwHiddenLive() {
 			try {
-				if (!mpwHiddenPauseOn()) return false;
+				if (mpwHiddenFrozen) return true;
 				if (powHiddenNow) return true;
 				return !!(typeof document !== "undefined" && document && document.hidden === true);
 			} catch (e) { return false }
 		}
+		function mpwHiddenAudioBlock() {
+			try {
+				/* 逃生门：`?hiddengate=legacy` ⇒ 整族闸门失效（含 C 那一轮的三条），回到旧行为。 */
+				if (mpwHiddenGateLegacy()) return false;
+				if (!mpwHiddenPauseOn()) return false;
+				return mpwHiddenLive();
+			} catch (e) { return false }
+		}
+		/** H-③ 所有"**我们自己的**起播入口"共用的一道闸：用户暂停 / 省电暂停 / hidden。
+		 *  返回值 = true 表示"**拦住了**"（调用方必须不 play）。`where` 进台账，用于归因。 */
+		function mpwPlayBlockedBy(where) {
+			try {
+				if (wallUserPaused || powPaused) return true;
+				if (mpwHiddenAudioBlock()) { mpwHiddenLedgerPush("play-blocked", { why: "hidden", where: String(where || "") }); return true }
+				return false;
+			} catch (e) { return false }
+		}
+		/** C 那轮 7 处重试路径的既有写法 `!(wallUserPaused || powPaused)` 的**等价加强版**
+		 *  （多出 hidden 一条；语义不变，见上面 H-②的根因）。 */
+		function mpwMediaPlayBlocked() { return mpwPlayBlockedBy("media-retry") }
+		/** H-① 挂载期闸门：`document.hidden === true` 时**一律不起播**，只记一条台账。
+		 *  @returns {boolean} true = 拦住了（调用方不许 play / 不许 prime）。 */
+		function mpwHiddenBootGate(where) {
+			try {
+				if (!mpwHiddenAudioBlock()) return false;
+				/* "从没起播过"与"被隐藏暂停过"必须区分：挂载期这条只置 bootBlocked，绝不置 pausedByUs。 */
+				mpwHiddenBootBlocked = true;
+				if (!mpwHiddenBootLogged) {
+					mpwHiddenBootLogged = true;
+					mpwHiddenLedgerPush("boot-hidden-no-autoplay", { where: String(where || ""), state: "never-started" });
+					try { console.warn("[dsh-mpkg-wallpaper] 挂载时页面处于隐藏状态 ⇒ **一律不起播**（视频/BGM/帧全部），等第一次可见时按当时策略恢复；台账 window.__mpwHiddenLedger（" + where + "）"); } catch (e) {}
+				} else {
+					mpwHiddenLedgerPush("mount-blocked", { where: String(where || "") });
+				}
+				return true;
+			} catch (e) { return false }
+		}
+		/** H-① 恢复：**从没起播过**那一条路（`paused-by-hidden` 走既有的 resumeWallpaperVideo）。
+		 *  只在"策略允许"时动手：用户暂停 / 卡片暂停 / 浏览器拒绝过 ⇒ 一个字节都不碰。 */
+		function mpwHiddenBootResume(where) {
+			try {
+				if (!mpwHiddenBootBlocked) return false;
+				if (mpwHiddenAudioBlock()) return false;              // 还隐藏着 ⇒ 不恢复
+				mpwHiddenBootBlocked = false;
+				const s = readSection();
+				let did = [];
+				/* 壁纸视频：闸门与 npPrimePlay 一模一样（它内部还会再判一次，这里只是留痕） */
+				try {
+					const vid = npActiveVideo(s) || bgElements().video;
+					if (vid && vid.paused && vid.src && !npPlayBlocked && !wallUserPaused && !npCardPaused && !npUserPausedOf(vid)) {
+						npPrimePlay(vid); did.push("video");
+					}
+				} catch (e) {}
+				/* 我们自己的 <audio>（曲目档）：只有"清单在 + 用户没按暂停"才续播 */
+				try {
+					const list = npTrackList(s);
+					if (npAudio && npAudio.paused && list && list.tracks && list.tracks.length && !npCardPaused) {
+						const a = String(npAudio.getAttribute("src") || "");
+						if (!a) npLoadTrack(true); else { const p = npAudio.play(); if (p && p.catch) p.catch(() => {}); }
+						did.push("audio");
+					}
+				} catch (e) {}
+				/* 帧：只撤销**我们**按下的暂停（webFramePausedByUs 记账，作者自己停着的不碰） */
+				try { const f = bgElements().frame; if (f && f.style.display !== "none") { resumeWebFrame(); did.push("frame") } } catch (e) {}
+				mpwHiddenLedgerPush("boot-visible-resume", { where: String(where || ""), did: did.join("+") || "none", state: "never-started->running" });
+				return true;
+			} catch (e) { return false }
+		}
 		/* ══════════════════════════════════════════════════════════════════════════════════
 		   C3(2026-09-20 真机修复)「**换档即断开旧音源**」：一条真凶级漏洞
 		   ──────────────────────────────────────────────────────────────────────────────────
@@ -5028,6 +5210,16 @@ function mpwThumbFail(el, why) {
 		 *  （否则重试那一下会被"状态校准"当场撤销，等于没重试）。 */
 		function npPlayRetryMuted(video, err) {
 			npOpTrace("prime-reject", null, String(err && err.name || "Error"));
+			/* H(2026-09-25) hidden 期间**连 muted 重试也不做**（先判、再记"被拒"状态：否则会把一次
+			   根本没发生的重试记成 `retryMuted:true`）。为什么这条也要挡：
+			   ① 它对"隐藏期 no-play"这条契约是噪声；② 真机审计 09-23 那条
+			   `hidden:true kind=play muted=true paused=true` 正是这类"被节流的 promise 回调在被隐藏
+			   之后才落地"的形态 —— 元素当时还没起播（paused=true 就是证据）。 */
+			if (mpwPlayBlockedBy("prime-retry-muted")) {
+				try { npMarkPlayBlocked({ name: String(err && err.name || "Error"), message: String(err && err.message || "").slice(0, 200), at: Date.now(), retryMuted: false, hiddenSkipped: true }); } catch (e) {}
+				npOpTrace("prime-retry", null, "skipped:hidden");
+				return false;
+			}
 			npMarkPlayBlocked({
 				name: String(err && err.name || "Error"),
 				message: String(err && err.message || "").slice(0, 200), at: Date.now(), retryMuted: true,
@@ -5071,6 +5263,9 @@ function mpwThumbFail(el, why) {
 				npGestureArmed = false;
 				if (!npPlayBlocked && !npSoundBlocked) return;
 				if (mpwHiddenAudioBlock()) { npOpTrace("gesture-retry", null, "gated:hidden"); return; }   // C: 隐藏时不补起播
+				/* H(2026-09-25 ①) 用户手势 = 挂载期被挡那条路的**第二个恢复口**（第一个是第一次可见；
+				   见 mpwHiddenBootGate/mpwHiddenBootResume）。 */
+				try { mpwHiddenBootResume("gesture"); } catch (e) {}
 				/* ①(NP-4) 用户真的交互了 ⇒ 声音限制解除：清掉"被挡住"状态，取消静音并续播。 */
 				npSoundBlocked = false; npSoundReason = null;
 				npGestureUnlock("gesture");   // C4：这一次交互同时解除"必须 muted"（此后按设置）
@@ -6042,6 +6237,9 @@ function mpwThumbFail(el, why) {
 			disarmSceneWatchdog(true); // ①(批次15 B1) 切到 canvas 合成壁纸：解除场景看门狗并清兜底视觉
 			try { if (window.__mpwLnReset) window.__mpwLnReset(); } catch {} // ①(批次15 B3) 方向键守卫复位
 			try { if (video) video.pause(); } catch {}
+			/* H(2026-09-25) 挂载期隐藏 ⇒ 记一条"从没起播过"的台账（video 已 pause；场景合成的
+			   音轨由渲染器帧那条 park 通道负责，见 applyWebMute / showWebEl）。 */
+			try { mpwHiddenBootGate("showSceneEl"); } catch (e) {}
 			wrap.classList.remove("mpw-img", "mpw-video", "mpw-web");
 			wrap.classList.add("mpw-scene");
 			if (img) img.style.display = "none";
@@ -6925,7 +7123,7 @@ function mpwThumbFail(el, why) {
 								vid2.removeAttribute("src");
 								vid2.src = hostUrl;
 								vid2.load();
-								try { if (!(wallUserPaused || powPaused)) { const pp = vid2.play(); if (pp && pp.catch) pp.catch(() => {}); } } catch {}
+								try { if (!mpwMediaPlayBlocked()) { const pp = vid2.play(); if (pp && pp.catch) pp.catch(() => {}); } } catch {}
 							} catch {}
 						}).catch(() => {});
 					}
@@ -6981,7 +7179,7 @@ function mpwThumbFail(el, why) {
 									vid.removeAttribute("src");
 									vid.src = hostUrl;
 									vid.load();
-									try { if (!(wallUserPaused || powPaused)) { const pp = vid.play(); if (pp && pp.catch) pp.catch(() => {}); } } catch {}
+									try { if (!mpwMediaPlayBlocked()) { const pp = vid.play(); if (pp && pp.catch) pp.catch(() => {}); } } catch {}
 								} catch {}
 								return;
 							}
@@ -6994,7 +7192,7 @@ function mpwThumbFail(el, why) {
 									vid.removeAttribute("src");
 									vid.src = resolveHostUrl(frameImg);
 									vid.load();
-									try { if (!(wallUserPaused || powPaused)) { const pp = vid.play(); if (pp && pp.catch) pp.catch(() => {}); } } catch {}
+									try { if (!mpwMediaPlayBlocked()) { const pp = vid.play(); if (pp && pp.catch) pp.catch(() => {}); } } catch {}
 								} catch {}
 								return;
 							}
@@ -7022,7 +7220,7 @@ function mpwThumbFail(el, why) {
 										vid.load();
 										// ①(修正) 暂停门控：自动转码重试也尊重暂停，否则用户暂停后
 										// 编码报错自动切转码会重播（绕过 showVideoEl 的门控）。
-										try { if (!(wallUserPaused || powPaused)) { const pp = vid.play(); if (pp && pp.catch) pp.catch(() => {}); } } catch {}
+										try { if (!mpwMediaPlayBlocked()) { const pp = vid.play(); if (pp && pp.catch) pp.catch(() => {}); } } catch {}
 									} catch {}
 								};
 								// 旧行为（回退开关）
@@ -7042,7 +7240,7 @@ function mpwThumbFail(el, why) {
 										vid.removeAttribute("src");
 										vid.src = cur;
 										vid.load();
-										try { if (!(wallUserPaused || powPaused)) { const pp = vid.play(); if (pp && pp.catch) pp.catch(() => {}); } } catch {}
+										try { if (!mpwMediaPlayBlocked()) { const pp = vid.play(); if (pp && pp.catch) pp.catch(() => {}); } } catch {}
 									} catch {}
 								};
 								try {
@@ -7075,7 +7273,7 @@ function mpwThumbFail(el, why) {
 								vid.src = cur;
 								vid.load();
 								// ①(修正) 暂停门控：404 重试不重播（同上，尊重暂停状态）
-								try { if (!(wallUserPaused || powPaused)) { const pp = vid.play(); if (pp && pp.catch) pp.catch(() => {}); } } catch {}
+								try { if (!mpwMediaPlayBlocked()) { const pp = vid.play(); if (pp && pp.catch) pp.catch(() => {}); } } catch {}
 							}, 800 * vid.__mpwHostTries);
 						});
 					}
@@ -7103,7 +7301,7 @@ function mpwThumbFail(el, why) {
 								vid.removeAttribute("src");
 								vid.src = hostUrl;
 								vid.load();
-								try { if (!(wallUserPaused || powPaused)) { const pp = vid.play(); if (pp && pp.catch) pp.catch(() => {}); } } catch {}
+								try { if (!mpwMediaPlayBlocked()) { const pp = vid.play(); if (pp && pp.catch) pp.catch(() => {}); } } catch {}
 								// ②(fix) 转码完成自动切换：回退后轮询 host 转码进度，
 								// done → 重新 apply（此时 /transcode 命中缓存，秒开转码产物）。
 								// 只轮询到转码完成或超时（上限 3 分钟，避免无限轮询）。
@@ -8890,7 +9088,7 @@ function mpwThumbFail(el, why) {
 				on("ended", () => { try {
 					const list = npTrackList(readSection());
 					if (list && list.tracks.length > 1) npStepTrack(1, true);
-					else if (npAudio) { npAudio.currentTime = 0; const p = npAudio.play(); if (p && p.catch) p.catch(() => {}); }
+					else if (npAudio && !mpwPlayBlockedBy("audio-loop")) { npAudio.currentTime = 0; const p = npAudio.play(); if (p && p.catch) p.catch(() => {}); }
 				} catch (e) {} });
 				on("error", () => { try { npAudioError() } catch (e) {} });
 				(document.body || document.documentElement).appendChild(npAudio);
@@ -8961,6 +9159,11 @@ function mpwThumbFail(el, why) {
 							if (!npWantPlay) return;
 							if (!(video.currentTime < 1.5)) return;    /* 放起来之后才停（播完/切源）⇒ 不关我们的事 */
 							if (npSoundBlocked) return;
+							/* H(2026-09-25) hidden 期间连这一发 muted 补播也不做：它虽然不出声，但会让
+							   "隐藏期间有 play()" 这条审计噪声盖住真凶（且解码白白耗电）。
+							   **必须在置 npSoundBlocked 之前判**：否则"被策略停住"这条状态会在隐藏期被
+							   单方面点亮，回到可见时没人再装手势重试（`npArmGestureRetry` 在下面那一行）。 */
+							if (mpwPlayBlockedBy("pause-replay")) { npOpTrace("audio-blocked", null, "skipped:hidden"); return; }
 							npSoundBlocked = true;
 							npSoundReason = { at: Date.now(), currentTime: +video.currentTime.toFixed(2), muted: video.muted, hint: "没有用户手势时浏览器不允许有声播放（Firefox 会直接把它停住）" };
 							try { window.__mpwNpSoundBlocked = npSoundReason; } catch (e) {}
@@ -9045,7 +9248,8 @@ function mpwThumbFail(el, why) {
 					   ≤32MiB 的 Blob 钉在 registry 里，自动连播 N 首 = 32MiB × N 单调增长。 */
 					npAudio.src = obj;
 					npBlobUrlSet(obj);
-					const p = npAudio.play(); if (p && p.catch) p.catch(() => {});
+					/* H(2026-09-25) hidden 时只装源、不起播（闸门见 mpwHiddenBootGate）。 */
+					if (!mpwPlayBlockedBy("audio-blob-retry")) { const p = npAudio.play(); if (p && p.catch) p.catch(() => {}); }
 					/* ①(2026-09-23 上游 Firefox Bug 2056444) 同一族的静默挂起（blob 音轨 rs=0 / 无 error、
 					   play() 的 Promise 永不 settle；`decodeAudioData` 亦然）⇒ 同一个有界重试兜底。 */
 					mpwBlobMediaRetry(npAudio, "音轨");
@@ -9078,7 +9282,12 @@ function mpwThumbFail(el, why) {
 				const st = readSection();
 				a.muted = !!(st.mute !== void 0 ? !!st.mute : true);
 				if (npVolumeSet()) a.volume = npWantVolume();   /* ①(NP-4)① 用户设过电平才写（默认不碰） */
-				if (play) { const p = a.play(); if (p && p.catch) p.catch(() => {}); }
+				if (play) {
+					/* H(2026-09-25) 起播前过闸：hidden 期间**只装源不播**。
+					   刻意**不**置"挂载期被挡"状态（那是 `showVideoEl/showWebEl/showSceneEl` 三个挂载点
+					   的职责）⇒ 换曲/next 这类被挡的起播不会在回到可见时自作主张补播。 */
+					if (!mpwPlayBlockedBy("npLoadTrack")) { const p = a.play(); if (p && p.catch) p.catch(() => {}); }
+				}
 			} catch (e) { mpwErr("npLoadTrack", e) }
 			npApplyFrameMute();
 			npSyncAudio();
@@ -9174,7 +9383,13 @@ function mpwThumbFail(el, why) {
 								const a = npEnsureAudio();
 								/* 还没装源（清单刚到/换过壁纸）⇒ 先装当前曲目再放 */
 								if (a && !String(a.getAttribute("src") || "")) { npLoadTrack(true); did = "audio.load+play"; }
-								else if (a) { const p = a.play(); if (p && p.catch) p.catch(() => {}); did = "audio.play"; }
+								else if (a) {
+									/* H(2026-09-25) 卡片/系统媒体键的播放也要过 hidden 闸：真机上"页面隐藏时
+									   被程序化调用 transport('play')"是后台重放那条链的一环（用户意图只在
+									   可见时可能发生 —— 隐藏页面上按不到卡片）。同样**不**置"挂载期被挡"。 */
+									if (mpwPlayBlockedBy("transport:play")) { did = "audio.play(blocked-hidden)"; npOpTrace("transport-hidden", op, did); }
+									else { const p = a.play(); if (p && p.catch) p.catch(() => {}); did = "audio.play"; }
+								}
 							} else if (npAudio) { npCardPaused = true; npPersistPaused(true); npAudio.pause(); did = "audio.pause"; }
 						} else if (!vid) {
 							/* 清单还没到：拉一次，到位后由 applyNowPlaying 把键的状态刷新（不假装按过了） */
@@ -9483,7 +9698,7 @@ function mpwThumbFail(el, why) {
 						else { npSetUserPaused(vid2, true); npWantPlay = false; try { vid2.pause() } catch (e) {} }
 						npOpTrace("link-align", act, "video");
 					} else if (act === "pause") { try { if (npAudio) npAudio.pause() } catch (e) {} npOpTrace("link-align", act, "audio") }
-					else { try { if (npAudio && !npCardPaused) { const p = npAudio.play(); if (p && p.catch) p.catch(() => {}) } } catch (e) {} npOpTrace("link-align", act, "audio") }
+					else { try { if (npAudio && !npCardPaused && !mpwPlayBlockedBy("link-align")) { const p = npAudio.play(); if (p && p.catch) p.catch(() => {}) } } catch (e) {} npOpTrace("link-align", act, "audio") }
 					try { npApplyFrameMute() } catch (e) {}
 				}
 				npLinkPrev = linkNow2;
@@ -9570,6 +9785,10 @@ function mpwThumbFail(el, why) {
 				const { frame } = bgElements();
 				if (!frame) return;
 				if (!webFramePausedByUs) return;          // ⑤ 我们没停过 ⇒ 一个字节都不碰
+				/* H(2026-09-25) **hidden 期间一个字节都不 play()**：本函数会被 `npApplyFrameMute`
+				   在"设置变化/延迟重放"里叫到，那条路上页面可能已经是隐藏的（C 那轮漏的就是这类）。
+				   早退**不**清 `webFramePausedByUs` ⇒ 回到可见时 `resumeWallpaperVideo` 会再叫一次。 */
+				if (mpwHiddenAudioBlock()) { mpwHiddenLedgerPush("frame-resume-blocked", { why: "hidden" }); return; }
 				webFramePausedByUs = false;
 				/* ①(2026-09-25 任务 ㉑ 追加) 撤销我们自己按下的"收起来"（跨源帧那条）。 */
 				try { sendRendererAudioPolicy(frame, !!readSection().mute || npFrameSoundBlocked(), false, "resume-frame") } catch (e) {}
@@ -9584,6 +9803,18 @@ function mpwThumbFail(el, why) {
 		function pauseWallpaperVideo() {
 			try {
 				const { video, frame } = bgElements();
+				/* H(2026-09-25) 状态区分：`paused-by-hidden` = "隐藏前真的在播 ⇒ 我们把它停住的"
+				   （回到可见时按原状态续播）；与"从没起播过"（`mpwHiddenBootBlocked`）是两回事。
+				   **只有"真的停住了一个正在播的东西"才算**：
+				   ① 用户手动暂停壁纸那条路（`pauseWallpaperVideo` 也被 `toggleWallPause` 调）不算；
+				   ② **后台重载挂载**那条路也不算 —— 那时元素**从没起播过**（`never-started`），
+				      该由 `mpwHiddenBootBlocked` 表达。否则两种状态同时为真，
+				      "谁被隐藏暂停过 / 谁从没起播过"就答不准了（真浏览器档 B5 抓到的就是这个）。
+				   判据用下面两行马上要算的"暂停前在不在播"（video / 我们自己的 audio）。 */
+				try {
+					const wasPlaying = !!(video && !video.paused && video.src) || !!(npAudio && !npAudio.paused);
+					if (mpwHiddenAudioBlock() && wasPlaying) mpwHiddenPausedByUs = true;
+				} catch (e) {}
 				/* C(2026-09-20) 记下"暂停之前壁纸在不在播"：恢复时**按原状态**续播
 				   （原本就暂停的绝不自作主张起播 —— 用户要的是"切页静音"，不是"回来自己开始放"）。 */
 				try { powHidWallWasPlaying = !!(video && !video.paused && video.src) } catch (e) {}
@@ -9617,17 +9848,21 @@ function mpwThumbFail(el, why) {
 					try { const p = video.play(); if (p && p.catch) p.catch(() => {}); } catch {}
 				}
 				// ⑤ 只撤销**我们**按下的暂停（webFramePausedByUs 记账；作者自己停着的媒体不碰）
-				if (frame && frame.style.display !== "none") resumeWebFrame();
+				/* H(2026-09-25) 隐藏期间**一次都不许 play()**：这条恢复路径也会被"设置变化/延迟重放"
+				   在后台叫到（C 那轮只挡住了 video 那一行，帧与我们自己的 audio 两行漏着）。 */
+				if (frame && frame.style.display !== "none" && !mpwHiddenAudioBlock()) resumeWebFrame();
 				/* ⑤ 静音回落到设置/卡片口径（不能把"卡片暂停"那条压住的静音也一起放开） */
 				try { npApplyFrameMute(); } catch (e) {}
 				/* ⑤ 隐藏前在放才续播；隐藏前就是暂停的绝不自作主张播放 */
 				try {
-					if (powHidNpWasPlaying && npAudio && npAudio.paused && !npCardPaused) {
+					if (powHidNpWasPlaying && npAudio && npAudio.paused && !npCardPaused && !mpwHiddenAudioBlock()) {
 						const p = npAudio.play(); if (p && p.catch) p.catch(() => {});
 					}
 					powHidNpWasPlaying = false;
 				} catch (e) {}
 				powHidWallWasPlaying = false;
+				mpwHiddenPausedByUs = false;
+				mpwHiddenLedgerPush("visible-resume", { force: force === true });
 			} catch {}
 		}
 		/** 按三档状态决定暂停/恢复（任一档触发即暂停，全恢复才继续）。 */
@@ -9639,9 +9874,14 @@ function mpwThumbFail(el, why) {
 				const battOn = s.powPauseBattery !== void 0 ? !!s.powPauseBattery : false;
 				let hiddenNow = powHiddenNow;
 				try { if (!hiddenNow && typeof document !== "undefined" && document && document.hidden === true) hiddenNow = true } catch (e) {}
+				if (mpwHiddenFrozen) hiddenNow = true;      // H: freeze（Android 冻结）与 hidden 同一待遇
 				const shouldPause = (hiddenOn && hiddenNow) || (blurOn && !powFocusedNow) || (battOn && powBattery && powBattery.charging === false);
-				if (shouldPause && !powPaused) { powPaused = true; pauseWallpaperVideo(); }
+				if (shouldPause && !powPaused) { powPaused = true; mpwHiddenLedgerPush("pause", { by: "power" }); pauseWallpaperVideo(); }
 				else if (!shouldPause && powPaused) { powPaused = false; resumeWallpaperVideo(); }
+				/* H(2026-09-25 ①) **挂载期被挡**那条独立状态：挂载完成时就是隐藏的 ⇒ 从没起播过；
+				   回到可见（且策略允许）时由它负责把那一次"补上"。与上面"按原状态续播"互不干扰：
+				   `resumeWallpaperVideo` 只在 `powHidWallWasPlaying` 为真时动手，而这条置的是 false。 */
+				if (!shouldPause) { try { mpwHiddenBootResume("updatePowerPause"); } catch (e) {} }
 			} catch {}
 		}
 		/** 注册省电监听（一次性）。
@@ -9658,6 +9898,8 @@ function mpwThumbFail(el, why) {
 			try {
 				document.addEventListener("visibilitychange", () => {
 					powHiddenNow = document.hidden === true;
+					if (!powHiddenNow) mpwHiddenFrozen = false;   // H: 可见 ⇒ 冻结状态一并解除
+					mpwHiddenLedgerPush("visibilitychange", { state: (() => { try { return String(document.visibilityState || "") } catch (e) { return "" } })() });
 					updatePowerPause();
 				});
 			} catch {}
@@ -9667,9 +9909,31 @@ function mpwThumbFail(el, why) {
 			} catch {}
 			// ⑤ pagehide/pageshow：bfcache / 切标签在部分浏览器不派发 visibilitychange
 			try {
-				window.addEventListener("pagehide", () => { powHiddenNow = true; updatePowerPause(); });
+				window.addEventListener("pagehide", () => { powHiddenNow = true; mpwHiddenLedgerPush("pagehide"); updatePowerPause(); });
 				window.addEventListener("pageshow", () => {
 					try { powHiddenNow = document.hidden === true } catch (e) { powHiddenNow = false }
+					mpwHiddenLedgerPush("pageshow");
+					updatePowerPause();
+				});
+			} catch {}
+			/* H(2026-09-25 ②) `freeze` / `resume`：页面生命周期 API（Android 冻结后台标签时派发）。
+			   为什么必须单独接：冻结**不一定**派发 `visibilitychange`（页面可能"一挂载就已经是 hidden"），
+			   而冻结期间我们的解码/音频仍可能被系统放行 ⇒ 把 freeze 当成 hidden 是最保守也最正确的读法。
+			   `document.addEventListener('freeze')` 在不支持的浏览器上等于挂了个永不触发的监听（无害，
+			   不抛错）⇒ 不做能力探测、也不写能力位（免得把"支持"说成"不支持"）。 */
+			try {
+				document.addEventListener("freeze", () => {
+					mpwHiddenFrozen = true;
+					mpwHiddenLedgerPush("freeze");
+					/* 走**同一条状态机**（而不是单独 pause 一下）：`updatePowerPause` 里
+					   `mpwHiddenFrozen ⇒ hiddenNow` ⇒ `powPaused=true` + `pauseWallpaperVideo()` 全落点；
+					   对应地 `resume`/可见时它会走 `resumeWallpaperVideo()` 按**原状态**续播
+					   （单独 pause 会让画面永久冻在冻结那一刻 —— 恢复没人管）。 */
+					updatePowerPause();
+				});
+				document.addEventListener("resume", () => {
+					mpwHiddenFrozen = false;
+					mpwHiddenLedgerPush("resume");
 					updatePowerPause();
 				});
 			} catch {}
@@ -10383,6 +10647,11 @@ function mpwThumbFail(el, why) {
 		   下一次就能直接从上报里读到来源。开关 `?npaudit=0` 完全不装（零开销）；缺省装。
 		   ══════════════════════════════════════════════════════════════════════════════════ */
 		const MPW_AUDIT_MAX = 200;
+		/* H(2026-09-25 ③) 「hidden 期间起播」**无论 owner 是谁都记一条**的独立台账（≤16 条）：
+		   为什么不能只靠上面那个 200 条环形缓冲 —— 它**刷新即清空**，而本条现场恰恰是"页面在后台
+		   被丢弃/重载"，等用户回到 Via 时缓冲里往往什么都没有了。这份台账挂在 `window` 上并与
+		   `mpwHiddenLedger` 一起进 `/diag` 信标，owner/src/栈三样齐全（第三方也照记，只是不控制它）。 */
+		const MPW_HIDDEN_PLAY_MAX = 16;
 		let mpwAuditInstalled = false;
 		let mpwAuditLastBeacon = 0;
 		function mpwAuditOn() {
@@ -10477,6 +10746,18 @@ function mpwThumbFail(el, why) {
 					|| !!(rec.el && rec.el.connected === false && rec.paused === false)
 					|| (kind === "play" && rec.hidden === true)
 					|| ((kind === "unmute" || kind === "volume") && rec.hidden === true && rec.muted === false);
+				/* H(2026-09-25 ③) hidden 期间那**两类**转变（起播 / 取消静音）另存一份**独立台账**：
+				   ① owner 是谁都记（我们自己、壁纸帧、别的插件、跨源帧的 foreign 条目）—— 只记录、不控制；
+				   ② 刷新丢不掉的那些行会跟着 /diag 信标一起落盘（见下面 beacon 的 hiddenPlays 字段）。 */
+				if (rec.hidden === true && (kind === "play" || kind === "unmute" || kind === "volume" || kind === "webaudio-start" || kind === "audioctx-resume")) {
+					try {
+						const hp = window.__mpwHiddenPlays || (window.__mpwHiddenPlays = []);
+						hp.push({ t: rec.t, kind: rec.kind, who: rec.who, win: rec.win, el: rec.el, muted: rec.muted, volume: rec.volume, paused: rec.paused, npMute: rec.np && rec.np.mute });
+						if (hp.length > MPW_HIDDEN_PLAY_MAX) hp.splice(0, hp.length - MPW_HIDDEN_PLAY_MAX);
+						if (store) store.hiddenPlays = hp;
+						mpwHiddenLedgerPush("hidden-play", { owner: (rec.el && rec.el.owner) || ((rec.win && rec.win.foreign) ? "foreign-frame" : "unknown"), playKind: rec.kind, src: (rec.el && rec.el.src) || (rec.win && rec.win.url) || "", audible: !!audible });
+					} catch (e) {}
+				}
 				if (suspicious) {
 					if (store) { try { store.suspicious = (store.suspicious || 0) + 1 } catch (e) {} }
 					if (Date.now() - mpwAuditLastBeacon > 5000) {
@@ -10488,6 +10769,11 @@ function mpwThumbFail(el, why) {
 										: (audible ? "audible-playback" : (rec.el && rec.el.connected === false ? "detached-playing" : "hidden-transition"))),
 								record: rec, window: list.slice(-12), count: list.length,
 								visibility: (() => { try { return document.visibilityState } catch (e) { return null } })(),
+								/* H(2026-09-25 ③) 两条"刷新也丢不掉"的台账一起进信标：hidden 期间的起播
+								   （含 owner/src/栈）与我们自己的隐藏闸门台账。真机下次复现时，**即使页面
+								   在后台被丢弃/重载**，落盘的那一份里也有这两样。 */
+								hiddenPlays: (() => { try { return (window.__mpwHiddenPlays || []).slice(-8) } catch (e) { return null } })(),
+								hiddenLedger: (() => { try { return mpwHiddenLedger.slice(-12) } catch (e) { return null } })(),
 							});
 						} catch (e) {}
 						try { console.warn("[dsh-mpkg-wallpaper][audio-audit] 可疑出声:", JSON.stringify(rec).slice(0, 400)); } catch (e) {}
@@ -11864,6 +12150,34 @@ function installAudioBus(win, opts = {}) {
 				npSource: () => { try { return { kind: npSourceKind(readSection()), id: npSourceId(readSection()), prev: npSrcIdPrev, audioPaused: npAudio ? !!npAudio.paused : null, audioSrc: npAudio ? String(npAudio.getAttribute('src') || '').slice(0, 60) : null } } catch (e) { return null } },
 				hiddenAudioBlock: () => { try { return mpwHiddenAudioBlock() } catch (e) { return null } },
 				hiddenPauseOn: () => { try { return mpwHiddenPauseOn() } catch (e) { return null } },
+				/* ══ H(2026-09-25) 隐藏闸门的钩子（tools/hidden-gate-test.mjs 用；生产不引用）══
+				   暴露的都是**真实现**：状态机（gate/bootBlocked/pausedByUs/frozen）、台账、以及三个
+				   真挂载点（showVideoEl/showWebEl/showSceneEl）+ 两条真恢复路径（pause/resume）。 */
+				hiddenState: () => {
+					try {
+						return {
+							legacy: mpwHiddenGateLegacy(), on: mpwHiddenPauseOn(), live: mpwHiddenLive(),
+							block: mpwHiddenAudioBlock(), frozen: !!mpwHiddenFrozen,
+							bootBlocked: !!mpwHiddenBootBlocked, pausedByUs: !!mpwHiddenPausedByUs,
+							bootLogged: !!mpwHiddenBootLogged, gateOn: !!mpwHiddenPauseOn(),
+						};
+					} catch (e) { return { err: String(e && e.message || e) } }
+				},
+				hiddenLedger: () => { try { return mpwHiddenLedger.slice() } catch (e) { return [] } },
+				hiddenLedgerClear: () => { try { mpwHiddenLedger.length = 0; mpwHiddenBootLogged = false; return true } catch (e) { return false } },
+				hiddenPlays: () => { try { return (window.__mpwHiddenPlays || []).slice() } catch (e) { return [] } },
+				/* 挂载点：走的是**生产函数本身**（含 boot 闸门、applyWebMute、pauseWebFrame 那几段） */
+				showVideo: (url) => { try { showVideoEl(url || readSection().image || "host:?token=t&index=0"); return true } catch (e) { return String(e && e.message || e) } },
+				showWeb: (url) => { try { showWebEl(url || readSection().webUrl || ""); return true } catch (e) { return String(e && e.message || e) } },
+				/* 恢复/暂停两条真路径 + 挂载期那条独立恢复口 */
+				pauseWallpaperVideo: () => { try { pauseWallpaperVideo(); return true } catch (e) { return String(e && e.message || e) } },
+				resumeWallpaperVideo: (force) => { try { resumeWallpaperVideo(force === true); return true } catch (e) { return String(e && e.message || e) } },
+				bootGate: (where) => { try { return mpwHiddenBootGate(where || "test") } catch (e) { return String(e && e.message || e) } },
+				bootResume: (where) => { try { return mpwHiddenBootResume(where || "test") } catch (e) { return String(e && e.message || e) } },
+				/* 帧策略的可判定读数（渲染器 park / shim policy 都落在这本台账上） */
+				rendererPolicy: () => { try { return (window.__mpwRendererAudioPush || { n: 0, last: null, log: [] }) } catch (e) { return null } },
+				rendererPolicyClear: () => { try { window.__mpwRendererAudioPush = { n: 0, last: null, log: [] }; return true } catch (e) { return false } },
+				unreachableFrames: () => { try { return (window.__mpwUnreachableFrames || []).slice() } catch (e) { return [] } },
 				ops: () => { try { return (window.__mpwNpOps || []).slice(-12) } catch (e) { return [] } },
 				// ⑤ 可见性/省电
 				defaultPowPauseHidden: DEFAULT_POW_PAUSE_HIDDEN,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mpkg-wallpaper",
-  "version": "3.13.8",
+  "version": "3.13.9",
   "description": "DSH Web 壁纸引擎 Wallpaper Engine mpkg 背景插件：浏览器内直接解析 .mpkg（preview.gif 动态背景/内嵌 mp4 视频/多时段切换），整屏统一虚化/对话框/弹层/遮罩独立虚化、镜头缩放平移、时钟、冲突检测。",
   "private": false,
   "type": "module",