dsh-mpkg-wallpaper 3.15.4 → 3.15.6

package/lib/client.js

@@ -1455,6 +1455,41 @@ function sectionSigNow() {
 		 *  真机现场：`converted="mp4"` + `image` 缺 + `webUrl` 是上一个 web 档的残留 ⇒ 旧判据只数
 		 *  `image/webUrl/sceneKey` 三兄弟里有没有"任何一个非空"，`webUrl` 一非空就判"不是半残"⇒
 		 *  自愈**不介入**，而挂载又按 webUrl 走 ⇒ 黑屏且永不自愈。 */
+		/* ②(2026-10-04 真机："刷新页面偶尔壁纸加载不出来 —— 类型变成 image、名字与图标是空的、
+		   预览框里是破图，重新在自定义目录里点一次『使用』又好了"）
+		   根因：档里**只剩 `image` 的 host token**，身份字段（mpkgKey/mpkgName）与 `converted` 却空了
+		   （两处存储按字段合并 + 换档时 `converted` 被清、`image` 被粘性护栏留下 ⇒ 半残档）。
+		   旧判据要求"有 mpkgKey/source 线索"才算半残档 ⇒ 这条档**既不进自愈、也判不出类型**：
+		   挂载走 image 分支、把**整段视频当图片**塞给 `<img>` ⇒ 破图图标 + 类型显示 image + 名字空。
+		   修法：token 里本来就带着身份（mpkg 的 token 名就是包名、ltoken 就是库条目）⇒ 从它反推一个
+		   临时 key 交给既有自愈链（`mpwDeriveSourceFromKey()` 会按包/目录元数据把全套源字段重算出来）。 */
+		function mpwKeyFromImageToken(img) {
+			try {
+				const u = String(img || "");
+				if (!u) return "";
+				let m = /[?&]token=([^&#]+)/.exec(u);
+				if (m) {
+					const name = decodeURIComponent(m[1]);
+					return "custommpkg|" + name + (/\.(mpkg|pkg)$/i.test(name) ? "" : ".mpkg");
+				}
+				m = /[?&]ltoken=([^&#]+)/.exec(u);
+				if (m) return "library|" + decodeURIComponent(m[1]);
+				m = /[?&]folder=([^&#]+)/.exec(u);
+				if (m) return "custom|" + decodeURIComponent(m[1]);
+			} catch (e) {}
+			return "";
+		}
+		/** 档里是不是"只剩 image token、身份/类型全空"（真机那条半残档的形状）。 */
+		function mpwIdentityMissing(s) {
+			try {
+				const img = String(mpwVal(s, "image") || "");
+				if (!/[?&](token|ltoken|custom)=/.test(img)) return false;
+				const name = String(mpwVal(s, "mpkgName") || "");
+				const key = String(mpwVal(s, "mpkgKey") || "");
+				const conv = String(mpwVal(s, "converted") || "");
+				return (!name && !key) || !conv;
+			} catch (e) { return false }
+		}
 		function mpwSrcMissing(s) {
 			const src = MPW_SRC_KEYS.some((k) => typeof mpwVal(s, k) === "string" && mpwVal(s, k));
 			const clue = (typeof mpwVal(s, "mpkgKey") === "string" && mpwVal(s, "mpkgKey")) ||
@@ -1464,6 +1499,9 @@ function sectionSigNow() {
 			const decl = typeof mpwVal(s, "converted") === "string" ? String(mpwVal(s, "converted")) : "";
 			const need = decl === "web" ? "webUrl" : decl === "scene" ? "sceneKey" : (decl === "mp4" || decl === "gif" || decl === "video" || decl === "image") ? "image" : null;
 			if (need && !mpwVal(s, need)) return true;
+			/* ②(2026-10-04) 第三种半残形状：来源只剩 image 的 host token，类型/身份全空
+			   （见 mpwIdentityMissing 的注释；真机表现为"刷新后破图 + 类型 image + 名字空"）。 */
+			if (mpwIdentityMissing(s) && !!(clue || src)) return true;
 			return false;
 		}
 		/* ══════════════════════════════════════════════════════════════════════════════════
@@ -2504,7 +2542,9 @@ function mpwThumbFail(el, why) {
 			try {
 				const cur = readSection();
 				if (!cur || !mpwSrcMissing(cur)) { mpwHealSig = ""; return false }
-				const key = String(cur.mpkgKey || "");
+				/* ②(2026-10-04) 身份 key 空但 image 是 host token ⇒ 用 token 反推（否则自愈链直接放弃，
+				   真机就是卡在这一句：`mpkgKey` 空 ⇒ 既不重挂也不自愈 ⇒ 永久破图）。 */
+				const key = String(cur.mpkgKey || "") || mpwKeyFromImageToken(cur.image);
 				if (!key) return false;
 				const sig = key + "|" + mpwHealSigOf(cur);
 				if (mpwHealSig === sig && MPW_HEAL.attempted > 0) return false;   // 同一状态只试一次
@@ -11767,6 +11807,10 @@ function mpwThumbFail(el, why) {
 				sticky: (base, next) => mpwStickySource(base, next),
 				reconcile: (local, host) => mpwReconcileStores(local || {}, host || {}),
 				srcMissing: (s) => mpwSrcMissing(s || readSection()),
+				/* ①(2026-10-04) "只剩 image token、身份/类型全空"那条半残档的纯函数（判据用） */
+				keyFromImageToken: (img) => mpwKeyFromImageToken(img),
+				healState: () => { try { return Object.assign({}, MPW_HEAL) } catch (e) { return {} } },
+				identityMissing: (s) => mpwIdentityMissing(s || readSection()),
 				deriveFromKey: (key) => mpwDeriveSourceFromKey(key || readSection().mpkgKey),
 				heal: () => { try { return mpwHealHalfArchive() } catch (e) { return String(e && e.message || e) } },
 				healState: () => Object.assign({}, MPW_HEAL, { last: MPW_HEAL.last ? Object.assign({}, MPW_HEAL.last) : null, sig: mpwHealSig }),
@@ -13568,14 +13612,32 @@ body[data-mpw-theme] [class*="settingsArea"] [role="alertdialog"] {
 		   wide: true = `?sbfill=wide` 回退开关（全局覆盖，仅排障用） */
 		function buildSidebarFillCss(mode, wide) {
 			const FILL = '--dsw-specific-sidebar-fill';
+			/* ②(2026-10-04 用户真机："整屏虚化 30 + 界面透明度 65% 时，右侧边栏比标题栏/左侧边栏**更白**")
+			   根因：这份覆盖只打在**左侧**白名单上 ⇒ 左栏内层的 `--dsw-specific-sidebar-fill` 被置透明、
+			   整栏只由我们容器那一层半透明承担；而**右栏/dock 的内层**仍拿宿主的不透明填充色
+			   （#f9fafb 一族）⇒ 右栏看上去更白、像是不跟透明度滑条。
+			   现在把右栏/dock 容器也纳入同一份白名单（同一个 token、同一个语义：内层透明，颜色只由
+			   `--mpw-surface-rs-dock` / `--mpw-unify-surface` 那一层给）——用户口径是"右栏与左栏同色同透明"。 */
 			const NARROW = `html body .pI_x6G_sidebarCol,
 html body [class*="sidebarCol"]:not([class*="_tab"]),
 html body .hHd-Xa_root,
-html body [data-slot="sidebar"]`;
+html body [data-slot="sidebar"],
+html body [data-sidebar-right-panel],
+html body [class*="P3OORG_panel"],
+html body [data-dockkit-pane],
+html body [data-dockkit-strip],
+html body [data-dockkit-surface],
+html body [data-dockkit-float]`;
 			const NARROW_DARK = `html body[data-ds-dark-theme] .pI_x6G_sidebarCol,
 html body[data-ds-dark-theme] [class*="sidebarCol"]:not([class*="_tab"]),
 html body[data-ds-dark-theme] .hHd-Xa_root,
-html body[data-ds-dark-theme] [data-slot="sidebar"]`;
+html body[data-ds-dark-theme] [data-slot="sidebar"],
+html body[data-ds-dark-theme] [data-sidebar-right-panel],
+html body[data-ds-dark-theme] [class*="P3OORG_panel"],
+html body[data-ds-dark-theme] [data-dockkit-pane],
+html body[data-ds-dark-theme] [data-dockkit-strip],
+html body[data-ds-dark-theme] [data-dockkit-surface],
+html body[data-ds-dark-theme] [data-dockkit-float]`;
 			const sel = wide ? 'html body' : NARROW;
 			const selDark = wide ? 'html body[data-ds-dark-theme]' : NARROW_DARK;
 			if (mode === 'translucent') {
@@ -15579,7 +15641,21 @@ function createNowPlaying(deps) {
     /** 一帧判据：写/撤 data-mpw-np-hidden + **让位判据**（①(NP-3)）。
      *  让位在**每一次**判据里都跑：挂载前（setEnabled 里单独一次）、挂载后（这里）都要判。
      *  规则：容器里出现非本插件、非宿主自有的占用者 ⇒ 撤下且**不重建**（等它走了再回来）。 */
+    /* ①(P1B) npFit 重排闸门：优先用 client.js 工厂作用域的 mpwHeavyGate（内联后作用域链可见）；
+       独立装载时用本地同语义兜底（动画在跑 ⇒ 推迟 400ms 补跑）。 */
+    const npFitGate = (typeof mpwHeavyGate === "function")
+      ? mpwHeavyGate
+      : function (name, fn) {
+          try { if (document.getAnimations && document.getAnimations().length) { setTimeout(fn, 400); return false } } catch (e) {}
+          return true;
+        };
     function evaluate() {
+        /* ①(P1B 2026-10-03) 收起/展开动画期间跳过重排（occupantNow/measureWidth/npFit 都是
+         getBoundingClientRect 类强制布局，宿主每帧改 DOM ⇒ 旧写法每帧一次）；400ms 后补跑
+         一次，返回上次 known hidden（调用方语义不变）。闸门主体在 client.js 工厂作用域
+         （mpwHeavyGate，内联进生成区后经作用域链可见）；本文件被**独立**装载时（now-playing-test
+         直载）用同语义本地兜底。 */
+      if (!npFitGate("npFit", evaluate)) return hidden;
       if (!container) {
         hidden = false;
         /* 没挂着时三种情况都要在这里补挂：①上一个占用者走了；②宿主侧栏后来才渲染出来；
@@ -16543,6 +16619,14 @@ module.exports = {
 			   uAlpha = 生效**不透明度** = 100 - 「界面透明度」（0 = 不透明、100 = 全透明）。
 			   与模糊彻底解耦：模糊 0 时也照样按透明度透出（背后壁纸是清晰的）。 */
 			const surfacePlan = mpwSurfacePlan(section);
+			/* ②(2026-10-04) 标题栏半透明底 token **在唯一入口无条件写**（亮/暗都走同一枚宿主底色）：
+			   旧写法只在 `syncHeaderFrost()` 里、且要求"这一刻找得到 header"才写 ⇒ 一旦那次没写，
+			   CSS 就掉回写死的白（用户真机读数：标题栏 `rgba(255,255,255,0.38)` 完全不吃透明度滑条）。
+			   ⇒ 落到与左栏/右栏**同一套模型**：宿主底色 × 表面不透明度。 */
+			try {
+				if (enabled && hasImage) document.documentElement.style.setProperty("--mpw-hdr-frost-bg", mpwSurfaceColor(surfacePlan.header.base, surfacePlan.header.opacityPct / 100));
+				else document.documentElement.style.removeProperty("--mpw-hdr-frost-bg");
+			} catch (e) {}
 			/* ②(2026-10-04 用户真机："整屏虚化程度调大 ⇒ 左/右侧边栏被叠上一层粉色滤镜；
 			   调到 0 就是完全透明的状态"）**铁律：我们一个像素都不画时，也不给宿主叠 backdrop-filter。**
 			   `backdrop-filter` 不是"我们的表面"，而是对宿主内容施加的滤镜 —— 完全没有雾层时它只剩失真：
@@ -17387,11 +17471,7 @@ html body[data-mpw-sblur][data-mpw-sblur-off] [class*="sidebarCol"] {
 				const rsBg = `rgba(255,255,255,${Math.max(0, Math.min(1, rsAlpha / 100)) * 0.55})`;
 				css += `
 /* ── F. 右侧边栏 / dock 虚化（独立开关+程度+透明度）── */
-html body[data-sidebar-right-panel],
-html body[data-sidebar-right-float-host],
-html body[data-mpw-rs],
-html body[data-dockkit-strip],
-html body[data-dockkit-float] {
+html body[data-mpw-rs-surface] {
   -webkit-backdrop-filter: ${Math.max(0, Number(rsAmount) || 0) > 0 ? `blur(${rsAmount}px)` : "none"};
   backdrop-filter: ${Math.max(0, Number(rsAmount) || 0) > 0 ? `blur(${rsAmount}px)` : "none"};
   background-color: ${rsBg} !important;
@@ -17520,6 +17600,12 @@ html body:has([class*="_modal"]) [data-mpw-rs] {
 				   三枚 token 只在接管时被下面那块 CSS 引用；不接管时它们不生效（无引用）。
 				   厚度直接取雾模型（= 左侧边栏/标题栏透明度），0 ⇒ rgba(...,0) = 完全透明，
 				   所以"统一虚化程度/透明度都拉到 0"时右栏/dock 也是干净的透出，不留采样色。 */
+				/* ②(2026-10-04 用户真机："右侧边栏比左栏/标题栏更白"）根因：右栏/dock 家族**互相嵌套**
+				   （面板 > dockkit 面板/标签条/表面，真机读数里两个元素的 rect 只差 1px），旧选择器把
+				   两层都刷上同一枚表面色 ⇒ 合成不透明度 1-(1-a)²（a=0.55 时 0.80）≈ 一块近白板；
+				   左栏只有一个匹配元素 ⇒ 单层 ⇒ 看起来"灰"。⇒ 只给**最外层**那个打标记（JS 结构判定，
+				   与 `data-mpw-holds-layer` 同一手法），CSS 只认标记。 */
+				try { mpwTagSurfaceOuter(); } catch (e) {}
 				const fogCss = mpwFogModel(section);
 				const unifyTakeover = unifyFollowNow && hasImage && !rightInert;
 				const unifyBlurCss = (!rightNoFog && fogCss.amountPx > 0) ? `blur(${fogCss.amountPx}px)` : "none";
@@ -17569,10 +17655,9 @@ ${chromeInert ? "" : `html body:not([data-mpw-sblur-off]) [class*="sidebarCol"]:
 	background-color: var(--mpw-surface-side-frost) !important;
 }`}
 /* 右侧栏 / dockkit（V 形：面板 + 标签条 + 表面） */
-${rightInert ? "" : `html body[data-mpw-rsblur="on"] [data-sidebar-right-panel],
-html body[data-mpw-rsblur="on"] [data-dockkit-pane],
-html body[data-mpw-rsblur="on"] [data-dockkit-strip],
-html body[data-mpw-rsblur="on"] [data-dockkit-surface] {
+${rightInert ? "" : `html body[data-mpw-rsblur="on"] [data-mpw-rs-surface],
+html body[data-mpw-rsblur="on"] [data-mpw-rs-surface][data-dockkit-pane],
+html body[data-mpw-rsblur="on"] [data-mpw-rs-surface][data-dockkit-strip] {
 	-webkit-backdrop-filter: ${rsBlurCss} !important;
 	backdrop-filter: ${rsBlurCss} !important;
 	background-color: var(--mpw-surface-rs-dock) !important;
@@ -17616,10 +17701,10 @@ html body[data-dragging] [data-dockkit-pane] {
 html body[data-ds-dark-theme]:not([data-mpw-sblur-off]) header[class*="_header_"],
 html body[data-ds-dark-theme]:not([data-mpw-sblur-off]) header.wSkVaW_header,
 html body[data-ds-dark-theme]:not([data-mpw-sblur-off]) [class*="sidebarCol"]:not([data-sidebar-right-panel]):not([data-dockkit-strip]),
-html body[data-ds-dark-theme][data-mpw-rsblur="on"] [data-sidebar-right-panel],
-html body[data-ds-dark-theme][data-mpw-rsblur="on"] [data-dockkit-pane],
-html body[data-ds-dark-theme][data-mpw-rsblur="on"] [data-dockkit-strip],
-html body[data-ds-dark-theme][data-mpw-rsblur="on"] [data-dockkit-surface] {
+html body[data-ds-dark-theme][data-mpw-rsblur="on"] [data-mpw-rs-surface],
+html body[data-ds-dark-theme][data-mpw-rsblur="on"] [data-mpw-rs-surface][data-dockkit-pane],
+html body[data-ds-dark-theme][data-mpw-rsblur="on"] [data-mpw-rs-surface][data-dockkit-strip],
+html body[data-ds-dark-theme][data-mpw-rsblur="on"] [data-mpw-rs-surface][data-dockkit-surface] {
 	background-color: var(--mpw-surface-rs-dock-dark) !important;
 	color: var(--dsw-alias-label-primary, var(--dsw-alias-text-primary, inherit));
 }
@@ -18775,11 +18860,16 @@ svg.mpw_navIconImg { background: none; border: 0; border-radius: 0; color: inher
    描边一律交还宿主（下方 hover/悬浮块里的 border-bottom-color 兜底保持不变）。 */
 html body .wSkVaW_header[data-mpw-hdr-translucent],
 html body header[class*="_header_"][data-mpw-hdr-translucent] {
-	background-color: var(--mpw-hdr-frost-bg, rgba(255, 255, 255, 0.38)) !important;
+	/* ②(2026-10-04 真机："标题栏是白色底，左右栏却跟滑条走"）不许有写死的白回退：
+	   --mpw-hdr-frost-bg 一旦没写到（历史路径/时序竞态），旧写法就掉回 rgba(255,255,255,.38)
+	   ⇒ 标题栏看起来永远是白的、与「界面透明度」无关。回退到同一枚表面 token
+	   （= 宿主底色 × 表面不透明度，与左栏/右栏同一套模型）⇒ 三块构造逐字一致。
+	   注意：CSS 模板里的注释不许出现反引号（会截断模板串，本仓踩过三次）。 */
+	background-color: var(--mpw-hdr-frost-bg, var(--mpw-surface-frost-top)) !important;
 }
 html body[data-ds-dark-theme] .wSkVaW_header[data-mpw-hdr-translucent],
 html body[data-ds-dark-theme] header[class*="_header_"][data-mpw-hdr-translucent] {
-	background-color: var(--mpw-hdr-frost-bg, rgba(18, 22, 30, 0.45)) !important;
+	background-color: var(--mpw-hdr-frost-bg, var(--mpw-surface-frost-top)) !important;
 }
 /* ②(2026-09-16 视觉回归修复) 标题栏磨砂"元素层"（.mpw-hdrFrost，由 JS 注入）的**层叠与托底**规则。
    为什么必须有这三条（真根因链）：
@@ -24547,6 +24637,10 @@ body[data-mpw-modal] [role="dialog"] {
 			mpwTrace('apply:start', { hasReact: !!react, hasReactDOM: !!ReactDOM, hasClient: !!ReactDOMClient });
 			if (globalThis.__mpwAppliedOnce) { try { console.warn("[dsh-mpkg-wallpaper] apply 重复调用已忽略"); } catch {} ; mpwTrace('apply:skip', { reason: 'already applied' }); return }
 			globalThis.__mpwAppliedOnce = 1;
+			/* ①(P1A 对照组 2026-10-03) 测量开关：URL 加 ?mpwperf=off ⇒ 本次**完全不装** CSS/observer/壁纸
+			   （apply 直接 return；与探针的"页内中性化"同口径，给动画/渲染开销做 A/B）。
+			   登记：docs/DIAGNOSTICS.md。 */
+			try { if (new URLSearchParams(location.search).get("mpwperf") === "off") { try { console.warn("[dsh-mpkg-wallpaper] ?mpwperf=off ⇒ 本次不装 CSS/observer（测量对照档）") } catch (e) {} ; mpwTrace('apply:skip', { reason: 'mpwperf=off' }); return } } catch (e) {}
 			try {
 				pluginCtx = ctx;
 				applyInner(ctx);
@@ -24565,6 +24659,29 @@ body[data-mpw-modal] [role="dialog"] {
 		// role=dialog（如设置面板，它在侧边栏 footArea 里）。
 		let sblurObserver = null;
 		let sblurRecheckTimer = 0;   // ⑥ 延迟重算的合并句柄（动画期间不堆积定时器）
+		/* ①(P1B 2026-10-03) 全文档扫描类重活的**共享闸门**（读数：tools/sidebar-anim-probe 左栏收起动画
+		   期间 插件开 p95=66.5ms / >50ms 空档 6 个 vs 页内中性化 32.6ms / 0 个；MO 回调自身仅 1-6ms
+		   ⇒ 卡顿主体在观察器调度的后续全文档扫描 + 强制布局）。口径：document.getAnimations() 有
+		   running 就跳过本轮重活，登记补跑；400ms 定时器统一补跑一次，不会漏收尾状态。
+		   getAnimations 只读动画表、不触发布局，闸门本身廉价。 */
+		let mpwHeavyRecheckTimer = 0;
+		const mpwHeavyPending = new Map();
+		function mpwHeavyAnimRunning() {
+			try { return !!(document.getAnimations && document.getAnimations().length) } catch (e) { return false }
+		}
+		function mpwHeavyGate(name, fn) {
+			if (!mpwHeavyAnimRunning()) return true;
+			mpwHeavyPending.set(name, fn);
+			if (!mpwHeavyRecheckTimer) {
+				mpwHeavyRecheckTimer = setTimeout(() => {
+					mpwHeavyRecheckTimer = 0;
+					const jobs = Array.from(mpwHeavyPending.values());
+					mpwHeavyPending.clear();
+					for (const j of jobs) { try { j() } catch (e) {} }
+				}, 400);
+			}
+			return false;
+		}
 		function setupSblurObserver() {
 			if (sblurObserver !== null) return;
 			const check = () => {
@@ -24626,7 +24743,24 @@ body[data-mpw-modal] [role="dialog"] {
 				sblurRecheckTimer = setTimeout(() => { sblurRecheckTimer = 0; check(); }, 300);
 			};
 			try {
-				sblurObserver = new MutationObserver(() => { check(); recheck(); });
+				/* ①(P1B) 旧写法每批突变**同步**跑 check()（querySelectorAll + getBoundingClientRect
+				   强制布局）⇒ 收起动画每帧一次全量扫描。改 rAF 帧内合并 + 闸门（动画期间跳过、
+				   结束补跑一次）。 */
+				let sbraf = 0;
+				const sbrun = () => {
+					sbraf = 0;
+					try {
+					if (document.body && document.body.hasAttribute
+						&& (document.body.hasAttribute("data-dsh-sidebar-dragging") || document.body.hasAttribute("data-dragging"))) return;
+					if (!mpwHeavyGate("sblur", sbrun)) return;
+					check();
+					} catch (e) {}
+				};
+				sblurObserver = new MutationObserver(() => {
+					if (sbraf) return;
+					try { sbraf = (typeof requestAnimationFrame === "function") ? requestAnimationFrame(sbrun) : setTimeout(sbrun, 16); }
+					catch (e) { sbrun(); }
+				});
 				sblurObserver.observe(document.body, { childList: true, subtree: true });
 			} catch { sblurObserver = null; }
 			// 窗口尺寸变化会让"近全屏"阈值与面板 rect 都变（父对话的真机判据就带视口切换）⇒ 一并重算
@@ -24694,6 +24828,155 @@ body[data-mpw-modal] [role="dialog"] {
 				} catch (e) {}
 			}
 		}
+		/* ②(2026-10-04 真机："右侧边栏比左栏/标题栏更白"）**嵌套表面只画最外层**：
+		   右栏/dock 家族是互相嵌套的（真机读数：两个命中元素的 rect 只差 1px），把同一枚半透明表面色
+		   刷在两层上 ⇒ 合成不透明度 1-(1-a)²（a=0.55 时 0.80）≈ 一块近白板；左栏只有一个匹配元素，
+		   于是"左栏灰、右栏白"。这里按**结构**（有没有同样命中的祖先）给最外层打
+		   `data-mpw-rs-surface`，CSS 只认这个标记（与 `data-mpw-holds-layer` 同一手法）。
+		   幂等、无布局读取（只用 matches/parentElement），可随突变跑。 */
+		const MPW_RS_FAMILY = '[data-sidebar-right-panel], [data-dockkit-pane], [data-dockkit-strip], [data-dockkit-surface], [data-dockkit-float], [data-sidebar-right-float-host], [class*="P3OORG_panel"]';
+		function mpwTagSurfaceOuter() {
+			try {
+				const all = Array.from(document.querySelectorAll(MPW_RS_FAMILY));
+				if (!all.length) return 0;
+				const set = new Set(all);
+				const isDock = (el) => { try { return el.matches('[data-dockkit-pane], [data-dockkit-strip], [data-dockkit-surface], [data-dockkit-float]') } catch (e) { return false } };
+				const hasMatchedAncestor = (el) => {
+					for (let p = el.parentElement, i = 0; p && i < 40; p = p.parentElement, i++) { if (set.has(p)) return true }
+					return false;
+				};
+				/* 同一片视觉区域**只许留一个**被刷表面的元素。优先级（真机结构）：
+				   ① 命中的 DSH 右栏面板（`[data-sidebar-right-panel]` / `[class*="P3OORG_panel"]`）——它是用户看到的那块；
+				   ② 没有面板时，dock 家族里"没有命中祖先"的那些（better-sidebar 独立 dock 布局）；
+				   ③ 兜底：全部"没有命中祖先"的（老布局）。
+				   为什么不能只按"有没有命中祖先"：真机里右栏面板与它的内层 `_surface_*` **同时带**
+				   `data-sidebar-right-panel` / `data-dockkit-surface`，两层 55% 叠起来 ≈ 80% ⇒ 用户看到的"更白"。 */
+				const outermost = all.filter((el) => !hasMatchedAncestor(el));
+				const panelsOuter = outermost.filter((el) => { try { return el.matches('[data-sidebar-right-panel], [class*="P3OORG_panel"]') } catch (e) { return false } });
+				let want = panelsOuter.length ? panelsOuter : outermost.filter((el) => !isDock(el));
+				if (!want.length) want = outermost;
+				const wantSet = new Set(want);
+				let changed = 0;
+				for (const el of all) {
+					const should = wantSet.has(el);
+					const has = el.hasAttribute("data-mpw-rs-surface");
+					if (should && !has) { try { el.setAttribute("data-mpw-rs-surface", ""); changed++ } catch {} }
+					else if (!should && has) { try { el.removeAttribute("data-mpw-rs-surface"); changed++ } catch {} }
+				}
+				return changed;
+			} catch (e) { return 0 }
+		}
+
+		function mpwTagPopoverBg() {
+			let list = null;
+			try { list = document.querySelectorAll(MPW_POP_TAG_SEL); } catch (e) { return; }
+			if (!list) return;
+			for (let i = 0; i < list.length; i++) {
+				const el = list[i];
+				let need = false;
+				try {
+					const cls = (typeof el.className === "string") ? el.className : "";
+					if (!MPW_POP_TAG_NOT.test(cls)) {
+						const cs = getComputedStyle(el);
+						if (cs && cs.display !== "none" && cs.visibility !== "hidden"
+							&& /blur\(/.test(String(cs.backdropFilter || cs.webkitBackdropFilter || ""))) {
+							const a = mpwColorAlpha(cs.backgroundColor);
+							if (a < 0.05) need = !mpwPopHasPaintedAncestor(el);
+							else if (a >= 0.999) need = mpwPopIsFloating(el);
+						}
+					}
+				} catch (e) { need = false; }
+				try {
+					if (need) { if (!el.hasAttribute("data-mpw-pop-bg")) el.setAttribute("data-mpw-pop-bg", ""); }
+					else if (el.hasAttribute("data-mpw-pop-bg")) el.removeAttribute("data-mpw-pop-bg");
+				} catch (e) {}
+			}
+		}
+		/* ②(2026-10-04 真机："右侧边栏比左栏/标题栏更白"）**嵌套表面只画最外层**：
+		   右栏/dock 家族是互相嵌套的（真机读数：两个命中元素的 rect 只差 1px），把同一枚半透明表面色
+		   刷在两层上 ⇒ 合成不透明度 1-(1-a)²（a=0.55 时 0.80）≈ 一块近白板；左栏只有一个匹配元素，
+		   于是"左栏灰、右栏白"。这里按**结构**（有没有同样命中的祖先）给最外层打
+		   `data-mpw-rs-surface`，CSS 只认这个标记（与 `data-mpw-holds-layer` 同一手法）。
+		   幂等、无布局读取（只用 matches/parentElement），可随突变跑。 */
+				function mpwTagSurfaceOuter() {
+			try {
+				const all = Array.from(document.querySelectorAll(MPW_RS_FAMILY));
+				if (!all.length) return 0;
+				const set = new Set(all);
+				/* 真机读数：DSH 右栏面板与 dockkit 面板/标签条**互相重叠**（rect 只差 1~2px）却不在同一条
+				   祖先链上 ⇒ 只按"有没有命中祖先"判不出重叠，两层 55% 会合成 ~80%（用户看到的"更白"）。
+				   判据：DSH 自己的右栏面板在场时，dock 子件一律不刷（它们显示的就是那块面板的表面）；
+				   只有"没有右栏面板、只有 dock"的布局（better-sidebar 底部工作台等）才由 dock 自己承担。 */
+				const panel = document.querySelector('[data-sidebar-right-panel]');
+				const isDock = (el) => { try { return el.matches('[data-dockkit-pane], [data-dockkit-strip], [data-dockkit-surface], [data-dockkit-float]') } catch (e) { return false } };
+				let changed = 0;
+				for (const el of all) {
+					let inner = false;
+					for (let p = el.parentElement, i = 0; p && i < 40; p = p.parentElement, i++) { if (set.has(p)) { inner = true; break } }
+					const coveredByPanel = !!(panel && panel !== el && isDock(el));
+					const want = !inner && !coveredByPanel;
+					const has = el.hasAttribute("data-mpw-rs-surface");
+					if (want && !has) { try { el.setAttribute("data-mpw-rs-surface", ""); changed++ } catch {} }
+					else if (!want && has) { try { el.removeAttribute("data-mpw-rs-surface"); changed++ } catch {} }
+				}
+				return changed;
+			} catch (e) { return 0 }
+		}
+
+		/* ①(P3 修复 2026-10-03) 弹层玻璃的 backdrop root 被截断 ⇒ 有半透明、没模糊。
+		   读数与机制（docs/POPOVER-BLUR.md）：挂在宿主输入框卡片（uV2eYG_card，backdrop-filter:
+		   blur(14px)）子树里的弹层，其 backdrop root 被卡片截断 ⇒ 弹层自己的 blur(11px) 只能采样
+		   卡片内部 = 看不出模糊；挂在 body 下的模型选择器正常。实验定案：把表面移出祖先链即恢复
+		   （React 管的 DOM 不许 reparent）；宿主规则带 !important ⇒ inline 覆盖无效，**CSSOM 注入
+		   同特异性更晚的 !important 规则**有效且可逆。
+		   修法：只扫已打 `data-mpw-pop-bg` 的弹层表面（我们的玻璃只刷在那里），沿祖先链找**第一个**
+		   带 blur 的截断祖先，给它打 `data-mpw-pop-untrunc` 属性 + 一条静态 !important 规则
+		   （`[data-mpw-pop-untrunc] { backdrop-filter: none !important; }`）——只在弹层开着期间生效，
+		   弹层关闭（无已标记表面）即摘属性、撤规则元素，宿主逐字还原。代价：属性表 + 一次
+		   querySelectorAll，挂在 prun（已 rAF 合并 + mpwHeavyGate 闸门）里，不开新观察器。 */
+		let popUntruncStyleEl = null;
+		function mpwPopUntruncStyle() {
+			if (!popUntruncStyleEl || popUntruncStyleEl.isConnected === false) {
+				popUntruncStyleEl = document.createElement("style");
+				popUntruncStyleEl.setAttribute("data-plugin", "dsh-mpkg-wallpaper");
+				popUntruncStyleEl.setAttribute("data-mpw-pop-untrunc-style", "");
+				popUntruncStyleEl.textContent = "[data-mpw-pop-untrunc] { backdrop-filter: none !important; -webkit-backdrop-filter: none !important; }";
+				(document.head || document.documentElement).appendChild(popUntruncStyleEl);
+			}
+			return popUntruncStyleEl;
+		}
+		function mpwPopUntruncSync() {
+			try {
+				const surfaces = document.querySelectorAll("[data-mpw-pop-bg]");
+				const targets = new Set();
+				for (let i = 0; i < surfaces.length; i++) {
+					const el = surfaces[i];
+					let cs = null;
+					try { cs = getComputedStyle(el) } catch (e) {}
+					/* 硬前提（与 mpwTagPopoverBg 同口径）：我们真的给了模糊才值得摘祖先的截断 */
+					if (!cs || !cs.backdropFilter || String(cs.backdropFilter).indexOf("blur") < 0) continue;
+					for (let p = el.parentElement, n = 0; p && p !== document.body && p !== document.documentElement && n < 12; p = p.parentElement, n++) {
+						let acs = null;
+						try { acs = getComputedStyle(p) } catch (e) { break }
+						if (acs && acs.backdropFilter && acs.backdropFilter !== "none" && String(acs.backdropFilter).indexOf("blur") >= 0) { targets.add(p); break }
+					}
+				}
+				const stale = document.querySelectorAll("[data-mpw-pop-untrunc]");
+				for (let i = 0; i < stale.length; i++) { const el = stale[i]; if (!targets.has(el)) { try { el.removeAttribute("data-mpw-pop-untrunc") } catch (e) {} } }
+				for (const el of targets) { if (!el.hasAttribute("data-mpw-pop-untrunc")) { try { el.setAttribute("data-mpw-pop-untrunc", "") } catch (e) {} } }
+				if (targets.size) mpwPopUntruncStyle();
+				else if (popUntruncStyleEl && popUntruncStyleEl.parentElement) { try { popUntruncStyleEl.remove() } catch (e) {} popUntruncStyleEl = null; }
+				return targets.size;
+			} catch (e) { return 0 }
+		}
+		/* ①(P3) 判据出口（tools/popover-untrunc-test.mjs 直接调 sync 断言 打标/还原/硬前提/首截断者）。 */
+		try {
+			globalThis.__mpwPopUntruncTest = {
+				sync: () => mpwPopUntruncSync(),
+				stylePresent: () => !!(popUntruncStyleEl && popUntruncStyleEl.parentElement),
+			};
+		} catch (e) {}
+
 		function setupPopTagWatch() {
 			if (popTagWatch !== null) return;
 			let praf = 0;
@@ -24703,7 +24986,16 @@ body[data-mpw-modal] [role="dialog"] {
 					// 左栏收起/展开与拖拽期间宿主每帧改 DOM：跳过（收尾还会再来一次）
 					if (document.body && document.body.hasAttribute
 						&& (document.body.hasAttribute("data-dsh-sidebar-dragging") || document.body.hasAttribute("data-dragging"))) return;
+					/* ①(P1B) 动画期间跳过全文档弹层扫描（结束补跑一次） */
+					if (!mpwHeavyGate("popTag", prun)) return;
 					mpwTagPopoverBg();
+					/* ②(2026-10-04) 右栏/dock 的"只留最外层"标记必须**跟着 DOM 走**：右栏面板是
+					   用户打开后才挂载的，apply 那一刻它还不存在 ⇒ 只按一次会把 dock 错标成表面，
+					   之后面板出现就变成两层（真机读数：dockPane/dockStrip 仍是 0.55）。
+					   这里与弹层标记共用同一个 rAF 合并的入口（要素很少，代价可忽略）。 */
+					try { mpwTagSurfaceOuter(); } catch (e) {}
+					/* ①(P3) 弹层开着 ⇒ 摘截断祖先的 blur；关了 ⇒ 还原（同一入口，随突变重算） */
+					try { mpwPopUntruncSync(); } catch (e) {}
 				} catch (e) {}
 			};
 			try {
@@ -24715,6 +25007,7 @@ body[data-mpw-modal] [role="dialog"] {
 				popTagWatch.observe(document.body, { childList: true, subtree: true });
 			} catch { popTagWatch = null; }
 			mpwTagPopoverBg();
+			try { mpwPopUntruncSync(); } catch (e) {}
 		}
 
 		// ①(新) 标题栏 backdrop blur 摘除：G 块给 header 加 blur(unifyAmount)（聊天区
@@ -24757,6 +25050,8 @@ body[data-mpw-modal] [role="dialog"] {
 					try {
 						if (document.body && document.body.hasAttribute
 							&& (document.body.hasAttribute("data-dsh-sidebar-dragging") || document.body.hasAttribute("data-dragging"))) return;
+						/* ①(P1B) 动画期间跳过（check 里有 querySelectorAll + getBoundingClientRect 强制布局） */
+						if (!mpwHeavyGate("hdrBlur", hrun)) return;
 						check();
 					} catch (e) {}
 				};
@@ -24770,6 +25065,22 @@ body[data-mpw-modal] [role="dialog"] {
 			check();
 		}
 
+		/* ①(P1B) 闸门的判据出口（tools/anim-guard-test.mjs 直接断言：动画在跑 ⇒ 拦下 + 登记 + 定时器就位；
+		   动画停 ⇒ 补跑执行、账目清空）。 */
+		try {
+			globalThis.__mpwHeavyTest = {
+				state: () => ({ pending: Array.from(mpwHeavyPending.keys()), timer: !!mpwHeavyRecheckTimer }),
+				gate: (name, fn) => mpwHeavyGate(name, fn),
+				flushNow: () => {
+					if (mpwHeavyRecheckTimer) { try { clearTimeout(mpwHeavyRecheckTimer) } catch (e) {} mpwHeavyRecheckTimer = 0; }
+					const jobs = Array.from(mpwHeavyPending.values());
+					mpwHeavyPending.clear();
+					for (const j of jobs) { try { j() } catch (e) {} }
+					return jobs.length;
+				},
+			};
+		} catch (e) {}
+
 		// ⑲(修正) Aqua 主题切换监听：深色/浅色切换时重算遮罩色与自适应文字色
 		//（用户实测：aquaInk 开时切换主题，文字色卡在旧主题——黑字黑底/白字白底看不清）。
 		let aquaThemeWatch = null;

package/lib/index.js

@@ -791,6 +791,12 @@ const FFMPEG_STATIC_SHA256 = {
   'ffmpeg-darwin-x64': 'cfe20936c83ecf5d68e424b87e8cc45b24dd6be81787810123bb964a0df686f9',
   'ffmpeg-darwin-arm64': 'a90e3db6a3fd35f6074b013f948b1aa45b31c6375489d39e572bea3f18336584',
 };
+// ①(F5 2026-10-03) 同源 ffmpeg-static b6.0 的 **ffprobe-\*** 资产（每平台一个，与 ffmpeg 资产同 tag 同命名规则）。
+//   逐平台**核实一个钉一个**（下载实测 sha256 后填入）；未钉平台 = ELF/PE/Mach-O 魔数 + 长度下限 +
+//   双镜像同源 + 下载时计算的 sha256（记进结果与台账）兜底。已核实：linux-arm64 49,946,640 B（本机实测可执行）。
+const FFPROBE_STATIC_SHA256 = {
+  'ffprobe-linux-arm64': '9c741c0dedaf503106732d819d7f9ecf1d991ca923cc688d3d52aa4d6d51222d',
+};
 // 单个转码任务的硬超时（覆盖编码全部尝试），可用 DSH_WE_TRANSCODE_TIMEOUT_MS 覆盖。
 const TRANSCODE_TIMEOUT_MS = Number(process.env.DSH_WE_TRANSCODE_TIMEOUT_MS) || 15 * 60 * 1000;
 const ALLOWED_FPS = [24, 30, 48, 60];
@@ -1221,7 +1227,72 @@ function probeVideoInfo(filePath) {
       pixFmt: video.pix_fmt, colorRange: video.color_range, colorSpace: video.color_space,
       colorPrimaries: video.color_primaries, colorTransfer: video.color_transfer,
     }, headBytes(filePath, 64));
-    return (info.width > 0 && info.fps > 0) ? info : null;
+    if (info.width > 0 && info.fps > 0) { info.probeSource = 'ffprobe'; return info; }
+    return null;
+  } catch { return null; }
+}
+
+/** ①(F5 次选) `ffmpeg -hide_banner -i <file>` 的 stderr 解析（**纯函数**，测试可直接喂真实 stderr）。
+ *  背景：ffprobe 缺席的机器（自带下载只装 ffmpeg 本体、系统只装了 ffmpeg）上可播性闸门整体失效
+ *  （probeVideoInfo → null ⇒ playable=null ⇒ 永远走"能转就转"）。ffmpeg 对 `-i` 无输出文件会
+ *  立即退出 1 并把流信息打到 stderr —— 不解码、毫秒级。解析自真实输出形状：
+ *    Input #0, matroska,webm, from 'x.mkv':
+ *    Duration: 00:01:30.00, start: 0.000000, bitrate: 1000 kb/s
+ *    Stream #0:0 ... : Video: h264 (High), yuv420p(progressive), 3840x2160 [SAR 1:1 DAR 16:9], 60 fps, 60 tbr
+ *    Stream #0:1 ... : Audio: opus, 48000 Hz, stereo, fltp
+ *  色彩元数据（color_range/space/primaries/transfer）这条路径拿不到 ⇒ 留空（= 不知道，不猜）。
+ *  返回 buildProbeInfo 的 meta 形状；解析不出视频流 ⇒ { video:'' }（调用方按失败处理）。 */
+function parseFfmpegStderrMeta(text) {
+  const s = String(text || '');
+  const meta = { container: '', duration: 0, size: 0, video: '', videoProfile: '', audio: '', audioProfile: '', width: 0, height: 0, rFrameRate: '', avgFrameRate: '', pixFmt: '', colorRange: '', colorSpace: '', colorPrimaries: '', colorTransfer: '' };
+  const inC = /Input #\d+,\s*([^,\n]+(?:,[^,\n]+)*?),\s*from/.exec(s);
+  if (inC) meta.container = inC[1].trim();
+  const dur = /Duration:\s*(\d+):(\d+):(\d+(?:\.\d+)?)/.exec(s);
+  if (dur) meta.duration = (Number(dur[1]) * 3600 + Number(dur[2]) * 60 + Number(dur[3])) || 0;
+  const vSeg = /: Video: ([^\n]+)/.exec(s);
+  if (vSeg) {
+    const line = vSeg[1];
+    const head = /^\s*([a-z0-9_]+)(?:\s*\(([^)]*)\))?/i.exec(line);
+    if (head) {
+      meta.video = head[1];
+      // `(High)` 是 profile；`(built-in)`/`(unspecified)` 这类不是
+      const prof = head[2] && !/built-in|unspecified|none/i.test(head[2]) ? head[2] : '';
+      if (prof) meta.videoProfile = prof;
+    }
+    const pix = /\b(yu[via][a-z0-9_]*|nv1[26]|nv24|p01[016]|gbrp[a-z0-9_]*|gray[0-9a-z_]*|rgb[a-z0-9_]*)(?:le|be)?\b/i.exec(line);
+    if (pix) meta.pixFmt = pix[1];
+    const dim = /\b(\d{2,5})x(\d{1,5})\b/.exec(line);
+    if (dim) { meta.width = Number(dim[1]) || 0; meta.height = Number(dim[2]) || 0; }
+    const fps = /([\d.]+)\s*fps/.exec(line) || /([\d.]+)\s*tbr/.exec(line);
+    if (fps) { meta.rFrameRate = fps[1] + '/1'; meta.avgFrameRate = fps[1] + '/1'; }
+  }
+  const aSeg = /: Audio: ([^\n]+)/.exec(s);
+  if (aSeg) {
+    const head = /^\s*([a-z0-9_]+)(?:\s*\(([^)]*)\))?/i.exec(aSeg[1]);
+    if (head) { meta.audio = head[1]; if (head[2]) meta.audioProfile = head[2]; }
+  }
+  return meta;
+}
+/** ①(F5 次选) ffprobe 探测失败/缺席时用 `ffmpeg -hide_banner -i` 兜底探测（失败返回 null，不抛错）。
+ *  成功的 info 带 `probeSource:'ffmpeg-i'`（ffprobe 路径成功 = `'ffprobe'`）——台账字段，
+ *  客户端/判据不读它、只用于诊断上报区分"这个答案是哪条探测路给的"。 */
+function probeVideoInfoFfmpegI(filePath) {
+  try {
+    const ff = (resolveFfmpeg() || {}).path || 'ffmpeg';
+    let err = '';
+    try {
+      execFileSync(ff, ['-hide_banner', '-i', filePath], { encoding: 'utf8', timeout: 15000, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
+      return null;   // 有输出文件才不会走到这；真走到了说明行为和预期不符，不猜
+    } catch (e) {
+      err = String((e && (e.stderr || e.stdout)) || '');
+      if (!err) return null;
+    }
+    const meta = parseFfmpegStderrMeta(err);
+    if (!meta.video) return null;
+    const info = buildProbeInfo(meta, headBytes(filePath, 64));
+    if (!(info.width > 0 && info.fps > 0)) return null;
+    info.probeSource = 'ffmpeg-i';
+    return info;
   } catch { return null; }
 }
 
@@ -1243,10 +1314,15 @@ function getVideoProbe(src) {
     let info = null;
     if (src.type === 'file') {
       info = probeVideoInfo(srcPath);
+      // ①(F5) ffprobe 缺席/失败的兜底：ffmpeg -i 的 stderr 解析（playable=null ⇒ 闸门失效的机器上补一条活路）
+      if (!info) info = probeVideoInfoFfmpegI(srcPath);
     } else {
       try {
         const mat = materializeSource(src, transcodeCacheDir());
-        try { info = probeVideoInfo(mat.file); } finally { if (mat.cleanup) mat.cleanup(); }
+        try {
+          info = probeVideoInfo(mat.file);
+          if (!info) info = probeVideoInfoFfmpegI(mat.file);
+        } finally { if (mat.cleanup) mat.cleanup(); }
       } catch { info = null; }
     }
     if (TRANSCODE_PROBE_CACHE.size >= TRANSCODE_PROBE_CACHE_MAX) TRANSCODE_PROBE_CACHE.clear();
@@ -1263,6 +1339,15 @@ function ffmpegDataDir() {
 function ffmpegExeName() {
   return process.platform === 'win32' ? 'ffmpeg.exe' : 'ffmpeg';
 }
+/** ①(F5) ffprobe 的落盘文件名与静态资产名（与 ffmpeg 同源同版本：ffmpeg-static b6.0 每平台
+ *  除 ffmpeg-\* 外还发布 ffprobe-\*）。没有 ⇒ 下载链跳过 ffprobe（不阻塞 ffmpeg 本体）。 */
+function ffprobeExeName() {
+  return process.platform === 'win32' ? 'ffprobe.exe' : 'ffprobe';
+}
+function ffprobeAssetName() {
+  const m = ffmpegAssetName();
+  return m ? m.replace(/^ffmpeg-/, 'ffprobe-') : null;
+}
 function transcodeCacheDir() {
   const dir = join(DATA_DIR, 'transcodes');
   try { mkdirSync(dir, { recursive: true }); } catch { /* 忽略 */ }
@@ -1808,9 +1893,10 @@ function resolveFfmpegSource() {
   return null;
 }
 
-/** 流式下载单个 URL 到 .part 文件：校验 大小>20MB + 魔数(MZ/ELF/Mach-O) + sha256。
- *  返回 { total, sha256 }；任一校验失败抛错。 */
-async function downloadFfmpegToFile(url, tmp, signal) {
+/** 流式下载单个 URL 到 .part 文件：校验 大小>minBytes(默认20MB) + 魔数(MZ/ELF/Mach-O) + sha256。
+ *  返回 { total, sha256 }；任一校验失败抛错。①(F5) ffprobe 比 ffmpeg 小 ⇒ minBytes 可传小一些。 */
+async function downloadFfmpegToFile(url, tmp, signal, opts) {
+  const minBytes = (opts && opts.minBytes) || 20 * 1024 * 1024;
   const res = await fetch(url, { redirect: 'follow', signal, headers: { 'User-Agent': 'dsh-mpkg-wallpaper' } });
   if (!res.ok) throw new Error('HTTP ' + res.status + ' @ ' + url);
   if (!res.body) throw new Error('no response body @ ' + url);
@@ -1835,7 +1921,7 @@ async function downloadFfmpegToFile(url, tmp, signal) {
   } finally {
     closeSync(fd);
   }
-  if (total < 20 * 1024 * 1024) throw new Error('implausible size ' + total + ' @ ' + url);
+  if (total < minBytes) throw new Error('implausible size ' + total + ' @ ' + url);
   const head = Buffer.alloc(8);
   try {
     const rfd = openSync(tmp, 'r');
@@ -1849,10 +1935,17 @@ async function downloadFfmpegToFile(url, tmp, signal) {
 }
 
 /** 下载当前平台的 ffmpeg-static 单文件到 DATA_DIR/ffmpeg/ffmpeg[.exe]（用户显式触发）。
- *  单飞防并发；校验通过后原子 rename。成功返回 { path, size }；失败抛错。 */
+ *  单飞防并发；校验通过后原子 rename。成功返回 { path, size }；失败抛错。
+ *  ①(F5) 附带 **ffprobe**：同源同版本同平台（ffmpeg-static 同 tag 的 ffprobe-\* 资产），
+ *  sha256（钉值命中则强校验）+ 长度下限 + 魔数逐条校验后落 `DATA_DIR/ffmpeg/ffprobe[.exe]`。
+ *  **ffprobe 失败不影响 ffmpeg 本体**（只记 lastFfprobeDownloadError；resolveFfprobe 的
+ *  sibling 目录会因这次落盘开始命中 ⇒ 可播性闸门在这些机器上真的生效）。 */
 async function downloadFfmpeg() {
   const target = join(ffmpegDataDir(), ffmpegExeName());
-  if (existsSync(target)) return { path: target, size: statSync(target).size };
+  if (existsSync(target)) {
+    const fp = await downloadFfprobe().catch((e) => ({ ok: false, error: String(e && e.message || e) }));
+    return { path: target, size: statSync(target).size, ffprobe: fp };
+  }
   const asset = ffmpegAssetName();
   if (!asset) throw new Error('unsupported platform ' + process.platform + '/' + process.arch);
   if (typeof fetch !== 'function') throw new Error('fetch unavailable (Node < 18?)');
@@ -1873,7 +1966,10 @@ async function downloadFfmpeg() {
         renameSync(tmp, target); // 原子写入：校验全过才就位
         lastFfmpegDownloadError = null;
         ffmpegDownloadProgress = null;
-        return { path: target, size: r.total };
+        // ①(F5) ffmpeg 就位后顺手补 ffprobe（失败不影响本次下载的成功语义）
+        let fp = null;
+        try { fp = await downloadFfprobe(); } catch (e) { fp = { ok: false, error: String(e && e.message || e) }; }
+        return { path: target, size: r.total, ffprobe: fp };
       } catch (err) {
         lastErr = err;
         try { unlinkSync(tmp); } catch { /* 忽略 */ }
@@ -1888,6 +1984,49 @@ async function downloadFfmpeg() {
   return ffmpegDownloadPromise;
 }
 
+let ffprobeDownloadPromise = null;    // ①(F5) ffprobe 下载单飞（与 ffmpeg 分开，互不阻塞）
+let lastFfprobeDownloadError = null;
+/** ①(F5) 下载当前平台的 ffprobe 静态二进制到 DATA_DIR/ffmpeg/ffprobe[.exe]。
+ *  校验：魔数(MZ/ELF/Mach-O) + 长度下限(20MB，arm64 实测 49.9MB) + sha256（钉值命中则强校验，
+ *  否则把算得的 sha256 记进返回值/台账）。成功后重置 resolveFfprobe 的进程内记忆化
+ *  （此前 resolve 过的 null 不该盖住刚落盘的二进制；desktop-compat C2 的"两次调用同对象"语义不变）。
+ *  返回 { ok:true, path, size, sha256, skipped? }；失败抛错（调用方决定要不要兜）。 */
+async function downloadFfprobe() {
+  const target = join(ffmpegDataDir(), ffprobeExeName());
+  if (existsSync(target)) return { ok: true, path: target, size: statSync(target).size, skipped: 'already-present' };
+  const asset = ffprobeAssetName();
+  if (!asset) throw new Error('unsupported platform ' + process.platform + '/' + process.arch + ' (ffprobe)');
+  if (typeof fetch !== 'function') throw new Error('fetch unavailable (Node < 18?)');
+  if (ffprobeDownloadPromise) return ffprobeDownloadPromise;
+  ffprobeDownloadPromise = (async () => {
+    const urls = ffmpegDownloadUrls(asset);
+    let lastErr = null;
+    for (const url of urls) {
+      const tmp = target + '.part' + Date.now();
+      const ctrl = new AbortController();
+      const timer = setTimeout(() => ctrl.abort(), 5 * 60 * 1000);
+      try {
+        const r = await downloadFfmpegToFile(url, tmp, ctrl.signal, { minBytes: 20 * 1024 * 1024 });
+        const want = FFPROBE_STATIC_SHA256[asset];
+        if (want && r.sha256 !== want) throw new Error('sha256 mismatch (want ' + want + ') @ ' + url);
+        if (process.platform !== 'win32') { try { chmodSync(tmp, 0o755); } catch { /* 忽略 */ } }
+        renameSync(tmp, target);
+        lastFfprobeDownloadError = null;
+        __ffprobeResolved = void 0;   // 记忆化失效：刚落盘的二进制要能被 resolveFfprobe 找到
+        return { ok: true, path: target, size: r.total, sha256: r.sha256, pinned: !!want };
+      } catch (err) {
+        lastErr = err;
+        try { unlinkSync(tmp); } catch { /* 忽略 */ }
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    lastFfprobeDownloadError = String(lastErr && lastErr.message || lastErr);
+    throw new Error('ffprobe download failed: ' + lastFfprobeDownloadError);
+  })().finally(() => { ffprobeDownloadPromise = null; });
+  return ffprobeDownloadPromise;
+}
+
 /** 在 mpkg 容器里挑视频条目：真视频文件（mp4/webm/mov）优先，其次含 ftyp 的视频纹理 tex。 */
 function pickMpkgVideoEntry(entries, filePath, dataStart) {
   const vid = entries.findIndex((e) => /\.(mp4|webm|mov)$/i.test(e.name));
@@ -4756,9 +4895,15 @@ function apply(ctx) {
         try {
           // ①(修正) 区分来源：env 显式 / 系统 PATH / 缓存静态。客户端据此显示「系统已装/缓存已装/未装」。
           const src = resolveFfmpegSource();
-          json(res, 200, { ok: true, found: !!src, source: src ? src.source : null, path: src ? src.path : null, version: src ? src.version : null });
+          // ①(F5) ffprobe 的在场读数（可播性闸门"真的生效"的前提；不改变任何既有字段）
+          const fp = (() => { try { return resolveFfprobe() } catch { return null } })();
+          const fpVersion = fp ? (() => { const v = ffmpegVersionOf(fp.path); return v ? v.version : null })() : null;
+          json(res, 200, {
+            ok: true, found: !!src, source: src ? src.source : null, path: src ? src.path : null, version: src ? src.version : null,
+            ffprobe: { found: !!fp, path: fp ? fp.path : null, version: fpVersion },
+          });
         } catch (err) {
-          json(res, 200, { ok: false, found: false, source: null, path: null, version: null, error: String(err && err.message || err) });
+          json(res, 200, { ok: false, found: false, source: null, path: null, version: null, ffprobe: { found: false, path: null, version: null }, error: String(err && err.message || err) });
         }
       },
     });
@@ -4774,8 +4919,14 @@ function apply(ctx) {
           if (existsSync(cached)) {
             try { unlinkSync(cached); } catch (e) { json(res, 500, { ok: false, error: String(e && e.message || e) }); return; }
           }
+          // ①(F5) 同目录的 ffprobe 缓存一并卸（下载链成对装 ⇒ 卸载也成对；系统 PATH/env 的不动）
+          const cachedFp = join(ffmpegDataDir(), ffprobeExeName());
+          let removedFp = null;
+          if (existsSync(cachedFp)) {
+            try { unlinkSync(cachedFp); removedFp = cachedFp; __ffprobeResolved = void 0; } catch { /* 不阻塞主二进制的卸载 */ }
+          }
           // 顺便清掉同目录残留（.part 下载碎片不在这里；仅清主二进制）
-          json(res, 200, { ok: true, removed: cached });
+          json(res, 200, { ok: true, removed: cached, removedFfprobe: removedFp });
         } catch (err) {
           json(res, 500, { ok: false, error: String(err && err.message || err) });
         }
@@ -4790,7 +4941,8 @@ function apply(ctx) {
         try {
           if ((req.method || 'GET').toUpperCase() !== 'POST') { json(res, 405, { ok: false, error: 'method' }); return; }
           const r = await downloadFfmpeg();
-          json(res, 200, { ok: true, path: r.path, size: r.size });
+          // ①(F5) 响应附带 ffprobe 侧下载结果（{ok,path,size,sha256?} 或 {ok:false,error}）；既有字段不变
+          json(res, 200, { ok: true, path: r.path, size: r.size, ffprobe: r.ffprobe || null });
         } catch (err) {
           json(res, 500, { ok: false, error: String(err && err.message || err) });
         }
@@ -5088,6 +5240,12 @@ export const __mpwTest = {
   // ①(2026-10-02 桌面端兼容) ffprobe 探测链的测试出口（tools/desktop-compat-test.mjs 直接调真实现）：
   //   env 分支只依赖 existsSync+isFile（不 spawn）⇒ 测试可用临时文件断言「env 覆盖生效」。
   resolveFfprobe, resolveFfmpeg,
+  // ①(F5 2026-10-03) ffprobe 资产/次选探测的测试出口（tools/ffprobe-provision-test.mjs 直接调真实现）：
+  //   下载走桩 HTTP 端点（DSH_WE_FFMPEG_URL 同款 env 覆盖）⇒ 断言落盘/校验失败不落盘；
+  //   次选探测喂真实 ffmpeg -i 的 stderr 形状；resetFfprobeMemo 给"下载后记忆化失效"做行为断言。
+  downloadFfprobe, downloadFfmpeg, ffprobeAssetName, ffprobeExeName, ffmpegDataDir,
+  parseFfmpegStderrMeta, probeVideoInfoFfmpegI,
+  resetFfprobeMemo: () => { __ffprobeResolved = void 0; },
   // ①(WP-1) 网页壁纸轮（存储 facade / 宿主音量 / CSP / 源级 URL 改写）的纯函数出口：
   //   `tools/web-wallpaper-test.mjs` 的 H/I/J 段直接调它们断言语义，K 段再走真路由端到端。
   //   **只读/纯函数**，不改变插件在宿主里的注册面（宿主只用 `apply`）。

package/lib/now-playing.js

@@ -1293,7 +1293,21 @@ function createNowPlaying(deps) {
     /** 一帧判据：写/撤 data-mpw-np-hidden + **让位判据**（①(NP-3)）。
      *  让位在**每一次**判据里都跑：挂载前（setEnabled 里单独一次）、挂载后（这里）都要判。
      *  规则：容器里出现非本插件、非宿主自有的占用者 ⇒ 撤下且**不重建**（等它走了再回来）。 */
+    /* ①(P1B) npFit 重排闸门：优先用 client.js 工厂作用域的 mpwHeavyGate（内联后作用域链可见）；
+       独立装载时用本地同语义兜底（动画在跑 ⇒ 推迟 400ms 补跑）。 */
+    const npFitGate = (typeof mpwHeavyGate === "function")
+      ? mpwHeavyGate
+      : function (name, fn) {
+          try { if (document.getAnimations && document.getAnimations().length) { setTimeout(fn, 400); return false } } catch (e) {}
+          return true;
+        };
     function evaluate() {
+        /* ①(P1B 2026-10-03) 收起/展开动画期间跳过重排（occupantNow/measureWidth/npFit 都是
+         getBoundingClientRect 类强制布局，宿主每帧改 DOM ⇒ 旧写法每帧一次）；400ms 后补跑
+         一次，返回上次 known hidden（调用方语义不变）。闸门主体在 client.js 工厂作用域
+         （mpwHeavyGate，内联进生成区后经作用域链可见）；本文件被**独立**装载时（now-playing-test
+         直载）用同语义本地兜底。 */
+      if (!npFitGate("npFit", evaluate)) return hidden;
       if (!container) {
         hidden = false;
         /* 没挂着时三种情况都要在这里补挂：①上一个占用者走了；②宿主侧栏后来才渲染出来；

package/package.json

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