dsh-mpkg-wallpaper 3.16.1 → 3.16.4

package/lib/client.js

@@ -6876,9 +6876,11 @@ function mpwThumbFail(el, why) {
 		/** ①(新) scene 内嵌视频探测（scene-video 快路径）：探测 URL 按 key 路由。
 		 *  返回 { has, mime }；网络错误/未找到视为无视频（回退静态帧）。 */
 		function sceneVideoCheckUrl(key) {
-			if (key && key.indexOf("library|") === 0) return HOST_URL + "/library-scene-video-check?ltoken=" + encodeURIComponent(key.slice(8));
+			// ①(2026-10-04) `has=1`：只要"有没有"（宿主走只读目录表+前缀的 verdict，不再为问一句提取整段视频）；
+			//   不带该参数时宿主保持旧行为（含 mime/size 与探测即落盘缓存）——旧路径判据因此逐位不变。
+			if (key && key.indexOf("library|") === 0) return HOST_URL + "/library-scene-video-check?has=1&ltoken=" + encodeURIComponent(key.slice(8));
 			const name = key && key.indexOf("custom|") === 0 ? key.slice(7) : "";
-			return HOST_URL + "/custom-scene-video-check?folder=" + encodeURIComponent(name);
+			return HOST_URL + "/custom-scene-video-check?has=1&folder=" + encodeURIComponent(name);
 		}
 		function checkSceneVideo(key) {
 			// ①(修正) 探测加 4s 超时：host 端首查需同步读包/落盘（可达 1-3s），
@@ -9390,7 +9392,21 @@ function mpwThumbFail(el, why) {
 				   宿主每帧都改 class/style，旧写法每帧同步跑一遍 applyFrostInline）。 */
 				let fraf = 0;
 				const frun = () => { fraf = 0; try { applyFrostInline(); } catch (e) {} };
-				frostObserver = new MutationObserver(() => {
+				/* ②(2026-10-05 真机采样定案："刷新/切子代理会话时标题栏的模糊会闪一下消失")
+				   采样读数：`t=2028 frost=false attr=false`、下一帧又回来 —— 宿主切换视图时**重建了 header
+				   元素**，我们插在 header 里的磨砂层随旧节点被卸载，而重建走的是 rAF 合并的慢路
+				   ⇒ 中间有 1~2 帧没有任何磨砂。修法：**新增节点**这一路同步重跑 `syncHeaderFrost()`
+				   （MutationObserver 回调是微任务，跑在绘制之前 ⇒ 那一帧就已经带上层），
+				   其余（class/style 变更）仍走 rAF 合并，避免动画期间每帧跑。 */
+				frostObserver = new MutationObserver((records) => {
+					let addedEl = false;
+					try {
+						for (const rec of (records || [])) {
+							for (const n2 of (rec.addedNodes || [])) { if (n2 && n2.nodeType === 1) { addedEl = true; break } }
+							if (addedEl) break;
+						}
+					} catch (e) { addedEl = true; }
+					if (addedEl) { try { frun(); } catch (e) {} return; }
 					if (fraf) return;
 					try { fraf = (typeof requestAnimationFrame === "function") ? requestAnimationFrame(frun) : setTimeout(frun, 16); }
 					catch (e) { frun(); }
@@ -17991,24 +18007,24 @@ ${unifyTakeover ? `
    现在接管真的做出来：这些表面与左栏**读同一套 token**（同色 + 同厚度 + 同半径），
    于是"整屏虚化程度 + 左侧边栏/标题栏透明度"一改，右栏/dock 一起变。
    位置在本块最后（与前文选择器同特异性时后者胜）⇒ 不需要额外的权重技巧。 */
-html body[data-mpw-unify] [data-sidebar-right-panel],
-html body[data-mpw-unify] [data-sidebar-right-float-host],
-html body[data-mpw-unify] [data-mpw-rs],
-html body[data-mpw-unify] [data-dockkit-pane],
-html body[data-mpw-unify] [data-dockkit-strip],
-html body[data-mpw-unify] [data-dockkit-surface],
-html body[data-mpw-unify] [data-dockkit-float] {
+html body[data-mpw-unify] [data-mpw-rs-surface],
+html body[data-mpw-unify] [data-mpw-rs-surface][data-sidebar-right-float-host],
+html body[data-mpw-unify] [data-mpw-rs-surface][data-mpw-rs],
+html body[data-mpw-unify] [data-mpw-rs-surface][data-dockkit-pane],
+html body[data-mpw-unify] [data-mpw-rs-surface][data-dockkit-strip],
+html body[data-mpw-unify] [data-mpw-rs-surface][data-dockkit-surface],
+html body[data-mpw-unify] [data-mpw-rs-surface][data-dockkit-float] {
 	-webkit-backdrop-filter: ${unifyBlurCss} !important;
 	backdrop-filter: ${unifyBlurCss} !important;
 	background-color: var(--mpw-unify-surface) !important;
 }
-html body[data-ds-dark-theme][data-mpw-unify] [data-sidebar-right-panel],
-html body[data-ds-dark-theme][data-mpw-unify] [data-sidebar-right-float-host],
-html body[data-ds-dark-theme][data-mpw-unify] [data-mpw-rs],
-html body[data-ds-dark-theme][data-mpw-unify] [data-dockkit-pane],
-html body[data-ds-dark-theme][data-mpw-unify] [data-dockkit-strip],
-html body[data-ds-dark-theme][data-mpw-unify] [data-dockkit-surface],
-html body[data-ds-dark-theme][data-mpw-unify] [data-dockkit-float] {
+html body[data-ds-dark-theme][data-mpw-unify] [data-mpw-rs-surface],
+html body[data-ds-dark-theme][data-mpw-unify] [data-mpw-rs-surface][data-sidebar-right-float-host],
+html body[data-ds-dark-theme][data-mpw-unify] [data-mpw-rs-surface][data-mpw-rs],
+html body[data-ds-dark-theme][data-mpw-unify] [data-mpw-rs-surface][data-dockkit-pane],
+html body[data-ds-dark-theme][data-mpw-unify] [data-mpw-rs-surface][data-dockkit-strip],
+html body[data-ds-dark-theme][data-mpw-unify] [data-mpw-rs-surface][data-dockkit-surface],
+html body[data-ds-dark-theme][data-mpw-unify] [data-mpw-rs-surface][data-dockkit-float] {
 	background-color: var(--mpw-unify-surface-dark) !important;
 }
 /* better-sidebar 的面板 / 底部工作台：**只跟雾色与厚度，不给 backdrop-filter**。
@@ -18077,6 +18093,9 @@ html body[data-mpw-sblur-off] [data-mpw-rs] {
 			tok("--mpw-pop-surface", mpwSurfaceColor(surfacePlan.left.base, popFallbackAlpha).replace(/[\d.]+%/, `calc(var(--mpw-pop-surface-alpha, ${popFallbackAlpha.toFixed(2)}) * 100%)`));
 			tok("--mpw-pop-surface-alpha", popFallbackAlpha.toFixed(2));
 			tok("--mpw-pop-surface-dark", `rgba(18, 22, 30, var(--mpw-pop-surface-alpha, ${popFallbackAlpha.toFixed(2)}))`);
+			/* ③(2026-10-05) C 类弹层（糊不到页面背后 ⇒ 做实在）专用的 88% 表面：**我们自己的 token**，
+			   不再借宿主 --dsw-specific-sidebar-fill（真机在侧栏作用域里它算出来是透明的 ⇒ 面板变透明）。 */
+			tok("--mpw-pop-trunc-surface", mpwSurfaceColor(surfacePlan.left.base, 0.88));
 			tok("--mpw-surface-pop-dark", `rgba(18, 22, 30, var(--mpw-pop-alpha, ${(popSurfaceAlpha / 100).toFixed(2)}))`);
 			// 弹层**表面**选择器（背景 + 模糊共用一份，避免两处写法漂移）。
 			// ③(关键收窄 2026-09-13) 只用 [class*="_menu"] 会连**非表面**一起命中：
@@ -18085,13 +18104,17 @@ html body[data-mpw-sblur-off] [data-mpw-rs] {
 			//   `._G5b-a_menuStatus`（说明文字）都含 "_menu" ——
 			//   给它们加 backdrop-filter 会在界面上糊出一块方块，加底色会糊出白块。
 			//   这里显式排除 anchor/icon/status/open/item/row/trigger/card 等非表面后缀。
-			const POP_NOT = `:not([role="menuitem"]):not([role="option"]):not([class*="Anchor"]):not([class*="anchor"]):not([class*="Icon"]):not([class*="icon"]):not([class*="Status"]):not([class*="status"]):not([class*="Open"]):not([class*="open"]):not([class*="_item"]):not([class*="Item"]):not([class*="_row"]):not([class*="Row"]):not([class*="_trigger"]):not([class*="Trigger"]):not([class*="_card"]):not([class*="Card"]):not([class*="_groupTitle"]):not([class*="_viewport"])`;
+			/* ③(2026-10-05) 末尾追加 `:not([data-mpw-pop-untrunc])`：被我们"去截断"的祖先
+			   （见 lib 里的 mpwPopUntruncApply）不再吃这套弹层表面规则 —— 否则我们自己的
+			   blur 规则会跟去截断规则互相压制（真机：加号菜单容器的 blur 是**我们自己**给的，
+			   特异性还比注入的去截断规则高，摘不掉 ⇒ 内层弹层照旧被截断）。 */
+			const POP_NOT = `:not([role="menuitem"]):not([role="option"]):not([class*="Anchor"]):not([class*="anchor"]):not([class*="Icon"]):not([class*="icon"]):not([class*="Status"]):not([class*="status"]):not([class*="Open"]):not([class*="open"]):not([class*="_item"]):not([class*="Item"]):not([class*="_row"]):not([class*="Row"]):not([class*="_trigger"]):not([class*="Trigger"]):not([class*="_card"]):not([class*="Card"]):not([class*="_groupTitle"]):not([class*="_viewport"]):not([data-mpw-pop-untrunc])`;
 			/* ①(2026-10-02 用户第 3 条⑥：上下文占用圆圈点开的框是**纯白**、没有玻璃感)
 			   它的真实结构是 div.JObwrW_panel[role="dialog"][aria-label="上下文已用"] ⇒ 既不在
 			   下面这串弹层选择器里（所以没有我们的底），又被"真弹层不做玻璃"那条按 role=dialog
 			   清掉了模糊 ⇒ 纯白。把它（以及同类小面板）纳入弹层表面集合。 */
 			const popSurfaceSel = `[role="menu"]${POP_NOT}, [role="listbox"]${POP_NOT}, [role="combobox"]${POP_NOT}, [data-dsh-surface]${POP_NOT}, [class*="_menu"]${POP_NOT}, [class*="_popover"]${POP_NOT}, [class*="_dropdown"]${POP_NOT}, [class*="_denseList"]${POP_NOT}, [class*="JObwrW_panel"]${POP_NOT}`;
-			const popTipSel = `[role="tooltip"], [role="alert"]`;
+			const popTipSel = `[role="tooltip"]:not([data-mpw-pop-untrunc]), [role="alert"]:not([data-mpw-pop-untrunc])`;
 			/* ①(2026-10-02 用户第 3 条：「把这个好用的模糊效果独立成 token，因为还有几个地方也要实现」)
 			   弹层表面 = **底色 + 模糊半径 + 圆角** 三件套，全部由这几枚 token 定义；任何弹层只要被
 			   下面的选择器命中，就自动同一套效果（不再各处写死 rgba/blur）。
@@ -18133,11 +18156,25 @@ ${popSurfaceSel} {
 html body [data-mpw-pop-bg] { background-color: var(--mpw-pop-surface) !important; }
 /* ②(2026-10-05) 弹层处在一个"自己有底的玻璃祖先"里面（backdrop root 被截断 ⇒ 我们糊不到页面背后）：
    与其"半透明却没模糊"（真机被读成"只有白色滤镜"），不如**做实在**——表面不透明度抬到 88%，
-   并把 backdrop-filter 撤掉（白算一遍）。注意：只动我们自己的标记属性，宿主元素一个都不碰。 */
-html body [data-mpw-pop-trunc] { background-color: color-mix(in srgb, var(--dsw-specific-sidebar-fill) 88%, transparent) !important; backdrop-filter: none !important; -webkit-backdrop-filter: none !important; }
-/* ②(2026-10-05) 处在包装容器里的弹层：玻璃由**根级模糊层**提供（见 lib 里的 mpwPopGlassApply），
-   弹层自己保持半透明表面、不再白算一次 backdrop-filter（它那层的 root 被祖先截断，算了也看不见）。 */
-html body [data-mpw-pop-glass] { backdrop-filter: none !important; -webkit-backdrop-filter: none !important; }
+   并把 backdrop-filter 撤掉（白算一遍）。注意：只动我们自己的标记属性，宿主元素一个都不碰。
+   ③(2026-10-05) 底色改用**我们自己的** token（--mpw-pop-trunc-surface）：原来借宿主
+   --dsw-specific-sidebar-fill，真机在侧栏作用域里它被算成**透明**（color-mix 嵌套后 α=0）
+   ⇒ 面板整个变透明、白字直接看不见（提示气泡就是这么"没有底"的）。 */
+html body [data-mpw-pop-trunc] { background-color: var(--mpw-pop-trunc-surface, var(--mpw-pop-surface)) !important; backdrop-filter: none !important; -webkit-backdrop-filter: none !important; }
+/* ②(2026-10-05 v3 定案)「去截断 + 补霜」：弹层自己的 backdrop-filter 采样不到页面，是因为
+   祖先链上有个创建 backdrop root 的元素（真机：输入框卡片 uV2eYG_card blur(14px)）。
+   B 类弹层开着期间给那个祖先打 data-mpw-pop-untrunc ⇒ 这条规则把它的 blur 摘掉（root 回到整页，
+   弹层自己的 blur 立刻采样得到页面）；丢掉的磨砂由 JS 在它内部补一层对齐霜层（data-mpw-pop-frost）。
+   特异性 (0,2,2)：压得过宿主按类名写的 !important 规则；而我们自己的弹层表面规则已经被
+   POP_NOT 里的 :not([data-mpw-pop-untrunc]) 排除，不打架。 */
+html body [data-mpw-pop-untrunc][data-mpw-pop-untrunc] {
+	backdrop-filter: none !important;
+	-webkit-backdrop-filter: none !important;
+}
+/* ②(2026-10-05 v3) 旧「根级模糊层」机制已删除（真机结论：挂在卡片的层 root 被截断；
+   挂 body 的层又会压住弹层——弹层在卡片的层叠上下文里）。data-mpw-pop-glass 现在只是"B 类、
+   祖先截断已被我们摘掉"的**诊断标记**，没有任何 CSS 效果（弹层自己的 blur 照常工作）。 */
+html body [data-mpw-pop-frost] { background-color: transparent !important; }
 html body[data-ds-dark-theme] [data-mpw-pop-bg] { background-color: var(--mpw-pop-surface-dark) !important; }
 [role="menu"] [class*="card"],
 [role="tooltip"] [class*="card"] {
@@ -24827,9 +24864,9 @@ body[data-mpw-modal] [role="dialog"] {
 			} catch { sblurObserver = null; }
 			// 窗口尺寸变化会让"近全屏"阈值与面板 rect 都变（父对话的真机判据就带视口切换）⇒ 一并重算
 			try { window.addEventListener("resize", recheck); } catch {}
-			/* ②(2026-10-05) 根级模糊层是 fixed 定位、按弹层 rect 对齐的 ⇒ 滚动/缩放时必须重贴 */
-			try { window.addEventListener("scroll", () => { try { mpwPopGlassApply() } catch (e) {} }, true); } catch {}
-			try { window.addEventListener("resize", () => { try { mpwPopGlassApply() } catch (e) {} }); } catch {}
+			/* ③(2026-10-05 v3) 旧「根级模糊层」是 fixed + 按弹层 rect 对齐 ⇒ 那时才需要 scroll/resize 重贴；
+			   现在是"摘祖先 blur + 容器内 inset:0 的霜层"，尺寸/位置全交给宿主自己的布局 ⇒ 两个监听删掉
+			   （顺带省掉滚动期的一路回调）。 */
 			check();
 		}
 
@@ -24939,10 +24976,22 @@ body[data-mpw-modal] [role="dialog"] {
 			} catch (e) { return 0 }
 		}
 
+		/** 我们自己注入的节点（根级模糊层等）：它们的突变**绝不能再喂回自己的快路**（否则死循环）。 */
+		function mpwIsOurs(node) {
+			try {
+				if (!node || node.nodeType !== 1) return false;
+				if (node.getAttribute && node.getAttribute("data-plugin") === "dsh-mpkg-wallpaper") return true;
+				for (let p = node.parentElement, k = 0; p && k < 3; p = p.parentElement, k++) {
+					if (p.getAttribute && p.getAttribute("data-plugin") === "dsh-mpkg-wallpaper") return true;
+				}
+			} catch (e) {}
+			return false;
+		}
 		function mpwTagPopoverFast(records) {
 			try {
 				let n = 0;
 				for (const rec of (records || [])) {
+					if (mpwIsOurs(rec.target)) continue;
 					/* ②(2026-10-05 真机仍见白帧的根因) 弹层大多是**先插入（隐藏）→ 再靠 class/style 显形**：
 					   只认 addedNodes 时，元素插入那一刻还是 display:none（判定不出"浮层面积"，也看不见），
 					   等它显形时走的是 **attributes 突变**，而旧观察器只监听 childList ⇒ 显形那一帧没人管，
@@ -24966,32 +25015,49 @@ body[data-mpw-modal] [role="dialog"] {
 						for (const el of cands) { if (mpwTagOnePopover(el)) n++; }
 					}
 				}
-				try { mpwSideLiftSync(); } catch (e) {}
-				try { mpwPopUntruncSync(); } catch (e) {}
+				/* ③(2026-10-05 会话里掉帧) 快路里**只留打标记**：mpwSideLiftSync 是全文档扫描
+				   （class* 子串匹配，代价随会话 DOM 线性涨），侧栏收起这类"宿主每帧改 DOM"的场景下
+				   每个突变批次都跑一次 ⇒ 会话里卡、空会话流畅。它挪去节流的重活路径（见 prun）。 */
+				if (n) { try { mpwPopUntruncSync(); } catch (e) {} }
 				return n;
 			} catch (e) { return 0 }
 		}
 		/** 单个元素：该不该有我们的兜底底；返回是否发生了变化。 */
 		function mpwTagOnePopover(el) {
 			let need = false;
+			let why = "";
 			try {
 				const cls = (typeof el.className === "string") ? el.className : "";
-				if (!MPW_POP_TAG_NOT.test(cls)) {
+				/* ③(2026-10-05 白字修复) **提示气泡（role=tooltip）不接管底色**：宿主的气泡是深底浅字
+				   （--dsw-alias-tooltip-bg = #2c2c2e 配 #fff 字），我们那层 58% 浅色表面压上去 ⇒
+				   白字看不清（真机：右栏右上角图标的气泡）。它自己的 blur 由 CSS 那条规则照常给。 */
+				let isTip = false;
+				try { isTip = el.getAttribute("role") === "tooltip" } catch (e) {}
+				if (!MPW_POP_TAG_NOT.test(cls) && !isTip) {
 					const cs = getComputedStyle(el);
 					const blurred = !!(cs && /blur\(/.test(String(cs.backdropFilter || cs.webkitBackdropFilter || "")));
 					if (blurred) {
-						const a = mpwColorAlpha(cs.backgroundColor);
-						/* ②(2026-10-05) 两类分开判：
-						   · 宿主**没有底**（α<0.05）的弹层：**不要求此刻可见** —— 隐藏时打标无害，
-						     等它显形时表面已经在位（这正是"先插入后显形"那条路的白帧来源）；
-						   · 宿主画了**不透明底**的小浮层：必须量得到面积（隐藏时 rect=0 ⇒ 留给下一次触发）。 */
-						if (a < 0.05) need = !mpwPopHasPaintedAncestor(el);
-						else if (a >= 0.999 && cs.display !== "none" && cs.visibility !== "hidden") need = mpwPopIsFloating(el);
+						/* ③(2026-10-05 闪烁修复) 已经带标记的：**只按当初那条结构性判据复核**，绝不重读底色。
+						   标记一生效，底色就变成我们自己画的 58%，重读会得到"宿主有半透明底"⇒ 撤标 ⇒
+						   宿主底回来 ⇒ 再打标 …… 逐帧自激（真机："底色时有时无"）。
+						   属性值就是当初的理由：empty = 宿主没画底；painted = 宿主画了不透明底。 */
+						const reason = el.getAttribute("data-mpw-pop-bg");
+						if (reason === "empty") { need = !mpwPopHasPaintedAncestor(el); why = "empty" }
+						else if (reason === "painted") { need = mpwPopIsFloating(el); why = "painted" }
+						else {
+							const a = mpwColorAlpha(cs.backgroundColor);
+							/* ②(2026-10-05) 两类分开判：
+							   · 宿主**没有底**（α<0.05）的弹层：**不要求此刻可见** —— 隐藏时打标无害，
+							     等它显形时表面已经在位（这正是"先插入后显形"那条路的白帧来源）；
+							   · 宿主画了**不透明底**的小浮层：必须量得到面积（隐藏时 rect=0 ⇒ 留给下一次触发）。 */
+							if (a < 0.05) { need = !mpwPopHasPaintedAncestor(el); why = "empty" }
+							else if (a >= 0.999 && cs.display !== "none" && cs.visibility !== "hidden") { need = mpwPopIsFloating(el); why = "painted" }
+						}
 					}
 				}
 			} catch (e) { need = false; }
 			try {
-				if (need) { if (!el.hasAttribute("data-mpw-pop-bg")) { el.setAttribute("data-mpw-pop-bg", ""); return true } }
+				if (need) { if (el.getAttribute("data-mpw-pop-bg") !== why) { el.setAttribute("data-mpw-pop-bg", why); return true } }
 				else if (el.hasAttribute("data-mpw-pop-bg")) { el.removeAttribute("data-mpw-pop-bg"); return true }
 			} catch (e) {}
 			return false;
@@ -25003,7 +25069,8 @@ body[data-mpw-modal] [role="dialog"] {
 			for (let i = 0; i < list.length; i++) mpwTagOnePopover(list[i]);
 		}
 
-		/* ①(P3 修复 2026-10-03) 弹层玻璃的 backdrop root 被截断 ⇒ 有半透明、没模糊。
+		/* ①(P3 修复 2026-10-03；历史：机制已被下面的 v3 取代，保留沿革与真机读数)
+		   弹层玻璃的 backdrop root 被截断 ⇒ 有半透明、没模糊。
 		   读数与机制（docs/POPOVER-BLUR.md）：挂在宿主输入框卡片（uV2eYG_card，backdrop-filter:
 		   blur(14px)）子树里的弹层，其 backdrop root 被卡片截断 ⇒ 弹层自己的 blur(11px) 只能采样
 		   卡片内部 = 看不出模糊；挂在 body 下的模型选择器正常。实验定案：把表面移出祖先链即恢复
@@ -25014,64 +25081,100 @@ body[data-mpw-modal] [role="dialog"] {
 		   （`[data-mpw-pop-untrunc] { backdrop-filter: none !important; }`）——只在弹层开着期间生效，
 		   弹层关闭（无已标记表面）即摘属性、撤规则元素，宿主逐字还原。代价：属性表 + 一次
 		   querySelectorAll，挂在 prun（已 rAF 合并 + mpwHeavyGate 闸门）里，不开新观察器。 */
-		/* ②(2026-10-05 设计收口) 三类弹层，三条路（宿主元素一个都不碰）：
+		/* ②(2026-10-05 设计收口 v1) 三类弹层，三条路（宿主元素一个都不碰）：
 		     A. 没有模糊祖先（典型：挂在 body 下的模型/推理选择器）⇒ 我们自己的 58% 表面 + 自己的 blur；
-		     B. 祖先里有模糊、且那个祖先是**已知包装容器**（输入框卡片一类）⇒ 弹层打 `data-mpw-pop-glass`，
-		        由 `mpwPopGlassApply()` 在**根级**垫一层对齐矩形的模糊层（backdrop root = 整页），
-		        包装容器照旧保留自己的磨砂 —— 用户明确要求"弹层要模糊、输入框的模糊也不能没"；
-		     C. 祖先里有模糊、但那不是包装容器（用户正在看的面板，例如子代理展开框）⇒ 什么都不摘，
-		        给弹层打 `data-mpw-pop-trunc`（88% 实底）：糊不到页面背后，就不假装是玻璃。 */
-		/* ②(2026-10-05) 「根级模糊层」：给"处在包装容器里、自己的 backdrop 被截断"的弹层垫一层
-		   挂在 body 下的模糊层（backdrop root = 整页），位置/圆角跟着弹层走。宿主元素一个都不碰。 */
-		const popGlassLayers = new WeakMap();
-		const popGlassNodes = new Set();        // 需要清理（弹层已卸载/已摘标记）时按它遍历
-		function mpwPopGlassApply() {
-			try {
-				const blur = (() => { try { return getComputedStyle(document.body).getPropertyValue("--mpw-pop-blur").trim() || "blur(11px)" } catch (e) { return "blur(11px)" } })();
-				for (const el of Array.from(document.querySelectorAll("[data-mpw-pop-glass]"))) {
-					let layer = popGlassLayers.get(el) || null;
-					if (!layer || !layer.isConnected) {
-						layer = document.createElement("div");
-						layer.setAttribute("data-plugin", "dsh-mpkg-wallpaper");
-						layer.setAttribute("data-mpw-pop-glass-layer", "");
-						layer.style.cssText = "position:fixed;pointer-events:none;z-index:4;border-radius:12px;";
-						(document.body || document.documentElement).appendChild(layer);
-						popGlassLayers.set(el, layer);
-						popGlassNodes.add(el);
-					}
-					const r = el.getBoundingClientRect();
-					let radius = "12px";
-					try { const cs = getComputedStyle(el); if (cs.borderTopLeftRadius && cs.borderTopLeftRadius !== "0px") radius = cs.borderTopLeftRadius } catch (e) {}
-					if (r.width < 2 || r.height < 2) { layer.style.display = "none"; continue }
-					layer.style.display = "block";
-					layer.style.left = Math.round(r.left) + "px";
-					layer.style.top = Math.round(r.top) + "px";
-					layer.style.width = Math.round(r.width) + "px";
-					layer.style.height = Math.round(r.height) + "px";
-					layer.style.borderRadius = radius;
-					layer.style.backdropFilter = blur;
-					layer.style.webkitBackdropFilter = blur;
+		     B. 祖先里有模糊、且那个祖先是**已知包装容器**（输入框卡片 / 菜单容器一类）；
+		     C. 祖先里有模糊、但那不是包装容器（用户正在看的面板，例如子代理展开框）⇒ 88% 实底。 */
+		/* ③(2026-10-05 v3 定案：**去截断 + 补霜**，取代 v2 的「根级模糊层」)
+		   为什么 v2 不行（真机读数 tools/host-popover-probe.mjs --groups glass-placement，结构性判据不用像素）：
+		     · 层挂在**卡片子树里**（v2 最后那版紧挨弹层之前）⇒ 它的 backdrop root 被 uV2eYG_card
+		       （宿主自己的 backdrop-filter: blur(14px)）截断，采样到的只是卡片内部已经糊过的底色
+		       ⇒ 观感正好是用户报的"只剩一层白色半透明，模糊没了"；
+		     · 层挂到 **body**（任何 z）⇒ root 确实干净了，但 `elementsFromPoint` 命中栈显示它**压在整个
+		       弹层之上**：弹层在卡片的层叠上下文里（卡片有 backdrop-filter ⇒ 自成层叠上下文），
+		       body 级定位元素整体画在它上面 ⇒ 弹层会被我们的层糊掉。两条路都堵死。
+		   所以只剩一条路：**把截断源头摘掉**——弹层开着期间给那个祖先打 `data-mpw-pop-untrunc`
+		   （静态规则 backdrop-filter:none !important ⇒ backdrop root 回到整页，弹层**自己的** blur
+		   立刻采样得到页面，连目标条一起糊），丢掉的磨砂由 `data-mpw-pop-frost` 补回来。
+		   真机验证（--groups glass-fix）：卡片摘 bf + z-index:0（它本来就是 position:relative）后，
+		   弹层截断链**清空**、弹层矩形**一字不动**、补的霜层与卡片矩形完全重合、中心命中仍是弹层自己。
+		   代价：一次属性表 + 一次 querySelectorAll（挂在 prun，已 rAF 合并）；层是 inset:0 的绝对定位，
+		   **不需要**随滚动/缩放重贴（v2 那两个 scroll/resize 监听因此删掉）。 */
+		const popUntruncs = new Map();   // 祖先元素 -> { bf, radius, frost, frostKey, zInline }
+		/** 该祖先能不能给"z-index:-1 的霜层"当层叠上下文：定位元素即可（静态元素我们不碰 ——
+		    给它 position:relative 会改包含块、把宿主弹层带跑，真机混账过）。 */
+		function mpwPopCanCtx(el, cs) {
+			try {
+				if (cs && cs.position) return cs.position !== "static";
+				return getComputedStyle(el).position !== "static";
+			} catch (e) { return false }
+		}
+		/** 去截断 + 补霜（幂等：need 里没有的一律还原，宿主逐字回到原样）。 */
+		function mpwPopUntruncApply(need) {
+			let changed = 0;
+			try {
+				for (const el of Array.from(popUntruncs.keys())) {
+					if (need && need.has(el) && el.isConnected !== false) continue;
+					const rec = popUntruncs.get(el);
+					if (rec && rec.frost && rec.frost.parentElement) { try { rec.frost.remove() } catch (e) {} }
+					try { el.removeAttribute("data-mpw-pop-untrunc") } catch (e) {}
+					/* 只还原我们动过的那一项（z-index 是我们为"造层叠上下文"补的） */
+					if (rec && rec.zInline !== null) { try { el.style.zIndex = rec.zInline } catch (e) {} }
+					popUntruncs.delete(el);
+					changed++;
 				}
-				/* ②(2026-10-05) 清理要按**层自己**的账走：弹层正常关闭时元素会被 React 从 DOM 摘掉，
-				   那时 `[data-mpw-pop-bg]` 已经查不到它 —— 只按查询清理会**留层泄漏**（真机上会累积一堆
-				   隐形 fixed 层）。所以：surface 已断开 / 已不是 glass / 已摘标记 ⇒ 撤层。 */
-				for (const el of Array.from(popGlassNodes)) {
-					const layer = popGlassLayers.get(el);
-					const alive = el.isConnected !== false && el.hasAttribute && el.hasAttribute("data-mpw-pop-glass") && el.hasAttribute("data-mpw-pop-bg");
-					if (alive) continue;
-					if (layer && layer.parentElement) { try { layer.remove() } catch (e) {} }
-					popGlassLayers.delete(el);
-					popGlassNodes.delete(el);
+				if (!need) return changed;
+				for (const el of need) {
+					let rec = popUntruncs.get(el) || null;
+					if (!rec) {
+						let cs = null;
+						try { cs = getComputedStyle(el) } catch (e) {}
+						const bf = (cs && cs.backdropFilter && cs.backdropFilter !== "none") ? String(cs.backdropFilter) : "";
+						rec = { bf: bf, radius: (cs && cs.borderTopLeftRadius) || "0px", frost: null, frostKey: "", zInline: null };
+						popUntruncs.set(el, rec);
+						try { el.setAttribute("data-mpw-pop-untrunc", "") } catch (e) {}
+						/* 层叠上下文：定位元素且 z-index:auto 时补 z-index:0（auto 与 0 的绘制次序一致，
+						   不会把它挪到别的东西上下）；已经是数值的不动（它本来就有层叠上下文）。 */
+						try {
+							const pcs = cs || getComputedStyle(el);
+							if (pcs.position !== "static" && pcs.zIndex === "auto") { rec.zInline = el.style.zIndex || ""; el.style.zIndex = "0" }
+						} catch (e) {}
+						changed++;
+					}
+					const key = rec.bf + "|" + rec.radius;
+					/* 存活判据用 parentElement + isConnected === false：桩/异常环境拿不到 isConnected 时
+					   也不会每轮重建霜层（重建 = 不可见的 DOM 抖动）。 */
+					const frostAlive = !!(rec.frost && rec.frost.parentElement && rec.frost.isConnected !== false);
+					if (rec.bf && rec.bf.indexOf("blur") >= 0 && (!frostAlive || rec.frostKey !== key)) {
+						try { if (rec.frost && rec.frost.parentElement) rec.frost.remove() } catch (e) {}
+						const frost = document.createElement("div");
+						frost.setAttribute("data-plugin", "dsh-mpkg-wallpaper");
+						frost.setAttribute("data-mpw-pop-frost", "");
+						/* inset:0 + z-index:-1：按 CSS 绘制顺序画在**父元素背景之上、内容之下** ⇒
+						   容器自己的磨砂观感、圆角、内容层次全都不变（真机实测矩形与容器逐像素重合）。 */
+						frost.style.cssText = "position:absolute;left:0;top:0;width:100%;height:100%;z-index:-1;pointer-events:none;"
+							+ "border-radius:" + rec.radius + ";backdrop-filter:" + rec.bf + ";";
+						rec.frost = frost;
+						rec.frostKey = key;
+						try { el.insertBefore(frost, el.firstChild) } catch (e) { try { el.appendChild(frost) } catch (e2) {} }
+						changed++;
+					}
 				}
 			} catch (e) {}
+			return changed;
 		}
 		/* 判据出口（tools/popover-glass-test.mjs 直接用） */
 		try {
 			globalThis.__mpwPopUntruncTest = {
 				sync: () => mpwPopClassifySync(),
-				/* 用 body 的子节点数（根级层就挂在 body 下）——比属性选择器更稳，桩/真机都对 */
-				glassCount: () => Array.from(((document.body || document.documentElement).children) || []).filter((e) => e && e.hasAttribute && e.hasAttribute("data-mpw-pop-glass-layer")).length,
-				truncCount: () => document.querySelectorAll("[data-mpw-pop-trunc]").length,
+				/* 旧名保留（旧判据引用过"根级模糊层"）：v3 已经没有那层了，恒为 0 */
+				glassCount: () => 0,
+				/* 去截断的祖先数（每个都该配一层霜层：无 blur 可补的祖先不计霜层） */
+				untruncCount: () => { try { return document.querySelectorAll("[data-mpw-pop-untrunc]").length } catch (e) { return 0 } },
+				frostCount: () => { try { return document.querySelectorAll("[data-mpw-pop-frost]").length } catch (e) { return 0 } },
+				truncCount: () => { try { return document.querySelectorAll("[data-mpw-pop-trunc]").length } catch (e) { return 0 } },
+				/* 单个元素的兜底底判定（判据要能直接驱动它：闪烁是"打标/撤标"自激，必须单元素可复现） */
+				tag: (el) => mpwTagOnePopover(el),
 			};
 		} catch (e) {}
 
@@ -25080,26 +25183,43 @@ body[data-mpw-modal] [role="dialog"] {
 				const surfaces = document.querySelectorAll("[data-mpw-pop-bg]");
 				const glasses = new Set();
 				const truncated = new Set();
+				const neutralize = new Set();
 				for (let i = 0; i < surfaces.length; i++) {
 					const el = surfaces[i];
 					let cs = null;
 					try { cs = getComputedStyle(el) } catch (e) {}
-					/* 硬前提：我们自己给了模糊才有"被截断"这回事 */
-					if (!cs || !cs.backdropFilter || String(cs.backdropFilter).indexOf("blur") < 0) continue;
+					/* 硬前提：我们自己给了模糊才有"被截断"这回事。
+					   ③(2026-10-05 闪烁修复) **已带标记的表面必须放行**：C 类规则把表面的 backdrop-filter
+					   撤成 none，只认 computed blur 的话下一轮就会把刚打的标记摘掉 ⇒ 打标/撤标逐帧自激
+					   （真机实测：按钮提示气泡与几个面板底色"时有时无"）。 */
+					const marked = el.hasAttribute("data-mpw-pop-glass") || el.hasAttribute("data-mpw-pop-trunc");
+					if (!marked && (!cs || !cs.backdropFilter || String(cs.backdropFilter).indexOf("blur") < 0)) continue;
+					/* ③(2026-10-05) 提示气泡（role=tooltip）一律不接管：宿主的气泡是**深底浅字**
+					   （--dsw-alias-tooltip-bg 配 #fff 字），我们的表面/实底压上去 ⇒ 白字看不见。
+					   它自己的 blur 由 CSS 那条 [role="tooltip"] 规则照常给。 */
+					try { if (el.getAttribute("role") === "tooltip") continue } catch (e) {}
+					let path = "";
+					const cands = [];      // 这条链上"可去截断"的祖先（走完再决定用不用：C 路一个都不摘）
 					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 }
-						const ablur = acs && acs.backdropFilter && acs.backdropFilter !== "none" && String(acs.backdropFilter).indexOf("blur") >= 0;
+						/* ③(2026-10-05 反自激) 已经被我们"去截断"的祖先照样算截断祖先 —— 否则下一轮
+						   看不见它的 blur（被我们摘了）⇒ 判成 A ⇒ 撤标记 ⇒ 还原 blur ⇒ 再判 B … 逐帧自激。 */
+						const declared = !!(p.hasAttribute && p.hasAttribute("data-mpw-pop-untrunc"));
+						const ablur = declared || (acs && acs.backdropFilter && acs.backdropFilter !== "none" && String(acs.backdropFilter).indexOf("blur") >= 0);
 						if (!ablur) continue;
-						let isSurface = false;
-						try { isSurface = p.matches(MPW_POP_TAG_SEL) } catch (e) {}
-						if (isSurface) { truncated.add(el); break }            // C：用户正在看的面板 ⇒ 一个像素都不动
+						let isOurDeco = false;
+						try { isOurDeco = !declared && p.matches(MPW_POP_TAG_SEL) && !p.hasAttribute("data-mpw-pop-bg") } catch (e) {}
 						let wrap = false;
-						try { wrap = /(_card|composer|overlayAnchor|_seat|_stack)/i.test(String(p.className || "")) } catch (e) {}
-						if (wrap) glasses.add(el);                              // B：已知包装容器 ⇒ 根级模糊层
-						else truncated.add(el);                                 // 未知祖先 ⇒ 保守：实底
+						try { wrap = declared || isOurDeco || /(_card|composer|overlayAnchor|_seat|_stack)/i.test(String(p.className || "")) } catch (e) {}
+						/* B：能摘（它得是定位元素：霜层的 z-index:-1 要有层叠上下文兜住；真机两个截断祖先
+						   都是定位的）⇒ 记进待摘表；C：其余的（用户正在看的面板 / 未知祖先 / 静态元素）保守做实在。 */
+						if (wrap && mpwPopCanCtx(p, acs)) { cands.push(p); continue }
+						path = "C";
 						break;
 					}
+					if (path === "C") truncated.add(el);
+					else if (cands.length) { for (const p of cands) neutralize.add(p); glasses.add(el) }
 				}
 				const sync = (attr, want) => {
 					const stale = document.querySelectorAll("[" + attr + "]");
@@ -25108,7 +25228,7 @@ body[data-mpw-modal] [role="dialog"] {
 				};
 				sync("data-mpw-pop-glass", glasses);
 				sync("data-mpw-pop-trunc", truncated);
-				mpwPopGlassApply();
+				mpwPopUntruncApply(neutralize);
 				return glasses.size + truncated.size;
 			} catch (e) { return 0 }
 		}
@@ -25118,28 +25238,53 @@ body[data-mpw-modal] [role="dialog"] {
 		function setupPopTagWatch() {
 			if (popTagWatch !== null) return;
 			let praf = 0;
+			/* ③(2026-10-05 会话里掉帧的根因) 下面这三个同步**每个都是全文档扫描**，而且选择器带
+			   `[class*=…]` 子串匹配 ⇒ 代价随会话 DOM 线性涨（真机现象正好是"空会话流畅、会话里卡"：
+			   宿主在侧栏收起/展开动画期间每帧改 DOM ⇒ 每个突变批次都把这三趟全扫一遍）。
+			   改成**节流 + 尾随**：距上次 ≥150ms 才立刻跑；否则跳过并挂一个 180ms 的尾随定时器
+			   （突发结束一定还会跑一次，状态不会被饿死）。动画在跑时要求 600ms 才放行（优先保动画帧）。
+			   注意：标记本身（data-mpw-pop-bg 等）仍走快路，不受这里影响。 */
+			let popHeavyLast = 0, popHeavyTimer = 0;
+			const nowMs = () => { try { return (typeof performance !== "undefined" && performance.now) ? performance.now() : Date.now() } catch (e) { return Date.now() } };
+			const popHeavySync = () => {
+				popHeavyLast = nowMs();
+				try { mpwTagSurfaceOuter(); } catch (e) {}
+				try { mpwPopUntruncSync(); } catch (e) {}
+				try { mpwSideLiftSync(); } catch (e) {}
+			};
+			const popHeavyTail = () => {
+				if (popHeavyTimer) return;
+				try {
+					popHeavyTimer = setTimeout(() => { popHeavyTimer = 0; try { popHeavySync() } catch (e) {} }, 180);
+				} catch (e) { popHeavyTimer = 0; }
+			};
 			const prun = () => {
 				praf = 0;
 				try {
 					// 左栏收起/展开与拖拽期间宿主每帧改 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-05 卡死 + 卡顿修复) 这一路**不再做全文档扫描**（旧写法每帧
+					   `querySelectorAll` 全文档，会话里元素多 ⇒ 侧栏动画就掉帧；空会话元素少 ⇒ 流畅，
+					   与真机观察完全一致）。全文档扫描只在 apply/初始那一次，突变一律走 fast path。 */
 					/* ②(2026-10-04) 右栏/dock 的"只留最外层"标记必须**跟着 DOM 走**：右栏面板是
 					   用户打开后才挂载的，apply 那一刻它还不存在 ⇒ 只按一次会把 dock 错标成表面，
 					   之后面板出现就变成两层（真机读数：dockPane/dockStrip 仍是 0.55）。
-					   这里与弹层标记共用同一个 rAF 合并的入口（要素很少，代价可忽略）。 */
-					try { mpwTagSurfaceOuter(); } catch (e) {}
-					try { mpwSideLiftSync(); } catch (e) {}
-					try { mpwPopGlassApply(); } catch (e) {}
-					/* ①(P3) 弹层开着 ⇒ 摘截断祖先的 blur；关了 ⇒ 还原（同一入口，随突变重算） */
-					try { mpwPopUntruncSync(); } catch (e) {}
+					   这里与弹层标记共用同一个节流入口（要素很少时几乎立刻就跑）。 */
+					const since = nowMs() - popHeavyLast;
+					if (since >= 150 && (!mpwHeavyAnimRunning() || since >= 600)) popHeavySync();
+					else popHeavyTail();
 				} catch (e) {}
 			};
 			try {
 				popTagWatch = new MutationObserver((records) => {
+					/* ②(2026-10-05 卡死修复的第二道保险) 全是**我们自己**的写入（根级模糊层的 style 等）
+					   ⇒ 直接返回：连 rAF 都不排，杜绝"写→观察→再写"的自激。 */
+					let anyForeign = false;
+					try {
+						for (const rec of (records || [])) { if (!mpwIsOurs(rec.target)) { anyForeign = true; break } }
+					} catch (e) { anyForeign = true; }
+					if (!anyForeign) return;
 					/* 同步快路：新增的弹层当场判定打标（消灭"先白后变"的过渡态） */
 					try { mpwTagPopoverFast(records); } catch (e) {}
 					if (praf) return;

package/lib/index.js

@@ -16,7 +16,7 @@ import { execFileSync, spawn, spawnSync } from 'node:child_process';
 // ①(2026-09-21 音频格式补全) 后三个导出是**唯一的**扩展名→MIME 表与嗅探入口，见 docs/AUDIO-TRACK-SPEC.md §1.2/§3：
 //   路由侧原先各自内联一份扩展名三元链 + 一份魔数嗅探，已与渲染器支持的后缀漂移（.oga/.m4a/.aac 缺失、ftyp 偏移写错）。
 //   ⚠ 这条 import 必须**保持单行**：tools/bundle-equivalence-test.mjs 的具名导入解析器按行读（注释进括号会解析失败）。
-import { extractSceneMainImage, extractSceneMainImageFromDir, extractSceneManifest, extractSceneLayer, extractTexVideoMp4, collectSceneVideoFiles, parsePkg, readPkgEntry, scanSceneAudio, scanSceneVideo, clearSceneVideoScanCache, suffixAudioMime, audioMimeFor, AUDIO_SUFFIX_MIME, mpwParseWeJson, mpwWeJsonSwallowed } from './pkg-extract.js';
+import { extractSceneMainImage, extractSceneMainImageFromDir, extractSceneManifest, extractSceneLayer, extractTexVideoMp4, collectSceneVideoFiles, parsePkg, readPkgEntry, scanSceneAudio, scanSceneVideo, clearSceneVideoScanCache, probeSceneVideoVerdict, suffixAudioMime, audioMimeFor, AUDIO_SUFFIX_MIME, mpwParseWeJson, mpwWeJsonSwallowed } from './pkg-extract.js';
 // ①(新 2026-09-16 I 项) 网页（web）类壁纸：内容优先的类型判定 + WE API shim 注入 + 跨源策略
 // （MIT，本仓库自写；API 名单参考 oneincase/webwallgl，未复制其代码，见 ../docs/COPYING-RULES.md §4）
 // ①(WP-1 2026-09-19) 追加：帧内存储 facade 的持久化路由（/web-store）、宿主媒体音频控制
@@ -4229,6 +4229,31 @@ function apply(ctx) {
     const probeSceneVideo = (req, res, dir) => {
       const t0 = Date.now();
       try {
+        /* ①(2026-10-04) **只判不取**（**仅当调用方显式要 `?has=1` 时**）：客户端"卡片/清单阶段"
+         *   只问"这张场景有没有内嵌视频"（`lib/client.js` 只读 `d.has`），而 `ensureSceneVideo` 是
+         *   "判定 + 提取"一体的（会把整段内嵌视频读进内存并落盘；实测 792MB 的容器 = 791.6MB 读盘）。
+         *   `?has=1` 时先走只读目录表 + 候选前缀的 `probeSceneVideoVerdict`（实测 64KB/容器）：能判定
+         *   就直接答 `{ok,has}`，答不了（unknown/多独立视频/松散目录）回退提取路径。
+         *   ⚠ **不带该参数时行为与改前逐位相同**（含 `{has,mime,size}` 响应形状与"探测即落盘缓存"
+         *   的既有契约）—— 既有判据 `tools/scene-video-test.mjs` 钉的正是那条默认路径。 */
+        const wantHasOnly = (() => {
+          try {
+            const q = String((req && req.url) || '');
+            return /[?&]has=1(?:&|$)/.test(q);
+          } catch { return false; }
+        })();
+        try {
+          const verdict = wantHasOnly ? probeSceneVideoVerdict(dir) : null;
+          if (verdict && verdict.decided) {
+            const ms0 = Date.now() - t0;
+            if (ms0 > 500) {
+              try { console.log('[dsh-mpkg-wallpaper][perf] scene 视频探测(verdict) ' + ms0 + 'ms:', dir); } catch {}
+            }
+            if (!verdict.has) { json(res, 200, { ok: true, has: false, verdict: true }); return; }
+            json(res, 200, { ok: true, has: true, verdict: true });
+            return;
+          }
+        } catch { /* verdict 出意外 → 回退提取路径（与改前同一答案） */ }
         const v = ensureSceneVideo(dir);
         const ms = Date.now() - t0;
         if (ms > 500) {

package/lib/pkg-extract.js

@@ -427,6 +427,35 @@ function readPkgEntry(data, entry) {
   return out;
 }
 
+/**
+ * ①(2026-10-04) **从"已读出的存储字节"还原一条目**：把"是否 LZ4 链"的判定交给**唯一口径**
+ * `probeCompressedEntry`（与 `parsePkg` 同一函数），而不是依赖调用方传进来的 `flags`。
+ *
+ * 为什么需要：`readPkgIndexFromFile` 只读目录表，条目内容不在已读头里 ⇒ 头解析出来的条目
+ * `flags` 恒为 0（`partial:true`）。索引先行的路径据此把**压缩条目**当 raw 用 ⇒ 视频/TEX
+ * 在"压缩存储"时会静默探测失败（legacy 整包口径却能成功）—— 这正是"两条路径判定分叉"的形态。
+ * 这里用全量存储字节做判定（信息最全），成功即解压；`flags & 1` 的快路保留（整包口径）。
+ */
+function decodeStoredEntry(stored, entry) {
+  const raw = stored instanceof Uint8Array ? stored : new Uint8Array(stored)
+  let original = null
+  if ((entry.flags & 1) === 0) {
+    // 头解析出来的条目 `size` 是**存储长度**（partial），不能拿它当原始长度：链头 u64 才是真值
+    try { original = probeCompressedEntry(raw, 0, raw.length) } catch { original = null }
+    if (original === null) return raw
+  }
+  if (original === null) {
+    // 整包口径（flags&1）：`entry.size` 已是 probe 出来的原始长度；仍以链头为准做一致性兜底
+    try {
+      const view = new DataView(raw.buffer, raw.byteOffset, raw.byteLength)
+      const head = Number(view.getBigUint64(0, true))
+      original = head > 0 && head <= 2147483647 ? head : entry.size
+    } catch { original = entry.size }
+  }
+  const w = { path: entry.path, offset: 0, compressedSize: raw.length, size: original, flags: 1 }
+  return readPkgEntry(raw, w)
+}
+
 /* ═══════════════════════════════════════════════════════════════════════════
  * ①(2026-09-15 用户第 1 条反馈「扫描音频的速度能否快些」) 惰性音频索引
  *
@@ -2446,11 +2475,9 @@ function scanSceneVideo(dirOrPath, opts = {}) {
           const got = readSync(fd, stored, 0, stored.length, Math.max(0, e.offset));
           bytesRead += got; entriesRead++;
           const buf = got === stored.length ? stored : stored.subarray(0, got);
-          if (e.flags & 1) {
-            const w = { path: e.path, offset: 0, compressedSize: buf.length, size: e.size, flags: 1 };
-            return readPkgEntry(buf, w);
-          }
-          return new Uint8Array(buf);
+          // ①(2026-10-04) 走 decodeStoredEntry：头解析的条目 flags 恒为 0（partial），
+          //   压缩条目必须靠 probeCompressedEntry 判（全量口径），否则会被当 raw 用 ⇒ 静默漏判。
+          return decodeStoredEntry(buf, e);
         } catch { return null; }
       };
       // ① 独立视频条目：只读它们（旧路径读了全部 TEX 也会丢弃这些结果）
@@ -2510,7 +2537,90 @@ function scanSceneVideo(dirOrPath, opts = {}) {
   return { video, source, cacheHit: false, indexEntries, entriesRead, bytesRead, tableBytes: source === 'pkg' ? undefined : 0, ms };
 }
 
-export { extractSceneMainImage, extractSceneMainImageFromDir, extractSceneManifest, extractSceneLayer, extractTexVideoMp4, collectSceneVideoFiles, parsePkg, readPkgEntry, parseTex, PKG_MAGIC_RE };
+/* ═══════════════════════════════════════════════════════════════════════════
+ * ①(2026-10-04) 「只判不取」的 scene 内嵌视频 verdict
+ *
+ * 动机（本机实测）：`ensureSceneVideo` 是"判定 + 提取"一体的 —— 探一次就把整段内嵌视频读进
+ * 内存并落盘（实测样例里 712 MB 的视频 = 712 MB 读盘），而客户端在**列表/卡片阶段**只问
+ * `{has, mime}`（`lib/client.js` 的 `sceneVideoCheckUrl` 只读 `d.has`）。本函数只做判定：
+ * **只读目录表 + 每条候选的前缀**（本机实测判定成本 ≈ 60 KB/包），绝不读视频载荷。
+ *
+ * 判定口径与 `scanSceneVideo` / legacy（`findSceneVideoInPkg`）**同源**：
+ *   · 有独立视频条目 ⇒ 恰好 1 条时可判定（取它）；≥2 条时"谁最大"要看解压后长度 ⇒ 交回慢路径；
+ *   · 否则看 TEX：逐条前缀判定（`probeTexVideoDecision`）——
+ *       ≥2 条判为 video ⇒ `has:false`（与 legacy "多 TEX 视频 ⇒ null" 一致）；
+ *       exactly 1 条 video 且无 unknown ⇒ `has:true`；0 条 video 且无 unknown ⇒ `has:false`；
+ *       出现 unknown（前缀不足/异常布局/压缩解释歧义）⇒ `decided:false`，调用方回退 `ensureSceneVideo`。
+ *   · **松散目录**（`scene.json` + 平铺 `.tex`）一律 `decided:false`：那种场景没有大载荷，不值得为它加一条分支。
+ *
+ * 返回 `{ has, ref, tex, decided, source, reason, indexEntries, bytesRead, ms }`。
+ * ⚠ 本函数**不写任何缓存**（判定结果由调用方决定是否复用；提取物缓存仍归 `ensureSceneVideo`）。
+ * ═══════════════════════════════════════════════════════════════════════════ */
+function probeSceneVideoVerdict(dirOrPath, opts = {}) {
+  const t0 = process.hrtime.bigint()
+  const done = (o) => Object.assign({ has: null, ref: null, tex: null, decided: false, source: 'pkg', reason: null, indexEntries: 0, bytesRead: 0, texPeeked: 0, ms: Number(process.hrtime.bigint() - t0) / 1e6 }, o)
+  let target = dirOrPath
+  try {
+    const st0 = statSync(dirOrPath)
+    if (st0.isDirectory()) {
+      const pkgPath = join(dirOrPath, 'scene.pkg')
+      if (!existsSync(pkgPath)) return done({ source: 'dir', reason: 'loose-dir' })
+      target = pkgPath
+    }
+  } catch (e) { return done({ source: 'unknown', reason: 'stat-failed' }) }
+  let idx = null
+  try { idx = readPkgIndexFromFile(target, opts) } catch (e) { return done({ reason: 'index-unreadable' }) }
+  const idxEntries = idx.entries
+  const sizeOf = (e) => (e.compressedSize == null ? e.size : e.compressedSize)
+  const base = { indexEntries: idxEntries.length, bytesRead: idx.headBytes, texPeeked: 0 }
+  const standalone = idxEntries.filter((e) => SCENE_VIDEO_EXT_RE.test(String(e.path || '').toLowerCase()) && sizeOf(e) > 0)
+  if (standalone.length === 1) return done(Object.assign({ has: true, ref: standalone[0].path, tex: false, decided: true }, base))
+  if (standalone.length > 1) return done(Object.assign({ reason: 'multi-standalone' }, base))
+  const texEntries = idxEntries.filter((e) => String(e.path || '').toLowerCase().endsWith('.tex'))
+  let bytesRead = idx.headBytes
+  let texPeeked = 0
+  const fd = openSync(target, 'r')
+  try {
+    let positives = 0, unknown = 0, firstPositive = null
+    for (const e of texEntries) {
+      const want = Math.min(sizeOf(e), TEX_PEEK_BYTES)
+      if (want <= 0) { unknown++; continue }
+      let head = null
+      try {
+        const buf = Buffer.allocUnsafe(want)
+        const got = readSync(fd, buf, 0, want, Math.max(0, e.offset))
+        bytesRead += got
+        if (got > 0) texPeeked++
+        head = got === want ? buf : buf.subarray(0, got)
+      } catch { head = null }
+      const decide = (bytes) => (bytes && bytes.length)
+        ? probeTexVideoDecision((off, len) => (off + len > bytes.length ? null : bytes.subarray(off, off + len)), bytes, e.path)
+        : 'unknown'
+      let decision = decide(head)
+      // 头解析的条目 `flags` 未知：可能是 LZ4 链条目 ⇒ 再按"压缩解释"试一次（成功且判出结论才采用）
+      if (decision === 'unknown') {
+        try {
+          const d = readPkgEntryHead(head, { path: e.path, offset: 0, compressedSize: head.length, size: e.size, flags: 1 }, TEX_PEEK_BYTES)
+          const d2 = decide(d)
+          if (d2 !== 'unknown') decision = d2
+        } catch { /* 不是压缩条目（或前缀不足）→ 保持 unknown */ }
+      }
+      if (decision === 'none') continue
+      if (decision === 'video') {
+        positives++
+        if (!firstPositive) firstPositive = e.path
+        if (positives >= 2) break
+      } else unknown++
+    }
+    const out = { indexEntries: idxEntries.length, bytesRead, texPeeked }
+    if (positives >= 2) return done(Object.assign({ has: false, decided: true }, out))
+    if (positives === 1 && unknown === 0) return done(Object.assign({ has: true, ref: firstPositive, tex: true, decided: true }, out))
+    if (positives === 0 && unknown === 0) return done(Object.assign({ has: false, decided: true }, out))
+    return done(Object.assign({ reason: 'unknown-tex-decision', positives, unknown }, out))
+  } finally { closeSync(fd) }
+}
+
+export { extractSceneMainImage, extractSceneMainImageFromDir, extractSceneManifest, extractSceneLayer, extractTexVideoMp4, collectSceneVideoFiles, parsePkg, readPkgEntry, parseTex, PKG_MAGIC_RE, probeSceneVideoVerdict, decodeStoredEntry };
 // ①(2026-09-15 音频扫描提速 / 2026-09-16 洁净室重写) 惰性音频索引：只读目录表 + 仅候选头 ≤16 字节。
 //   名字与结构依据 docs/AUDIO-TRACK-SPEC.md（后缀判定 / 容器判定 / 枚举核心里外三层）。
 export {

package/package.json

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