dsh-mpkg-wallpaper 3.8.0 → 3.8.2

package/lib/client.js

@@ -206,6 +206,22 @@ function mpwTrace(ev, data) {
 		   宿主同一位置已经有**别的插件**注入的元素时，我们**不挂/撤下**并留一行可读 warn，
 		   而不是叠着画。 */
 		const DEFAULT_NP_NOW_PLAYING = true;
+		/* ①(NP-4 2026-09-19 真机修复) 音量电平（0..100）。
+		   为什么要有它：NP-3 的"第四个键"只是**静音开关**（布尔 muted），全仓**没有任何**
+		   能改电平的落点（真机读数：section 里与音量有关的键 0 个）⇒ 用户现场
+		   "打开之后也不能调整它开启的音量"。默认 100：与 `HTMLMediaElement.volume` 的默认值
+		   相同，也与 web 帧主音量的缺省（web-wallpaper.js 的 masterVolume=1）相同
+		   ⇒ **默认档逐字节零行为变化**（判据见 tools/np-control-test.mjs 的 E 组）。 */
+		const DEFAULT_NP_VOLUME = 100;
+		/* ①(NP-4)② 「播放/暂停是否同时控制壁纸的播放/暂停」联动开关，默认**开**。
+		   默认必须是开：改动之前 NP 的播放/暂停/进度就是直接落在壁纸媒体元素上的
+		   （视频档：`vid.play()/pause()`；见 npTransport）——默认关就等于改掉了既有行为，
+		   而本条明确要求"不许在做这件事时改变既有默认行为"。
+		   语义（口径见 docs/NOW-PLAYING-DSH.md §7.8）：
+		     开 ⇒ 传输动作同时驱动壁纸自己的媒体 + 我们自己的播放器；
+		     关 ⇒ 只驱动我们自己的播放器（壁纸的画面播放不受控件影响）；
+		          壁纸媒体是**唯一**声源时（视频档没有旁挂音频）控件如实禁用，不假装。 */
+		const DEFAULT_NP_LINK_WALLPAPER = true;
 		const HOST_BASE = "/api/mpkg-wallpaper";
 		// ①(MERGED-3 1.3) 诊断开关速查区离线副本（渲染器离线时用）。
 		//   在线数据源 = <渲染器>/diag-flags.json（由 we-scene-demo/diag-flag-check.mjs 脚本生成，勿手改）；
@@ -306,6 +322,12 @@ function mpwTrace(ev, data) {
 		 *    · 源字段（image/webUrl/sceneKey）粘性 ⇒ 谁都没带就保持原样，绝不因为"这次没提"而消失。
 		 *  合并结果**同时**回写两处（旧写法只写 localStorage，宿主那份半残档永远修不回来）。 */
 		function initHostSettings() {
+			// ①(2026-09-19 设置持久化轮) **一次性**：apply() 会因 RTC 重连/热重注入重跑，而每一次都会
+			//   重新 GET 一次宿主设置。旧实现里重复的 GET 只是重复合并（幂等，代价小）；现在合并带
+			//   "两处存储时间戳裁决 + 回写两处"，重复跑会让"后到的那次 GET"拿着**更旧**的宿主快照
+			//   参与裁决（极端情况下把刚写下的本地新值判给宿主）。所以这一轮明确只跑一次。
+			if (window.__mpwHostInitOnce) return;
+			window.__mpwHostInitOnce = true;
 			try {
 				fetch(HOST_BASE + "/settings", { method: "GET" }).then(async (r) => {
 					if (!r.ok) { try { mpwBootSettle("host-get-not-ok") } catch {} return }
@@ -407,7 +429,15 @@ function sectionSigNow() {
 			return o;
 		}
 		function readSection() {
-			if (sectionCache) return sectionCache;
+			if (sectionCache) {
+				// ①(2026-09-19 设置持久化轮) **读口一律不见元键**：内部缓存为了落盘会带
+				//   `__mpwLocalAt` 这类元键（时间戳/自愈标记），但"用户档"的读数口（面板/buildCss/
+				//   导出/字段集合比较/测试的逐字段 diff）必须看不到它们 —— 否则元键会被当成
+				//   "用户的设置项"参与比较（真机上表现为"莫名多出一个键"，测试里表现为假红）。
+				const clean = mpwStripMeta(sectionCache);
+				if (clean !== sectionCache) sectionCache = clean;
+				return sectionCache;
+			}
 			sectionCache = mpwNormalizeSection(loadSection());
 			return sectionCache;
 		}
@@ -872,8 +902,26 @@ function sectionSigNow() {
 				(typeof mpwVal(s, "source") === "string" && mpwVal(s, "source"));
 			return !src && !!clue;
 		}
+		/** 不变量Ⅲ（半边）：**补空缺、不覆盖** —— 保留 `win` 已有的每一个键的值，
+		 *  只把 `lose` 里 `win` **没有**的键补进来。
+		 *  ⚠ 这里连踩过两次坑（都由 B1/B4 断言抓出来，故单独成函数 + 明确语义）：
+		 *    · 用 `mpwMergeSection(lose, win)` ⇒ win 的键逐个覆盖 lose ⇒ 变成"整档赢"，
+		 *      等于退化成旧写法的整档覆盖语义（字段级裁决名存实亡）；
+		 *    · 用"谁值不同就取另一份"⇒ 两边都有的键仍然由**一方**决定，同样是整档赢。
+		 *  只有"以赢家为底、输家只填空缺"才同时满足：两端都有的键由时间戳裁决 + 只有一端有的键一定保留。 */
+		function mpwOverlayFill(win, lose) {
+			const out = Object.assign({}, (win && typeof win === "object") ? win : {});
+			if (!lose || typeof lose !== "object") return out;
+			for (const k of Object.keys(lose)) {
+				if (out[k] !== void 0) continue;          // 赢家已有 ⇒ 一律用赢家的
+				const v = lose[k];
+				if (v === void 0 || v === null) continue; // 输家的"缺/显式删"都不该补进赢家
+				out[k] = v;
+			}
+			return out;
+		}
 		/** 不变量Ⅲ：启动时把两处存储合成一份 —— 新者优先（各自的内嵌时间戳），
-		 *  再走三路合并（"与 base 相同 = 这一层没动过它"⇒ 用另一层，字段级不会互相抹）。 */
+		 *  输家只补赢家没有的键（`mpwOverlayFill`），源字段另有粘性保护（谁都没有时不抹）。 */
 		function mpwReconcileStores(localIn, hostIn) {
 			const local = mpwStripMeta(localIn || {});
 			const host = mpwStripMeta(hostIn || {});
@@ -894,12 +942,10 @@ function sectionSigNow() {
 				newer = "unknown";
 				reason = "no-stamps(local=" + localKeys.length + " keys, host=" + hostKeys.length + " keys)";
 			}
-			const A = winner === "local" ? local : host;
-			const B = winner === "local" ? host : local;
-			// 三路合并：A 为基准；B 里"与 A 不同"的键（= 只有 B 那一层动过）也带上（B 不覆盖 A 已给的键）。
-			const patch = {};
-			for (const k of mpwSortedKeys(B)) if (mpwVal(B, k) !== mpwVal(A, k)) patch[k] = mpwVal(B, k);
-			let merged = mpwMergeSection(A, patch);
+			/* 裁决后合成：**赢家已有的键一律用赢家的值**，输家只补赢家没有的键（见 mpwOverlayFill）。 */
+			const win = winner === "local" ? local : host;
+			const lose = winner === "local" ? host : local;
+			let merged = mpwOverlayFill(win, lose);
 			// 源字段粘性 + 一致性标记：两处都没有源、却都有来源线索 ⇒ 半残档（交给自愈）
 			merged = mpwStickySource(local, merged);
 			merged = mpwStickySource(host, merged);
@@ -1945,11 +1991,12 @@ function sectionSigNow() {
 			// 导致每次 applyFromStorage 都重设 src → Edge 端也重载重播。
 			try { if (video.getAttribute('src') !== url) video.src = url; } catch {}
 			video.playbackRate = (typeof readSection().playbackRate === "number" && readSection().playbackRate >= 0.5 && readSection().playbackRate <= 2) ? readSection().playbackRate : 1;
-			/* ①(NP-3) 静音设置项 → 视频元素（Edge canvas 路线同样要落） */
-			try { applyVideoMute(); } catch {}
+			/* ①(NP-4) 起播顺序：**先 muted 起播，拿到播放权之后再按设置应用 muted/volume**。
+			   旧写法在这里先 `applyVideoMute()` 再 `play()` ⇒ 那是一次"有声自动播放"，
+			   没有用户手势时被浏览器直接拒（真机读数：NotAllowedError，见 npPrimePlay 的注释）
+			   ⇒ 视频永远 paused、画面冻住、也没有声音。顺序是这条 bug 的全部根因。 */
+			try { npPrimePlay(video); } catch {}
 			edgeDrawFrame();
-			// ①(修正) 暂停门控：Edge canvas 渲染路径也尊重暂停，避免其余路径重播
-			try { if (!(wallUserPaused || powPaused)) { const p = video.play(); if (p && p.catch) p.catch(() => {}); } } catch {}
 			// ①(修正) 首帧前先画一帧（避免白屏）——用命名函数 + removeEventListener 防泄漏
 			//（原来 {once:true} 在视频永不加载时会残留监听，评审指出）
 			const drawOnce = () => { try { video.removeEventListener("loadeddata", drawOnce); } catch {} edgeDrawFrame(); };
@@ -2008,8 +2055,9 @@ function sectionSigNow() {
 			img.style.display = "";
 		}
 		function showVideoEl(url) {
+			npOpTrace("showVideoEl", null, String(url || "").slice(0, 48));
 			const { img, video, frame, canvas, wrap } = bgElements();
-			if (!img || !video || !wrap) return;
+			if (!img || !video || !wrap) { npOpTrace("showVideoEl", null, "no-elements"); return; }
 			// ①(加固) CSS 类切换：视频壁纸显示 video、隐藏 img
 			stopSceneAnim();
 			disarmSceneWatchdog(true); // ①(批次15 B1) 切到视频壁纸：解除场景看门狗并清兜底视觉
@@ -2032,21 +2080,19 @@ function sectionSigNow() {
 			// video.src → 浏览器重载媒体源 → autoplay 自动播放，绕过下方 play() 暂停门控
 			// （用户实测：暂停后调静音壁纸又重播、暂停按钮与实际状态脱节）。
 			// getAttribute('src') 返回原始的相对字符串，同 url 相等 → 不重载，彻底避免。
-			try { if (video.getAttribute('src') !== url) video.src = url; } catch {}
+			try { if (video.getAttribute('src') !== url) { video.src = url; npSetUserPaused(video, false) } } catch {}
 			// ⑳(新) 视频倍速：原生 playbackRate（0.5-2x，即时生效，不重载）
 			try {
 				const rate = readSection().playbackRate;
 				if (typeof rate === "number" && rate >= 0.5 && rate <= 2 && video.playbackRate !== rate) video.playbackRate = rate;
 			} catch {}
-			/* ①(NP-3) 静音设置项 → 视频元素（此前只有建 DOM 时的硬编码 true，再没人改过它）。 */
-			try { applyVideoMute(); } catch {}
 			video.style.display = "";
 			// ①(修正) 暂停状态门控：用户手动暂停（wallUserPaused）或省电暂停（powPaused）
 			// 时不 play——否则任何设置开关 apply（commit→applyFromStorage→showVideoEl）都
 			// 无条件 play()，把用户手动暂停解开（用户实测"暂停后开启效果又解开暂停"）。
-			if (!(wallUserPaused || powPaused)) {
-				try { const p = video.play(); if (p && p.catch) p.catch(() => {}); } catch {}
-			}
+			// ①(NP-4) 门控**在 npPrimePlay 里**（它自己判 wallUserPaused/powPaused），
+			//   并且把"静音/电平落点"挪到**起播成功之后**（顺序根因见 npPrimePlay 注释）。
+			try { npPrimePlay(video); } catch {}
 		}
 		/**
 		 * ①(修复 2026-09-12) 清理场景 iframe 上历史遗留的诊断开关。
@@ -2818,7 +2864,7 @@ function sectionSigNow() {
 				if (frame) frame.muted = mute;
 				// ①(2026-09-16 I 项) shim 通道：帧内静音由 shim 执行（不透明源读不到帧内元素）
 				if (frame && mpwWebShimUrl(frame.getAttribute("src"))) {
-					webShimCall(frame, { op: "policy", muted: mute, speed: typeof s.playbackRate === "number" ? s.playbackRate : 1 });
+					webShimCall(frame, { op: "policy", muted: mute, speed: npPolicySpeed(), volume: npWantVolume() });
 				}
 				const doc = frame && frame.contentDocument;
 				if (doc) {
@@ -2838,11 +2884,278 @@ function sectionSigNow() {
 			if (!video) return false;
 			try {
 				const s = readSection();
-				const want = (s.mute !== void 0 ? !!s.mute : true) || npAudioOwns();
+				const want = (npPrimedMuted || npSoundBlocked) ? true : ((s.mute !== void 0 ? !!s.mute : true) || npAudioOwns());
 				if (video.muted !== want) video.muted = want;
 			} catch {}
 			return true;
 		}
+		/* ══════════════════════════════════════════════════════════════════════════
+		   ①(NP-4 2026-09-19 真机修复)「壁纸声音」的电平 + 起播顺序
+		   真机读数（用户当前档 `custom|3582362359`：video + mp4 内 aac，设置 mute=false）：
+		     · 加载后 `<video>` = {paused:true, muted:false, volume:1, currentTime:0}
+		     · 全程 `play()` **只被调用过一次**，`muted:false`，promise
+		       **rejected NotAllowedError**（"The play method is not allowed by the user agent…"），
+		       而旧写法在 .catch 里把它吞了（lib/client.js 的 showVideoEl 尾部）
+		   ⇒ 视频永远没起播：画面冻在第一帧、**也没有任何声音**，于是静音开关"开/关都听不到声音"。
+		   根因是**顺序**：旧写法先 `applyVideoMute()`（把 muted 写成 false）再 `play()`
+		   —— 那一刻这是一次"有声自动播放"，没有用户手势时被浏览器直接拒；
+		   先以 muted 起播（浏览器允许）拿到播放权，再取消静音才是对的顺序。
+		   下面三件事一起做，缺一条就还剩一半：①起播顺序；②失败**不静默**（状态可查 + 首次手势重试）；
+		   ③**电平**落点（NP-3 只有布尔 muted，全仓没有改 volume 的地方）。
+		   ══════════════════════════════════════════════════════════════════════════ */
+		/** ①(NP-4) 传输/起播动作的**统一轨迹**（最近 32 条）。真机排障唯一能看到"动作走到哪一步"的地方；
+		    只记账，零行为影响（探针读它，见 tools/np-media-live-probe.mjs 的 I/K 组）。 */
+		function npOpTrace(op, value, did) {
+			try {
+				const a = window.__mpwNpOps || (window.__mpwNpOps = []);
+				a.push({ op: op, value: value === void 0 ? null : value, at: Date.now(), did: String(did || "") });
+				if (a.length > 32) a.shift();
+			} catch (e) {}
+		}
+		let npPlayBlocked = null;      // {name,message,at,retryMuted} —— 起播被拒的可查原因（null = 没被拒）
+		/** 起播被拒的原因**挂到 window 上**（真机探针/控制台可查；写失败不影响任何行为）。
+		    为什么必须可查：这条 bug 的修前形态就是"被拒了但没人知道"（`.catch(() => {})`）——
+		    一个只在闭包里存在的错误等于没有错误。 */
+		function npMarkPlayBlocked(v) {
+			npPlayBlocked = v;
+			try { window.__mpwNpPlayBlocked = v; } catch (e) {}
+		}
+		let npGestureArmed = false;    // 首次用户手势重试只装一次（不常驻监听）
+		let npPrimedMuted = false;     // 正在用"muted 起播"兜着（这一段里 muted 由重试持有，不被状态校准撤销）
+		let npPrimedMutedTimer = 0;    // 上面那段的到期兜底（1.5s）
+		/* ── ①(NP-4) 浏览器自动播放策略的**第二半**（真机读数逼出来的）──────────────────
+		   第一半：没有用户手势时"有声"自动播放会被 **reject**（NotAllowedError）——见 npPrimePlay。
+		   第二半（更隐蔽）：**"muted 起播成功之后再取消静音"同样不被允许** —— Firefox 在那一刻
+		   直接把元素**停住**（paused=true）：既不 reject 任何 promise，也不调用 `video.pause()`
+		   （所以包 pause/load 都抓不到它）。真机读数（用户那张档，页面从未交互）：
+		     ops = [showVideoEl, prime:"calling-play muted=true", prime-ok:"played"]
+		     而 video = {paused:true, currentTime:0, muted:false}
+		   ⇒ 画面冻住、也没有任何声音；静音开关怎么拨都不响（因为**根本没在放**）。
+		   正确做法（浏览器规则就是这么定的，不是绕过它）：
+		     · 页面还没被交互过 ⇒ 以 muted 保持画面在动，并把"声音被策略挡住"记成可查状态；
+		     · 用户**第一次**真的点了页面（pointerdown/keydown 任一）⇒ 立刻取消静音并续播（声音到位）；
+		     · 这一段里 muted 由本状态持有（`npSoundBlocked` ⇒ npWantMuted() 为 true），
+		       否则"取消静音 → 被停 → 再取消静音"会自己转成一个环。 */
+		let npWantPlay = false;        // 我们**想要**它在放（用来把"被策略停住"与"用户自己暂停"分开）
+		/* ①(NP-4) 真机回归的修法：`applyNowPlaying` 里那次"补起播"（刷新后没人再调 play 了）
+		   会把**用户刚用卡片按下的暂停**在 60ms 后解开（真机读数：点播放键 ⇒ paused false→false，
+		   因为暂停被延迟 apply 又续上了）。所以"用户按过暂停"必须是一条独立状态：
+		     · npTransport 的 pause 分支置真，play 分支置假；
+		     · npPrimePlay 在它为真时**直接返回**（和 wallUserPaused/powPaused 同一条闸）；
+		     · 切壁纸/换源（applyNowPlaying 走新 section）时清零。 */
+		/* ①(NP-4) "用户亲手按过暂停"这条状态记在**元素自己身上**（`video.__mpwUserPaused`），
+		   不记模块变量：元素是这件事的天然所有者（换源即清零），而且单元门禁里每个用例一份新夹具时
+		   模块变量会跨夹具串味（实测：上一个用例的暂停把下一个用例的静音判据带红）。 */
+		function npUserPausedOf(video) { try { return !!(video && video.__mpwUserPaused) } catch (e) { return false } }
+		function npSetUserPaused(video, on) { try { if (video) video.__mpwUserPaused = !!on } catch (e) {} }
+		let npSoundBlocked = false;    // 浏览器不允许"没有用户手势就出声"（已如实记录并保持画面在动）
+		let npSoundReason = null;      // 可查原因（window.__mpwNpSoundBlocked）
+		/** 设置项 `npVolume`（0..100）→ 0..1。缺省/非法 ⇒ 1（与 elements 的默认值一致 ⇒ 零行为变化）。 */
+		function npWantVolume() {
+			let raw;
+			try { raw = readSection().npVolume; } catch (e) { return 1 }
+			const n = Number(raw);
+			if (raw === void 0 || raw === null || !isFinite(n)) return 1;
+			return Math.max(0, Math.min(1, n / 100));
+		}
+		/** 静音落点（唯一口径）：设置项 `mute`，或我们的播放器正在放音（内容重复）。 */
+		function npWantMuted() {
+			let s = {};
+			try { s = readSection() } catch (e) {}
+			/* ①(NP-4) 策略挡住出声时，muted 由本状态持有（见 npSoundBlocked 的注释：不这样做，
+			   "取消静音 ⇒ 被浏览器停住 ⇒ 再取消静音"会变成一个自己转的环）。 */
+			return npSoundBlocked || ((s.mute !== void 0 ? !!s.mute : true) || npAudioOwns());
+		}
+		/** ①(NP-4) 联动的唯一判据（②）：开 ⇒ 传输动作同时驱动壁纸媒体；关 ⇒ 只驱动我们的播放器。 */
+		function npLinkOn(section) {
+			const s = section || {};
+			return s.npLinkWallpaper !== void 0 ? !!s.npLinkWallpaper : DEFAULT_NP_LINK_WALLPAPER;
+		}
+		/** ①(NP-4) 「电平被别人显式设过」的唯一判据：section 里有 `npVolume` 这个键。
+		 *  为什么要有这一条（而不是"反正默认 100 等于 1，随便写"）：
+		 *    · web 帧那条 shim 通道（lib/web-wallpaper.js 的 `policy.volume` → setMasterVolume）
+		 *      **只要字段出现就装钩子**（包 HTMLMediaElement.prototype.volume 的 setter + 包
+		 *      window.Audio）——那是作者脚本能观察到的环境变化；
+		 *    · 同源兼容模式直写 `els[i].volume` 会把作者自己设的音量**覆盖成 1**。
+		 *  两条都只在"用户真的动过电平"之后才允许发生 ⇒ 默认档（从没设过 npVolume）
+		 *  **一个元素、一个字段都不碰**，与改动前逐字节同行为（判据见 tools/np-control-test.mjs A11/A12）。 */
+		function npVolumeSet() {
+			try {
+				const raw = readSection().npVolume;
+				return raw !== void 0 && raw !== null && isFinite(Number(raw));
+			} catch (e) { return false }
+		}
+		/** ①(NP-4) 电平落点：视频元素 / 我们自己的播放器 / web 帧（同源直写 + shim 主音量）。
+		 *  shim 那条通道是**既有**的（实机口径 = 作者页面内音量 × 宿主主音量，见 lib/web-wallpaper.js）。
+		 *  `force` = 调用方明确要落（拖完音量条那一下）；否则只在用户设过电平时才写。 */
+		function npApplyVolume(force) {
+			const vol = npWantVolume();
+			const touch = force === true || npVolumeSet();
+			if (touch) {
+				try { const v = bgElements().video; if (v && v.volume !== vol) v.volume = vol; } catch (e) {}
+				try { if (npAudio && npAudio.volume !== vol) npAudio.volume = vol; } catch (e) {}
+			}
+			try {
+				const frame = bgElements().frame;
+				if (frame) {
+					if (mpwWebShimUrl(frame.getAttribute("src"))) {
+						const msg = { op: "policy", muted: npWantMuted(), speed: npPolicySpeed() };
+						if (touch) msg.volume = vol;      /* 没设过 ⇒ 不带这个键（钩子不装，零环境变化） */
+						webShimCall(frame, msg);
+					}
+					/* 兼容模式（同源）：帧内元素直接写。沙箱（不透明源）读不到 ⇒ 只有上面 shim 那一条。 */
+					const doc = touch ? frame.contentDocument : null;
+					if (doc) {
+						const els = doc.querySelectorAll("audio,video");
+						for (let i = 0; i < els.length; i++) { try { if (els[i].volume !== vol) els[i].volume = vol } catch (e) {} }
+					}
+				}
+			} catch (e) {}
+			npReportAudio();
+			return vol;
+		}
+		function npPolicySpeed() {
+			try {
+				const r = readSection().playbackRate;
+				return (typeof r === "number" && r >= 0.5 && r <= 2) ? r : 1;
+			} catch (e) { return 1 }
+		}
+		/** ①(NP-4) 把"我们知道的音频状态"如实报到宿主 `/media-audio`（WP-1 契约）。
+		 *  节流 250ms：拖动音量时每帧都 POST 就是打自己的接口打到卡。 */
+		let npReportAt = 0, npReportTimer = 0;
+		function npReportAudio(now) {
+			const send = () => {
+				npReportAt = Date.now();
+				try {
+					const s = readSection();
+					const vid = npActiveVideo(s);
+					const muted = npWantMuted();
+					const body = {
+						muted: muted, volume: npWantVolume(),
+						hasAudio: vid ? npVideoAudio(vid) : (npAudio ? true : null),
+						source: vid ? "video" : (npAudio ? "tracks" : (bgElements().frame ? "web" : null)),
+					};
+					fetch(HOST_BASE + "/media-audio", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) }).catch(() => {});
+				} catch (e) {}
+			};
+			const since = Date.now() - npReportAt;
+			if (now === true || since >= 250) { send(); return; }
+			if (npReportTimer) return;
+			try { npReportTimer = setTimeout(() => { npReportTimer = 0; send(); }, 250 - since); } catch (e) {}
+		}
+		/** ①(NP-4) 起播顺序的唯一入口（showVideoEl / showVideoEdge / 首帧恢复都走它）。
+		 *  规则：要起播就先 muted 起播，**拿到播放权之后**再按设置应用 muted/volume。
+		 *  失败 ⇒ 记 canPlay 的诚实状态 + 装一次性手势重试（首次点击/按键时自动补一次）。 */
+		function npPrimePlay(video) {
+			if (!video) { npOpTrace("prime", null, "no-video"); return false; }
+			if (wallUserPaused || powPaused || npUserPausedOf(video)) {
+				npApplyMute(); npApplyVolume();
+				npOpTrace("prime", null, "gated: wallUserPaused=" + wallUserPaused + " powPaused=" + powPaused + " userPaused=" + npUserPausedOf(video));
+				return false;
+			}
+			/* 已经在放 = 没有起播可偷，而且**不许在这里再校准静音**：
+			   起播那一刻的元素状态就是对的（上面那条路已经保证），而"每次 apply 都按设置重写"
+			   会踩到另一条既有竞态 —— `npTransport` 末尾那次 60ms 的延迟 apply 可能落在
+			   "设置缓存被一次更早发出的 GET /settings 的应答覆盖回旧值"之后（真机读数：
+			   localStorage=false 而 readSection()=true）⇒ 元素被按**旧值**重新静音，
+			   用户看到"开关明明关了却还是没声音"。静音/电平各自有明确入口：
+			   静音键（npTransport 的 mute 分支）与音量拖动（volume 分支）+ 切壁纸时的
+			   applyNowPlaying。这里只起播，不改状态。 */
+			if (!video.paused) { npOpTrace("prime", null, "already-playing"); return false; }
+			npWantPlay = true;
+			npOpTrace("prime", null, "calling-play muted=" + video.muted);
+			/* **第一次就用设置里的静音状态去 play()**：有用户手势（或浏览器本身允许）时这是
+			   最正确的一条 —— 元素状态从头到尾等于设置，一个字节都不偷。
+			   旧写法反过来：先无条件 muted=true 再 play()，然后指望某个回调把 muted 恢复成设置值
+			   ⇒ 回调不来（promise 不被 resolve / 元素被换掉 / 那一帧整页 reload）元素就**永久停在
+			   muted=true**：设置里写着 mute=false，用户却什么都听不到（"开/关都听不到声音"）。
+			   ⇒ 只有被拒时才退到"muted 起播"重试一次（见 npPlayRetryMuted），并且那次有兜底纠偏。 */
+			let p = null;
+			try { p = video.play(); } catch (e) {
+				npMarkPlayBlocked({ name: String(e && e.name || "Error"), message: String(e && e.message || "").slice(0, 200), at: Date.now(), retryMuted: false });
+				npArmGestureRetry();
+				return false;
+			}
+			/* 起播成功只清"被拒"标记 + 落一次电平：**不在这里重写 muted** —— 起播用的就是设置里的
+			   静音状态，重写一次只会把"设置缓存被更早的 GET 应答覆盖回旧值"这条既有竞态带进来
+			   （真机读数见 npPrimePlay 里那段注释）。 */
+			const done = () => { npMarkPlayBlocked(null); npApplyVolume(); npOpTrace("prime-ok", null, video.paused ? "resolved-but-paused" : "played"); };
+			if (p && typeof p.then === "function") {
+				p.then(done, (err) => { npPlayRetryMuted(video, err) });
+				/* ①(NP-4) "promise 一直不落"也是一种结局：留一条痕，别让人对着 paused=true 猜。
+				   3s 后若既没 ok 也没 reject 的记录，就记一条 pending（只记账，不改行为）。 */
+				try {
+					setTimeout(() => {
+						try {
+							const a = window.__mpwNpOps || [];
+							const last = a[a.length - 1] || {};
+							if (last.did === "calling-play muted=" + false || /^calling-play/.test(String(last.did || ""))) {
+								npOpTrace("prime-pending", null, "3s 后 promise 仍未落（paused=" + video.paused + "）");
+							}
+						} catch (e) {}
+					}, 3000);
+				} catch (e) {}
+			} else done();
+			return true;
+		}
+		/** 有声起播被浏览器拒 ⇒ **只重试一次** muted 起播（浏览器一律允许 muted 自动播放）。
+		 *  muted 这一次是"元素状态 == 设置"的**唯一例外**，所以配两条兜底纠偏，缺一不可：
+		 *   ① 媒体的 `playing` 事件（npWatchVideo 里接的）—— 真的出画/出声了就恢复设置值；
+		 *   ② 1.5s 一次性兜底（`npPrimedMuted` 到期即清）—— 连 playing 都不来也不许一直静音。
+		 *  两条路都会把 `npPrimedMuted` 清掉，恢复之后 `npApplyMute` 才允许把 muted 写成设置值
+		 *  （否则重试那一下会被"状态校准"当场撤销，等于没重试）。 */
+		function npPlayRetryMuted(video, err) {
+			npOpTrace("prime-reject", null, String(err && err.name || "Error"));
+			npMarkPlayBlocked({
+				name: String(err && err.name || "Error"),
+				message: String(err && err.message || "").slice(0, 200), at: Date.now(), retryMuted: true,
+			});
+			let retried = false;
+			try {
+				video.muted = true;
+				const p2 = video.play();
+				retried = true;
+				/* ①(NP-4) 重试**也要留结果**：不静默的判据不能只管第一次。
+				   第一次被拒时那个 promise rejection 曾被 `.catch(() => {})` 吞掉 —— 同一个坑不踩第二次。 */
+				if (p2 && typeof p2.then === "function") {
+					p2.then(
+						() => { try { window.__mpwNpRetryPlay = "ok" } catch (e) {} },
+						(e2) => { try { window.__mpwNpRetryPlay = String(e2 && e2.name || "Error") } catch (e) {} });
+				} else { try { window.__mpwNpRetryPlay = "ok" } catch (e) {} }
+			} catch (e) { try { window.__mpwNpRetryPlay = String(e && e.name || "Error") } catch (e2) {} }
+			npOpTrace("prime-retry", null, retried ? "muted-play" : "throw");
+			npPrimedMuted = retried;
+			if (retried) {
+				try { clearTimeout(npPrimedMutedTimer); } catch (e) {}
+				try { npPrimedMutedTimer = setTimeout(() => { npPrimedMuted = false; npApplyMute(); npApplyVolume(); }, 1500); } catch (e) {}
+			}
+			try {
+				console.warn("[dsh-mpkg-wallpaper] 壁纸视频的有声起播被浏览器拒绝（自动播放策略）: "
+					+ npPlayBlocked.name + " — " + npPlayBlocked.message
+					+ (retried ? "；已退回 muted 起播（成功出画后恢复静音设置）" : "")
+					+ "；首次点击/按键页面时还会再补一次。读数: "
+					+ JSON.stringify({ muted: video.muted, volume: video.volume, readyState: video.readyState }));
+			} catch (e) {}
+			npArmGestureRetry();
+			return false;
+		}
+		/** 起播被拒 ⇒ 装**一次性**的首次手势重试（pointerdown/keydown，capture，事件驱动、自卸）。 */
+		function npArmGestureRetry() {
+			if (npGestureArmed) return;
+			npGestureArmed = true;
+			const once = () => {
+				try { document.removeEventListener("pointerdown", once, true); } catch (e) {}
+				try { document.removeEventListener("keydown", once, true); } catch (e) {}
+				npGestureArmed = false;
+				if (!npPlayBlocked && !npSoundBlocked) return;
+				/* ①(NP-4) 用户真的交互了 ⇒ 声音限制解除：清掉"被挡住"状态，取消静音并续播。 */
+				npSoundBlocked = false; npSoundReason = null;
+				try { window.__mpwNpSoundBlocked = null; window.__mpwNpSoundAllowedBy = "gesture"; } catch (e) {}
+				try { const v = npActiveVideo(readSection()) || bgElements().video; if (v) { npApplyMute(); npApplyVolume(); npPrimePlay(v); } } catch (e) {}
+			};
+			try { document.addEventListener("pointerdown", once, true); } catch (e) {}
+			try { document.addEventListener("keydown", once, true); } catch (e) {}
+		}
 		/** ⑳(新) 给 web 壁纸 iframe 内的 <video> 应用倍速（含加载完成后补一次）。 */
 		function applyWebSpeed(frame) {
 			try {
@@ -2850,7 +3163,7 @@ function sectionSigNow() {
 				const rate = s.playbackRate;
 				if (typeof rate !== "number" || rate < 0.5 || rate > 2) return;
 				if (frame && mpwWebShimUrl(frame.getAttribute("src"))) {
-					webShimCall(frame, { op: "policy", muted: s.mute !== void 0 ? !!s.mute : true, speed: rate });
+					webShimCall(frame, { op: "policy", muted: s.mute !== void 0 ? !!s.mute : true, speed: rate, volume: npWantVolume() });
 				}
 				const doc = frame && frame.contentDocument;
 				if (!doc) return;
@@ -3311,7 +3624,7 @@ function sectionSigNow() {
 		function webShimPushPolicy(frame) {
 			try {
 				const s = readSection();
-				webShimCall(frame, { op: "policy", muted: s.mute !== void 0 ? !!s.mute : true, speed: typeof s.playbackRate === "number" ? s.playbackRate : 1 });
+				webShimCall(frame, { op: "policy", muted: s.mute !== void 0 ? !!s.mute : true, speed: npPolicySpeed(), volume: npWantVolume() });
 				webShimCall(frame, { op: "pause", value: !!wallUserPaused });
 			} catch {}
 		}
@@ -5718,15 +6031,39 @@ function sectionSigNow() {
 			}
 			return scope.ltoken ? (HOST_BASE + "/library-scene-audio?refs=0&ltoken=" + encodeURIComponent(scope.ltoken)) : "";
 		}
-		/** 单个音轨的字节 URL（宿主 /raw，支持 Range —— 长音频可拖动）。 */
-		function npTrackUrl(scope, trackPath) {
+		/** 单个音轨的字节 URL。
+		 *  ①(NP-4 2026-09-19 真机修复) **子目录路径**：旧写法无条件取基名
+		 *  （`path.split(/[\\/]/).pop()`）⇒ 音轨在子目录里时恒 404、在包内时恒 403。
+		 *  真机读数（宿主两条路由的实测响应，见 docs/NOW-PLAYING-DSH.md §7.8 的清单）：
+		 *    · `raw?custom=1&folder=3744579963&file=CH0200_MemorialLobby_1_1.ogg`
+		 *      → **404**（清单里那条真实路径是 `assets/audio/CH0200_MemorialLobby_1_1.ogg`）
+		 *    · `raw?...&file=assets%2Faudio%2F…ogg` → **403**（/raw 的 `file` 只接受**基名**，
+		 *      见 lib/index.js 的 `bad()` 判据：`file.includes('/')` 即拒绝）
+		 *    · `custom-folder/3744579963/assets/audio/CH0200_MemorialLobby_1_1.ogg`
+		 *      → **200 / audio/ogg**（prefix 路由 `/custom-folder/<folder>/<rest…>` 支持嵌套）
+		 *  ⇒ 有子目录时改走 **path 式**前缀路由（与网页壁纸的相对资源同一条）；
+		 *  单段路径**保持旧 URL 逐字节不变**（根目录音轨零回归：`3646392375/backgroundmuisc.mp3`、
+		 *  3580207945 那一档的 6 条都实测能放）。
+		 *  包内音频（`source==='pkg'`，文件在 `scene.pkg` 里）**没有任何字节通道**：
+		 *  `/custom-folder` 404（不在磁盘上）、`/raw` 403、`/custom-media` 403、
+		 *  `/custom-scene-frame` 回的是 png。⇒ 返回空串，调用方按"只列清单、不能播"如实标（不假装）。 */
+		function npTrackUrl(scope, trackPath, src) {
 			if (!scope || !trackPath) return "";
-			const file = String(trackPath).split(/[\\/]/).filter(Boolean).pop() || "";
+			if (String(src || "") === "pkg") return "";
+			const segs = String(trackPath).split(/[\\/]/).filter((x) => x && x !== "." && x !== "..");
+			const file = segs.length ? segs[segs.length - 1] : "";
 			if (!file) return "";
+			const enc = segs.map(encodeURIComponent).join("/");
 			if (scope.mode === "custom") {
-				return HOST_BASE + "/raw?custom=1&folder=" + encodeURIComponent(scope.folder) + "&file=" + encodeURIComponent(file);
+				if (segs.length === 1) {
+					return HOST_BASE + "/raw?custom=1&folder=" + encodeURIComponent(scope.folder) + "&file=" + encodeURIComponent(file);
+				}
+				return HOST_BASE + "/custom-folder/" + encodeURIComponent(scope.folder) + "/" + enc;
+			}
+			if (segs.length === 1) {
+				return HOST_BASE + "/raw?ltoken=" + encodeURIComponent(scope.ltoken) + "&file=" + encodeURIComponent(file);
 			}
-			return HOST_BASE + "/raw?ltoken=" + encodeURIComponent(scope.ltoken) + "&file=" + encodeURIComponent(file);
+			return HOST_BASE + "/library-web/" + encodeURIComponent(scope.ltoken) + "/" + enc;
 		}
 
 		/**
@@ -5772,13 +6109,13 @@ function sectionSigNow() {
 			const key = npScopeKey(scope);
 			const cached = npMediaCache.data;
 			if (!cached || npMediaCache.key !== key || !cached.tracks || !cached.tracks.length) return null;
-			return { scope: scope, key: key, tracks: cached.tracks };
+			return { scope: scope, key: key, tracks: cached.tracks, source: String(cached.source || "") };
 		}
 		function npCurrentTrack(section) {
 			const list = npTrackList(section);
 			if (!list) return null;
 			const i = Math.max(0, Math.min(list.tracks.length - 1, npTrackIdx));
-			return { scope: list.scope, key: list.key, tracks: list.tracks, index: i, track: list.tracks[i] };
+			return { scope: list.scope, key: list.key, tracks: list.tracks, source: list.source, index: i, track: list.tracks[i] };
 		}
 		function npAudioOwns() {
 			/* ①(NP-3) 我们的播放器在放音时，web 壁纸帧内的那份声音要让位（同一首会被放两遍）。 */
@@ -5797,10 +6134,14 @@ function sectionSigNow() {
 		function npResolveMedia(section) {
 			const s = section || {};
 			const id = npWallpaperIdentity(s);
+			const link = npLinkOn(s);
+			const vol = npWantVolume();
 			const out = {
 				kind: "none", title: "", byline: id.name, cover: "",
-				total: null, playing: false, muted: s.mute !== void 0 ? !!s.mute : true, volume: 1,
+				total: null, playing: false, muted: s.mute !== void 0 ? !!s.mute : true, volume: vol,
 				canPlay: false, canVolume: false, canPrev: false, canNext: false, hasAudio: null, source: "",
+				/* ①(NP-4) ②③ 新增的三个派生量（控制器据此决定键能不能按、带子能不能拖）。 */
+				canSeek: false, link: link, listOnly: false, trackIndex: 0, trackCount: 0,
 			};
 			// 封面：当前壁纸的缩略图（真实数据；拿不到就留空 ⇒ 走渐变兜底，与上游一致）
 			if (s.image && /^(data:|blob:|idb:|https?:|\/)/.test(String(s.image))) out.cover = String(s.image);
@@ -5812,15 +6153,25 @@ function sectionSigNow() {
 				out.title = id.name || "Video wallpaper";
 				out.playing = !vid.paused;
 				out.muted = !!vid.muted;
-				out.volume = typeof vid.volume === "number" ? vid.volume : 1;
+				out.volume = vol;
 				if (isFinite(vid.duration) && vid.duration > 0) out.total = Math.round(vid.duration);
 				const hasAudio = npVideoAudio(vid);
 				out.hasAudio = hasAudio;
-				out.canPlay = true;
+				/* ①(NP-4)② 联动关 ⇒ 播放/暂停**不许**碰壁纸媒体。视频档的声源就是这个视频本身
+				   ⇒ 关掉联动之后没有任何可控声源：如实禁用（不假装按得动），并说清是哪一条挡住的。 */
+				out.canPlay = link;
 				/* 明确知道"没有音轨"时静音键禁用（如实显示无音轨）；不知道就给用户按（可能真是静音了） */
 				out.canVolume = hasAudio !== false;
+				out.canSeek = link && typeof out.total === "number" && out.total > 0;
+				/* ①(NP-4)④ 视频档的"曲目"就是容器里那一条音轨：把 1/1 如实写出来
+				   （用户看到的是"清单里只有一条"，而不是"按钮莫名其妙是灰的"）。
+				   1/1 说的是**媒体条数**（进度条的主人只有一个），所以 hasAudio 判不出来
+				   （Firefox 有 mozHasAudio、Chromium 那套读不到 ⇒ null）时照样成立、照样写。 */
+				out.trackCount = hasAudio === false ? 0 : 1;
+				out.trackIndex = out.trackCount ? 1 : 0;
 				out.byline = hasAudio === false ? mpwT("np.noAudio")
-					: (hasAudio === true ? (id.name + " · " + mpwT("np.src.video")) : id.name);
+					: (id.name + " · " + mpwT("np.src.video") + " · 1/1");
+				if (!link) out.byline = mpwT("np.note.linkOff");
 				out.canPrev = false; out.canNext = false;   /* 单个媒体，没有曲目清单 */
 				return out;
 			}
@@ -5830,14 +6181,22 @@ function sectionSigNow() {
 				const n = cur.tracks.length;
 				const mime = cur.track && cur.track.mime ? String(cur.track.mime) : "audio";
 				const fname = String(cur.track && cur.track.path || "").split(/[\\/]/).filter(Boolean).pop() || id.name;
+				/* ①(NP-4)④ 包内音频（scan 的 source==='pkg'，文件在 scene.pkg 里）：清单是真的，
+				   但宿主**没有任何路由**能把它的字节取出来（实测 /custom-folder 404、/raw 403、
+				   /custom-media 403）⇒ 只列清单、如实标 disabled + 副标题写清原因。 */
+				const listOnly = String(cur.source || "") === "pkg";
 				out.kind = "track";
 				out.source = "tracks";
 				out.title = fname;
-				out.byline = id.name + " · " + mime + (n > 1 ? (" · " + (cur.index + 1) + "/" + n) : "");
-				out.canPlay = true;
+				out.listOnly = listOnly;
+				out.trackCount = n;
+				out.trackIndex = cur.index + 1;
+				out.byline = id.name + " · " + mime + (n > 1 ? (" · " + (cur.index + 1) + "/" + n) : "")
+					+ (listOnly ? (" · " + mpwT("np.note.pkgListOnly")) : "");
+				out.canPlay = !listOnly;
 				out.canVolume = true;
-				out.canPrev = n > 1;                     /* 只有一条 ⇒ 禁用（不假装有第二首） */
-				out.canNext = n > 1;
+				out.canPrev = n > 1 && !listOnly;        /* 只有一条 ⇒ 禁用（不假装有第二首） */
+				out.canNext = n > 1 && !listOnly;
 				out.hasAudio = true;
 				if (npAudio) {
 					out.playing = !npAudio.paused;
@@ -5845,6 +6204,8 @@ function sectionSigNow() {
 					if (isFinite(npAudio.duration) && npAudio.duration > 0) out.total = Math.round(npAudio.duration);
 					else if (npAudio.readyState === 0) out.total = null;
 				}
+				/* 我们自己的播放器一直归控件管（它就是"声音"本身）⇒ 与联动开关无关。 */
+				out.canSeek = typeof out.total === "number" && out.total > 0;
 				return out;
 			}
 			// ③ web 壁纸（目录里没有独立音频文件）：帧内那份声音只有静音这条真通道
@@ -5880,14 +6241,14 @@ function sectionSigNow() {
 				fetch(url).then((r) => (r && r.ok ? r.json() : null)).then((d) => {
 					if (seq !== npMediaToken) return;            // 迟到的应答丢掉（壁纸已经换了）
 					const tracks = (d && d.tracks) || [];
-					npMediaCache = { key: key, at: Date.now(), data: { count: d && d.count || 0, tracks: tracks } };
+					npMediaCache = { key: key, at: Date.now(), data: { count: d && d.count || 0, tracks: tracks, source: String(d && d.source || "") } };
 					if (npTrackIdx >= tracks.length) npTrackIdx = 0;
 					/* 壁纸换了 ⇒ 我们自己的播放器必须跟着换源（否则会放着上一张壁纸的歌） */
 					try { if (npAudio) { npAudio.pause(); npAudio.removeAttribute("src"); } } catch (e) {}
 					applyNowPlaying(readSection());
 				}).catch(() => {
 					if (seq !== npMediaToken) return;
-					npMediaCache = { key: key, at: Date.now(), data: { count: 0, tracks: [] } };
+					npMediaCache = { key: key, at: Date.now(), data: { count: 0, tracks: [], source: "" } };
 				});
 			} catch (e) {}
 		}
@@ -5933,6 +6294,74 @@ function sectionSigNow() {
 				for (const ev of ["loadedmetadata", "durationchange", "play", "pause", "volumechange", "timeupdate"]) {
 					try { video.addEventListener(ev, sync) } catch (e) {}
 				}
+				/* ①(NP-4) **谁把它停了**：真机上出现过"起播成功（promise resolve）之后又被暂停"
+				   （读数：prime-ok → paused=true）。只记账不改行为：给 pause() 包一层，把调用栈记进轨迹。
+				   包装保留原语义（返回原返回值、参数原样透传）。 */
+				/* 同一条纪律：`load()` 也会把元素打回 paused=true —— 一起记账（谁重置的要知道）。 */
+				try {
+					if (!video.__mpwLoadTraced && typeof video.load === "function") {
+						video.__mpwLoadTraced = true;
+						const origLoad = video.load.bind(video);
+						video.load = function () {
+							try {
+								const st = String(new Error().stack || "").split("\n").slice(2, 6)
+									.map(function (x) { return (x.trim().split(" ")[1] || "?").split("/").pop() }).join("<");
+								npOpTrace("video.load", null, st.slice(0, 180));
+							} catch (e) {}
+							return origLoad.apply(video, arguments);
+						};
+					}
+				} catch (e) {}
+				try {
+					if (!video.__mpwPauseTraced && typeof video.pause === "function") {
+						video.__mpwPauseTraced = true;
+						const origPause = video.pause.bind(video);
+						video.pause = function () {
+							try {
+								const st = String(new Error().stack || "").split("\n").slice(2, 6)
+									.map(function (x) { return (x.trim().split(" ")[1] || "?").split("/").pop() }).join("<");
+								npOpTrace("video.pause", null, st.slice(0, 180));
+							} catch (e) {}
+							return origPause.apply(video, arguments);
+						};
+					}
+				} catch (e) {}
+				/* ①(NP-4) `playing` = 真的出画/出声了。起播成功之后才把**静音与电平**落到元素上
+				   （顺序修法的收尾：muted 起播 → playing → 按设置取消静音），并且清掉"被拒"状态。 */
+				/* ①(NP-4) **被策略停住**的识别点：`pause` 事件 + 我们本来想让它放 + 用户没按过暂停
+				   + 还没真正放起来（currentTime 很小）⇒ 是浏览器把"没有手势的有声播放"停掉了。
+				   处理：退回 muted 让画面继续动，把原因记成可查状态，并装一次性手势重试补声音。 */
+				try {
+					video.addEventListener("pause", () => {
+						try {
+							if (wallUserPaused || powPaused) return;
+							if (!npWantPlay) return;
+							if (!(video.currentTime < 1.5)) return;    /* 放起来之后才停（播完/切源）⇒ 不关我们的事 */
+							if (npSoundBlocked) return;
+							npSoundBlocked = true;
+							npSoundReason = { at: Date.now(), currentTime: +video.currentTime.toFixed(2), muted: video.muted, hint: "没有用户手势时浏览器不允许有声播放（Firefox 会直接把它停住）" };
+							try { window.__mpwNpSoundBlocked = npSoundReason; } catch (e) {}
+							npOpTrace("audio-blocked", null, "退回 muted 保持画面；首次手势后补声音");
+							try { video.muted = true; } catch (e) {}
+							try {
+								const p = video.play();
+								if (p && typeof p.then === "function") {
+									p.then(() => { npOpTrace("audio-blocked-replay", null, "ok muted=" + video.muted + " paused=" + video.paused) },
+										(e) => { npOpTrace("audio-blocked-replay", null, "rejected:" + String(e && e.name || "Error")) });
+								} else { npOpTrace("audio-blocked-replay", null, "no-promise") }
+							} catch (e) { npOpTrace("audio-blocked-replay", null, "threw:" + String(e && e.name || "Error")) }
+							npArmGestureRetry();
+						} catch (e) {}
+					});
+				} catch (e) {}
+				try {
+					video.addEventListener("playing", () => {
+						/* 真的出画/出声了 ⇒ "muted 起播"那一段到此结束，把静音/电平恢复成设置值。 */
+						try { npPrimedMuted = false; clearTimeout(npPrimedMutedTimer); } catch (e) {}
+						try { npPlayBlocked = null; npApplyMute(); npApplyVolume(); } catch (e) {}
+						sync();
+					});
+				} catch (e) {}
 				sync();
 				return true;
 			} catch (e) { return false }
@@ -5962,7 +6391,7 @@ function sectionSigNow() {
 			let cur = null;
 			try { cur = npCurrentTrack(readSection()) } catch (e) { cur = null }
 			if (!cur || !npAudio) return;
-			const url = npTrackUrl(cur.scope, cur.track && cur.track.path);
+			const url = npTrackUrl(cur.scope, cur.track && cur.track.path, cur.source);
 			if (!url || npAudioBlobTried === url) {
 				try { console.warn("[dsh-mpkg-wallpaper] np: 音轨加载失败（宿主 /raw 或解码不支持）: " + url) } catch (e) {}
 				try { if (npCtl) { npCtl.setMedia({ playing: false, canPlay: false, byline: mpwT("np.note.decode") }); npCtl.setProgress(0); } } catch (e) {}
@@ -6001,13 +6430,14 @@ function sectionSigNow() {
 			if (!cur) return false;
 			const a = npEnsureAudio();
 			if (!a) return false;
-			const url = npTrackUrl(cur.scope, cur.track && cur.track.path);
+			const url = npTrackUrl(cur.scope, cur.track && cur.track.path, cur.source);
 			if (!url) return false;
 			npAudioBlobTried = "";
 			try {
 				if (String(a.getAttribute("src") || "") !== url) a.setAttribute("src", url);
 				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(() => {}); }
 			} catch (e) { mpwErr("npLoadTrack", e) }
 			npApplyFrameMute();
@@ -6020,7 +6450,7 @@ function sectionSigNow() {
 		function npApplyMute() {
 			const s = readSection();
 			const mute = s.mute !== void 0 ? !!s.mute : true;
-			try { const v = npActiveVideo(s); if (v && v.muted !== mute) v.muted = mute; } catch (e) {}
+			try { const v = npActiveVideo(s); const w = (npPrimedMuted || npSoundBlocked) ? true : mute; if (v && v.muted !== w) v.muted = w; } catch (e) {}
 			try { if (npAudio && npAudio.muted !== mute) npAudio.muted = mute } catch (e) {}
 			try { applyVideoMute(); } catch (e) {}
 			npApplyFrameMute();
@@ -6038,47 +6468,86 @@ function sectionSigNow() {
 		 *   prev/next   清单里的上一条/下一条（环形）
 		 *   mute        既有设置项 `mute` + **真的落到元素**（video/audio/帧内 + 宿主 /media-audio 上报）
 		 */
-		function npTransport(op, section) {
+		function npTransport(op, section, value) {
 			const s = section || readSection();
+			const link = npLinkOn(s);
+			/* ①(NP-4) 传输动作的**可查轨迹**（最近 32 条：op / value / 有没有真的落到某个元素）。
+			   为什么要留它：真机上"点了没反应"这一类问题，界面与设置都看不出"动作到底走到哪一步"
+			   （修前那次 NotAllowedError 就是这么消失的）。它只记账，零行为影响，排障与探针都读它。 */
+			let did = "";
+			const trace = () => npOpTrace(op, value, did || "no-target");
 			try {
 				if (op === "play" || op === "pause") {
 					const vid = npActiveVideo(s);
-					if (vid) {
-						if (op === "play") { const p = vid.play(); if (p && p.catch) p.catch(() => {}); }
-						else vid.pause();
+					/* ①(NP-4)② 联动开 ⇒ 壁纸媒体一起动；关 ⇒ **一个字节都不碰壁纸**（画面不受控件影响）。 */
+					if (vid && link) {
+						if (op === "play") { npSetUserPaused(vid, false); npPrimePlay(vid); did = "video.play"; }
+						else { npWantPlay = false; npSetUserPaused(vid, true); vid.pause(); did = "video.pause"; }
+						npApplyFrameMute();
 					} else {
 						const list = npTrackList(s);
 						if (list && list.tracks.length) {
 							if (op === "play") {
 								const a = npEnsureAudio();
 								/* 还没装源（清单刚到/换过壁纸）⇒ 先装当前曲目再放 */
-								if (a && !String(a.getAttribute("src") || "")) npLoadTrack(true);
-								else if (a) { const p = a.play(); if (p && p.catch) p.catch(() => {}); }
-							} else if (npAudio) npAudio.pause();
-						} else {
+								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 (npAudio) { npAudio.pause(); did = "audio.pause"; }
+						} else if (!vid) {
 							/* 清单还没到：拉一次，到位后由 applyNowPlaying 把键的状态刷新（不假装按过了） */
 							npFetchTracks(s);
+							did = "fetch-tracks";
+						} else {
+							/* ①(NP-4) 有壁纸媒体但**联动关** ⇒ 这里就是"一个字节都不碰"的那条路。 */
+							did = "skip(link-off)";
 						}
 						/* ①(NP-3) 播放状态变了 ⇒ 帧内静音策略要重算（我们在放音时帧内强制静音） */
 						npApplyFrameMute();
 					}
 				} else if (op === "next" || op === "prev") {
-					npStepTrack(op === "next" ? 1 : -1, true);
+					did = npStepTrack(op === "next" ? 1 : -1, true) ? "step" : "step(nolist)";
 				} else if (op === "restart") {
 					/* ①(NP-3) 保留 op（兼容旧调用/排障），但 UI 里的"回到开头"已换成上一首/下一首。 */
 					const vid = npActiveVideo(s);
 					if (vid) { try { vid.currentTime = 0 } catch (e) {} }
 					else if (npAudio) { try { npAudio.currentTime = 0 } catch (e) {} }
+				} else if (op === "seek") {
+					/* ①(NP-4)③ 拖动落点：`value` 是**相对当前媒体时长**的 0..1（控制器算好送进来）。
+					   口径（与②的联动同一条，判据见 docs/NOW-PLAYING-DSH.md §7.8）：
+					     · 联动开 ⇒ **真的落到当前媒体的 currentTime**（壁纸媒体 + 我们自己的播放器，
+					       谁在放就落谁；视频档就是那个 <video>）；
+					     · 联动关 ⇒ 只落到**我们自己的播放器**（"只影响声音"）；壁纸媒体一个字节都不碰。
+					   轨道只有一个所有者（npResolveMedia 视频/曲目两条各自 return），所以
+					   这里的 ratio 不会出现"同一根带子对应两个时长"的歧义。 */
+					const r = Math.max(0, Math.min(1, Number(value) || 0));
+					const vid = npActiveVideo(s);
+					if (vid && link && isFinite(vid.duration) && vid.duration > 0) {
+						try { vid.currentTime = r * vid.duration; did = "video.seek=" + vid.currentTime.toFixed(2) } catch (e) {}
+					} else if (vid && !link) { did = "skip(link-off)" }
+					if (npAudio && isFinite(npAudio.duration) && npAudio.duration > 0) {
+						try { npAudio.currentTime = r * npAudio.duration; did += (did ? "+" : "") + "audio.seek=" + npAudio.currentTime.toFixed(2) } catch (e) {}
+					}
+				} else if (op === "volume") {
+					/* ①(NP-4)① 电平（0..1）：写设置项 `npVolume`（0..100）并**真的落到元素**
+					   （video / 我们自己的播放器 / web 帧 + shim 主音量）。与静音键是两件事：
+					   静音键动的是既有 `mute` 开关，这里动的是电平。 */
+					const level = Math.max(0, Math.min(1, Number(value) || 0));
+					saveSection({ npVolume: Math.round(level * 100) });
+					npApplyVolume(true);           /* 用户明确拖了电平 ⇒ 无论默认与否都落到实处 */
+					did = "volume=" + Math.round(level * 100);
 				} else if (op === "mute") {
 					// ①(NP-1) 静音走**既有**设置项（mute）：这样视频/web 两条路径都由既有接线负责，
 					//   不在这里另写一套；同时把状态如实报到宿主 media-audio 契约（WP-1 新增）。
 					// ①(NP-3) 关键补齐：写完设置**必须真的落到元素**（下面这行 npApplyMute()）。
+					// ①(NP-4) 静音是**壁纸级**设置（设置面板里就有这一行），不受联动开关管：
+					//   关掉联动只影响"传输键要不要驱动壁纸的播放/进度"，不改变"静音"这条既有语义。
 					const next = !(s.mute !== void 0 ? !!s.mute : true);
 					saveSection({ mute: next });
 					npApplyMute();
-					try { fetch(HOST_BASE + "/media-audio", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ muted: next }) }).catch(() => {}); } catch {}
+					did = "mute=" + next;
 				}
-			} catch (e) { mpwErr("npTransport", e); }
+			} catch (e) { mpwErr("npTransport", e); did = "error:" + String(e && e.message || e).slice(0, 60); }
+			trace();
 			setTimeout(() => { try { applyNowPlaying(readSection()); } catch {} }, 60);
 		}
 
@@ -6097,7 +6566,7 @@ function sectionSigNow() {
 					t: (k) => { try { return mpwT(k); } catch (e) { return k; } },
 					doc: document, win: window,
 					log: console,
-					onTransport: (op) => npTransport(op, readSection()),
+					onTransport: (op, value) => npTransport(op, readSection(), value),
 				});
 				npCtl = mod.createController();
 				npSlotAction = mod.createSlotAction(npCtl);
@@ -6144,8 +6613,24 @@ function sectionSigNow() {
 				return;
 			}
 			ctl.setEnabled(true);
-			/* ①(NP-3) 视频壁纸：先把媒体事件接上（元数据到了要重解，否则音轨判定会一直停在旧值） */
-			try { const vid = npActiveVideo(s); if (vid) npWatchVideo(vid); } catch (e) {}
+			/* ①(NP-4) 换了壁纸/换了源 ⇒ "用户按过暂停"清零（新源按自动播放的规则重新起播）。 */
+			/* ①(NP-4) 这里**不**再判"源变了没有"：`video.getAttribute('src')` 是**解析后**的 URL
+			   （`/api/mpkg-wallpaper/custom-folder/…`），而 `section.image` 是 `host:?…` 形态，
+			   两者恒不相等 ⇒ 每次 apply 都会把"用户按过暂停"清掉、60ms 后又把播放续上
+			   （真机读数：`pause → video.pause` 之后紧跟 `prime: calling-play`）。
+			   换源时清零这件事由 `showVideoEl` 在**真的重设 src 那一行**做（那里才拿得到真相）。 */
+			/* ①(NP-3) 视频壁纸：先把媒体事件接上（元数据到了要重解，否则音轨判定会一直停在旧值）。
+			   ①(NP-4) 起播门控也在这里补一次：`showVideoEl` 只在**设置变化**那条路径上跑，
+			   而"刷新页面"那条路径上视频是被 `applyFromStorage` 装进来的 —— 不在这里补，
+			   刷新之后就没有人再调 play()（真机读数：全程只调用过一次 play()，还被拒）。 */
+			try {
+				const vid = npActiveVideo(s);
+				if (vid) { npWatchVideo(vid); if (vid.paused && !npPlayBlocked) npPrimePlay(vid); }
+			} catch (e) {}
+			/* ①(NP-4)② 联动开关落点（只写一个可查询属性 + 影响媒体源的 canPlay/canSeek 派生量）。 */
+			try { ctl.setLink(npLinkOn(s)); } catch (e) {}
+			/* ①(NP-4)① 电平：刷新/切壁纸后把 `npVolume` 补落到真实元素上。 */
+			try { npApplyVolume(); } catch (e) {}
 			ctl.setMedia(npResolveMedia(s));
 			/* ①(NP-3) 清单/播放器：有目录作用域才拉清单；清单到了之后把当前曲目装进播放器
 			   （**只装源、不自动播放** —— 浏览器自动播放策略 + "不替用户按播放"两条都要求这样）。 */
@@ -6886,6 +7371,10 @@ function sectionSigNow() {
 				legacy: () => mpwPersistLegacy(),
 				state: () => Object.assign({}, mpwPersistState),
 				apply: () => { try { applyFromStorage() } catch (e) { return String((e && e.message) || e) } return "ok" },
+				/* ①(2026-09-19) "部分档写入"的真实入口：`writeSection` 拿到**没带源字段**的 next 时，
+				   粘性护栏必须把源保住（真机上 `initHostSettings` 的宿主合成结果、`mpwMarkPersistFail`
+				   的留痕写都会经过这条路）。暴露它才能把这条护栏变成断言而不是"看代码觉得对"。 */
+				writePartial: (next) => { try { writeSection(next || {}, true); return true } catch (e) { return String(e && e.message || e) } },
 				onMsg: (fn) => mpwPersistOnMsg(fn),
 				takePending: () => mpwPersistTakePending(),
 				failKey: MPW_PERSIST_FAIL_KEY,
@@ -6959,11 +7448,11 @@ function sectionSigNow() {
 			globalThis.__mpwNpTest = {
 				scope: (section) => { try { return npAudioScope(section || readSection()) } catch (e) { return { err: String(e && e.message || e) } } },
 				scanUrl: (section) => { try { return npScanUrl(npAudioScope(section || readSection())) } catch (e) { return "ERR " + (e && e.message || e) } },
-				trackUrl: (section, p) => { try { return npTrackUrl(npAudioScope(section || readSection()), p) } catch (e) { return "ERR " + (e && e.message || e) } },
+				trackUrl: (section, p, src) => { try { return npTrackUrl(npAudioScope(section || readSection()), p, src) } catch (e) { return "ERR " + (e && e.message || e) } },
 				activeVideo: (section) => { const v = npActiveVideo(section || readSection()); return v ? true : false },
 				videoAudio: (section) => npVideoAudio(npActiveVideo(section || readSection())),
 				resolve: (section) => { try { return npResolveMedia(section || readSection()) } catch (e) { return { err: String(e && e.message || e) } } },
-				transport: (op, section) => { try { npTransport(op, section || readSection()); return true } catch (e) { return String(e && e.message || e) } },
+				transport: (op, section, value) => { try { npTransport(op, section || readSection(), value); return true } catch (e) { return String(e && e.message || e) } },
 				audio: () => npAudio,
 				idx: () => npTrackIdx,
 				load: (i) => { try { if (typeof i === "number") npTrackIdx = Math.max(0, i); return npLoadTrack(false) } catch (e) { return String(e && e.message || e) } },
@@ -6971,10 +7460,12 @@ function sectionSigNow() {
 				ownsSound: () => npAudioOwns(),
 				/* 夹具：把"宿主扫描路由的应答"直接塞进缓存（等价于 npFetchTracks 的成功回调）。
 				   入参是 **section**（不是 scope）：作用域由 npAudioScope 自己算 —— 与生产同一条口径。 */
-				seedTracks: (section, tracks) => {
+				seedTracks: (section, tracks, source) => {
 					try {
 						const s = npAudioScope(section || readSection());
-						npMediaCache = { key: npScopeKey(s), at: Date.now(), data: { count: (tracks || []).length, tracks: tracks || [] } };
+						/* ①(NP-4)④ 第三个入参 = 宿主扫描应答里的 `source`（'dir' | 'pkg'）：
+						   'pkg' 表示音轨在 scene.pkg 里 ⇒ 只能列清单、不能播（判据见 A9a4/D 组）。 */
+						npMediaCache = { key: npScopeKey(s), at: Date.now(), data: { count: (tracks || []).length, tracks: tracks || [], source: String(source || "") } };
 						npTrackIdx = 0;
 						return npMediaCache.key;
 					} catch (e) { return String(e && e.message || e) }
@@ -6983,6 +7474,21 @@ function sectionSigNow() {
 				/* 走**真 apply 路径**（applyNowPlaying 本身；测试/真机排障都用它手动重放一次） */
 				apply: (section) => { try { applyNowPlaying(section || readSection()); return true } catch (e) { return String(e && e.message || e) } },
 				dropAudio: () => { try { npDropAudio(); return true } catch (e) { return String(e && e.message || e) } },
+				/* ══ ①(NP-4)① ② ③ 的新钩子（驱动的是**生产实现本身**，不是副本） ══
+				   音量 / 联动 / 起播顺序 / 拖动落点这四件事的判据全走这里，见 tools/np-control-test.mjs。 */
+				volume: () => { try { return npWantVolume() } catch (e) { return String(e && e.message || e) } },
+				wantMuted: () => { try { return npWantMuted() } catch (e) { return String(e && e.message || e) } },
+				link: (section) => { try { return npLinkOn(section || readSection()) } catch (e) { return String(e && e.message || e) } },
+				applyVolume: (force) => { try { npApplyVolume(force === true); return true } catch (e) { return String(e && e.message || e) } },
+				volumeSet: () => { try { return npVolumeSet() } catch (e) { return String(e && e.message || e) } },
+				playBlocked: () => npPlayBlocked,
+				primePlay: (section) => { try { const v = npActiveVideo(section || readSection()); return v ? npPrimePlay(v) : "no-active-video" } catch (e) { return String(e && e.message || e) } },
+				primedMuted: () => !!npPrimedMuted,
+				userPaused: () => npUserPausedOf(npActiveVideo(readSection())),
+				soundBlocked: () => !!npSoundBlocked,
+				trackList: (section) => { try { const l = npTrackList(section || readSection()); return l ? { key: l.key, source: l.source, paths: l.tracks.map((t) => t.path) } : null } catch (e) { return String(e && e.message || e) } },
+				step: (dir) => { try { return npStepTrack(dir, false) } catch (e) { return String(e && e.message || e) } },
+				trackIdx: () => npTrackIdx,
 			};
 			globalThis.__mpwSectionTest = {
 				read: () => { try { const s = readSection() || {}; return { bsCompat: s.bsCompat, bsCompatUserSet: s.bsCompatUserSet === true, headerFrostUserSet: s.headerFrostUserSet === true } } catch (e) { return { err: String(e && e.message || e) } } },
@@ -7771,7 +8277,7 @@ module.exports = {
    组件本体（几何/形变/那套"一个数就是全部状态"的设计）来自 **Bencho** 的 "Now playing"
    （上游文件 `Sound.tsx` + 随附样式表），上游作者 Bencho，许可 **MIT**（bencho.dev/licence）。
    移植方式：**逐行移植、注释原文保留**（用户原话："它们解释了这些数字为什么是这个值，
-   也是这份代码值得照抄而不是重写的主要原因"）。归属见 `THIRD-PARTY.md` §13；
+   也是这份代码值得照抄而不是重写的主要原因"）。归属见 `THIRD-PARTY.md` §6（①2026-09-19 复核更正：原先指向 §13，该节实际是别的条目）；
    跨仓台账见 `../docs/COPYING-RULES.md` §4。
    ⚠ **本文件不含任何 GPL 代码**：`we-scene-demo/demo/now-playing/**`（GPL-3.0-or-later）
    只被**读来核对数学**，一行都没有拷进来（`../docs/COPYING-RULES.md` §2.2 "GPL 永不进插件"）。
@@ -7868,6 +8374,10 @@ const NP_ROOT_COLLAPSED_TOKEN = "collapsed";
    这一层是**降级链**而不是两套实现：容器只有一个，位置只有一个来源，谁先可用就用谁。 */
 const NP_SLOT_ATTR = "data-mpw-np-slot";
 const NP_SLOT_SEL = "[data-mpw-np-slot]";
+/* ── ①(NP-4)② 联动开关（"播放/暂停是否同时控制壁纸的播放/暂停"）的可查询落点 ────────
+   开关本身在设置面板里（放 Now playing 之下，NP 关掉就撤掉那一行）；组件根上这个属性是
+   真机探针/门禁读"当前是哪一档"的唯一入口（不靠读设置文件，避免两处口径）。 */
+const NP_LINK_ATTR = "data-mpw-np-link";
 /* ── ①(NP-3) 让位：宿主同一位置已经有别的插件注入的元素时不挂/撤下 ─────────────
    值就是原因串（可读、可查询）：`foreign-occupant`（容器里出现了非本插件、非宿主自有的元素）。
    写在我们自己的 slot div 上（宿主 slot 出口是我们唯一"永远属于自己"的节点，即使没挂载也在），
@@ -7915,6 +8425,19 @@ const HEART_D = "M12 20.4c-4.9-3.2-7.6-6.2-7.6-9.5A4.15 4.15 0 0 1 12 8.1a4.15 4
 const VOL_MUTE_D = "M4 9.4h3.1L11.4 6v12L7.1 14.6H4z M15.2 9.6l4 4.8 M19.2 9.6l-4 4.8";
 const VOL_ON_D = "M4 9.4h3.1L11.4 6v12L7.1 14.6H4z M14.6 9.2a3.9 3.9 0 0 1 0 5.6 M17 6.8a7.4 7.4 0 0 1 0 10.4";
 
+/* ── ①(NP-4) 拖动：进度 seek + 音量，共用**一条**换算 ──────────────────────────
+   为什么两条要合一条：两者都只是"指针横坐标 → 0..1"，差别只在把 0..1 交给谁。
+   分成两份实现就会出现"一个按内边距盒算、一个按边框盒算"这种只在某一态偏几像素的
+   分歧（上游那张样式表在别处也吃过同一种亏：同一个位置有两个意见）。
+   `ratioOf` 是纯函数（只吃 rect + clientX）⇒ 无浏览器门禁可以直接喂矩形断言边界值。 */
+const NP_SCRUB_PAD = 9;         /* 轨道只有 3px（RAIL_H），命中带上下各补 9px ⇒ 共 21px，够手指 */
+const NP_VOL_W = 84;            /* 音量条的可见宽度（卡片 260 宽里时钟行放得下，见 §几何） */
+/* ⑤ 悬浮态放大：容器能往两侧各"借"多少像素。
+   上限 12 而不是"能借多少借多少"：借来的宽度是宿主自己的内边距（悬浮态 12px），
+   贴到内边距盒边缘虽然不算裁切，但卡片会顶到宿主圆角卡片的边上。
+   12 与本机实测的悬浮内边距相等 ⇒ 卡片的左右各留 1px 余量（判据见 np-control-live 的 G 组）。 */
+const NP_BLEED_MAX = 12;
+
 /* ── 样式：全部落在 [data-mpw-now-playing] / .mpw_np* -------------------------
    上游那张样式表的原文注释保留在对应规则上。这里**故意不出现** sidebarCol / footArea /
    settingsArea / .hHd-Xa_* 任何一个名字：style-scope-guard 的 SURFACES 里"侧栏"的
@@ -8191,8 +8714,133 @@ body[data-ds-dark-theme] [data-mpw-now-playing] {
 	.mpw_np_op, .mpw_np_art, .mpw_np_like { transition-duration: 1ms; }
 	.mpw_np_like.mpw_np_on .mpw_np_ic { animation: none; }
 }
+/* ══ ①(NP-4) 拖动（进度 seek + 音量）══
+   两条都是自绘的（不用 input[type=range]）：本组件的每个位置都由补间逐帧写成内联样式，
+   浏览器原生控件的高度/内边距/thum 尺寸在各家实现里都不一样，塞进来就是"第二个意见"。
+   规则只写**材料**（颜色/圆角/命中带），位置与长度一律由 JS 内联写。 */
+/* the scrubber —— 轨道只有 3px，命中带上下各补 9px（NP_SCRUB_PAD）。
+   它绝对定位在 .mpw_np_bar 里（那条是 position:absolute ⇒ 自己是包含块），
+   **不参与** 那一列的 flex 流 ⇒ 时钟/进度条的布局一个像素都不动（放大那件事不留回归）。 */
+.mpw_np_scrub {
+	position: absolute;
+	left: 0;
+	width: 100%;
+	pointer-events: auto;
+	cursor: pointer;
+	touch-action: none;
+	background: transparent;
+}
+/* 没有可 seek 的媒体时：命中带仍然在（判据要能量到它），但不给"能拖"的指针语义 */
+.mpw_np_scrub[data-mpw-np-noseek] { cursor: default; }
+/* the rail 的可见部分保持 3px；拖动时只把游标点亮，不改几何 */
+.mpw_np_rail { position: relative; }
+.mpw_np_scrub[data-mpw-np-drag] ~ .mpw_np_clock { color: var(--mpw-np-ink-3); }
+/* the level —— 卡片里时钟行的中间那一段（左时刻 / 音量 / 右剩余）。
+   收起态整行随 late 淡出，音量条与时钟同一条约定：只在卡片里存在。 */
+.mpw_np_vol { flex: 1 1 auto; display: flex; align-items: center; justify-content: center; min-width: 0; }
+.mpw_np_volHit {
+	position: relative;
+	display: block;
+	width: 84px;              /* = NP_VOL_W，两端实测一致（css-matrix 有一条对拍） */
+	height: 12px;             /* 命中带；可见轨道只有 2px，居中 */
+	pointer-events: auto;
+	cursor: pointer;
+	touch-action: none;
+}
+.mpw_np_volRail {
+	position: absolute; left: 0; right: 0; top: 50%; height: 2px; margin-top: -1px;
+	border-radius: 999px; background: rgba(var(--mpw-np-ink-rgb), 0.16);
+}
+.mpw_np_volRun {
+	position: absolute; left: 0; top: 50%; height: 2px; margin-top: -1px;
+	border-radius: 999px; background: var(--mpw-np-ink);
+}
+.mpw_np_volKnob {
+	position: absolute; top: 50%; width: 7px; height: 7px; margin: -3.5px 0 0 -3.5px;
+	border-radius: 999px; background: var(--mpw-np-ink);
+}
+.mpw_np_volHit:focus-visible, .mpw_np_scrub:focus-visible {
+	outline: none;
+	box-shadow: 0 0 0 2px var(--mpw-np-card), 0 0 0 4px rgba(var(--mpw-np-ink-rgb), 0.35);
+}
 `;
 
+
+/* ── ①(NP-4) 拖动换算与借宽判据（**模块作用域**的纯函数） ──────────────────────
+   为什么放在模块作用域而不是工厂里：它们一行 DOM 都不碰（只吃矩形 + 一个计算样式函数），
+   放在这里无浏览器门禁可以直接喂矩形断言边界值（tools/np-control-test.mjs 的 F 组），
+   不必为了测"指针横坐标 → 0..1"去装一整个控制器。工厂里只留绑定 win / NP_BLEED_MAX 的薄壳。
+   两条拖动条（进度 seek / 音量）共用同一条换算：两者都只是"指针横坐标 → 0..1"，
+   差别只在把 0..1 交给谁。分两份实现就会出现"一个按内边距盒算、一个按边框盒算"这种
+   只在某一态偏几像素的分歧（上游那张样式表在别处也吃过同一种亏：同一个位置有两个意见）。 */
+const npClamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+/** 指针横坐标 → 0..1（夹住：滑出条外仍然最左/最右，不回弹、不越界）。 */
+function ratioOf(rect, clientX) {
+  if (!rect) return 0;
+  const w = Number(rect.width);
+  if (!(w > 0)) return 0;
+  const x = Number(clientX);
+  if (!isFinite(x)) return 0;
+  return npClamp((x - Number(rect.left)) / w, 0, 1);
+}
+/** 键盘步进（←/↓ 与 →/↑ 各一步、Home/End 到端点）；不是这些键返回 null（不吞别的键）。 */
+function stepRatio(cur, key, step) {
+  const st = Number(step) > 0 ? Number(step) : 0.02;
+  const c = npClamp(Number(cur) || 0, 0, 1);
+  if (key === "Home") return 0;
+  if (key === "End") return 1;
+  if (key === "ArrowLeft" || key === "ArrowDown") return npClamp(c - st, 0, 1);
+  if (key === "ArrowRight" || key === "ArrowUp") return npClamp(c + st, 0, 1);
+  return null;
+}
+/** 最近一个**会裁切**的祖先的内边距盒 = 硬边界（⑤ 的"不许被裁切"就是不许越过它）。
+    量不到（假 DOM / 没有 getComputedStyle）⇒ null，调用方按"不放大"处理。 */
+function clipPadBox(el, getCS) {
+  try {
+    let cur = el;
+    /* 从容器自己开始往上走（容器是我们自己的节点，overflow 是 visible ⇒ 第一轮就跳过）；
+       循环条件只判 `cur`：写成 `cur && cur.parentElement` 会把**最上面那个**祖先漏掉
+       —— 真机上恰好是它（列元素）带 overflow:hidden，漏了就等于没有硬边界（借宽会越界）。 */
+    while (cur) {
+      const cs = getCS ? getCS(cur) : null;
+      const ov = cs ? String(cs.overflow || "") + String(cs.overflowX || "") + String(cs.overflowY || "") : "";
+      if (ov && ov.indexOf("visible") < 0) {
+        const r = cur.getBoundingClientRect ? cur.getBoundingClientRect() : null;
+        if (!r) return null;
+        const pad = (v) => { const n = parseFloat(v); return isFinite(n) ? n : 0 };
+        return {
+          left: Number(r.left) + (cs ? pad(cs.paddingLeft) : 0),
+          right: Number(r.right) - (cs ? pad(cs.paddingRight) : 0),
+          node: cur,
+        };
+      }
+      cur = cur.parentElement;
+    }
+  } catch (e) {}
+  return null;
+}
+/** ⑤ 悬浮态放大：容器能往左右各"借"多少像素。
+    借的是**容器到最近裁切祖先内边距盒之间那段空档**（宿主自己的内边距，本来是空的）。
+    `applied` 是当前已经借出去的量 —— 必须减掉再算，否则量到的是加宽后的盒子、
+    算出来只剩 1px、下一帧又缩回去：**抖动**（"同一件事两个意见"在本文件里出现过一次）。
+    借多少的硬上限是 NP_BLEED_MAX（见常量处），不贴宿主圆角卡片的边。 */
+function bleedFor(container, applied, maxBleed, getCS) {
+  if (!container || !container.getBoundingClientRect) return 0;
+  const cs = getCS || (typeof getComputedStyle === "function" ? getComputedStyle : null);
+  const clip = clipPadBox(container, cs);
+  if (!clip) return 0;
+  let r = null;
+  try { r = container.getBoundingClientRect(); } catch (e) { return 0 }
+  if (!r) return 0;
+  const back = Number(applied) > 0 ? Number(applied) : 0;
+  const baseL = Number(r.left) + back, baseR = Number(r.right) - back;
+  const budgetL = baseL - clip.left, budgetR = clip.right - baseR;
+  const b = Math.floor(Math.min(budgetL, budgetR));
+  if (!(b > 0)) return 0;
+  const cap = Number(maxBleed) > 0 ? Number(maxBleed) : NP_BLEED_MAX;
+  return Math.min(b, cap);
+}
+
 /* ══════════════════════════════════════════════════════════════════════════════
    组件
    ══════════════════════════════════════════════════════════════════════════════ */
@@ -8375,6 +9023,10 @@ function createNowPlaying(deps) {
     /* ①(NP-3) 第四个键（音量/静音）只在深半边存在（见文件头差异 3）。 */
     const showVolume = late > 0;
     const markCur = M.clamp(Number(q.mark) || 0, 0, 1);
+    /* ①(NP-4) 音量（0..1）与"这条轨道能不能拖"都由控制器送进来（默认值 = 不改既有行为：
+       音量 1、能不能拖跟"有没有已知时长"走）。 */
+    const vol = M.clamp(Number(q.volume) >= 0 ? Number(q.volume) : (Number(media.volume) >= 0 ? Number(media.volume) : 1), 0, 1);
+    const canSeek = q.canSeek === void 0 ? known : !!q.canSeek;
 
     const artStyle = {
       left: M.artX(), top: M.artY(), width: art, height: art,
@@ -8410,8 +9062,60 @@ function createNowPlaying(deps) {
               className: "mpw_np_run",
               style: { width: (known ? M.runPct(at) : 0) + "%" },
             })),
+          /* ①(NP-4)③ 进度条可拖动：命中带绝对定位在 bar 上（**不进**那一列的 flex 流），
+             所以时钟与轨道的布局一个像素都不动。轨道只有 3px，命中带上下各补 NP_SCRUB_PAD。
+             落点由控制器交给 client.js 的接线（口径见 docs/NOW-PLAYING-DSH.md §7.8）：
+             联动开 ⇒ 真的落到**当前媒体的 currentTime**；联动关 ⇒ 只落到我们自己的播放器；
+             两样都没有 ⇒ 这条带子是只读的（data-mpw-np-noseek，不假装能拖）。 */
+          h("span", {
+            className: "mpw_np_scrub",
+            "data-mpw-np-scrub": "",
+            "data-mpw-np-noseek": canSeek ? void 0 : "",
+            "data-mpw-np-drag": q.dragging ? "" : void 0,
+            role: "slider",
+            tabIndex: canSeek ? 0 : -1,
+            "aria-label": t("np.seek"),
+            "aria-valuemin": 0, "aria-valuemax": known ? media.total : 0,
+            "aria-valuenow": known ? Math.round(at) : 0,
+            "aria-disabled": canSeek ? void 0 : true,
+            style: {
+              /* ⚠ 这个 `top` 是**相对 `.mpw_np_bar`** 的（bar 自己已经在 `top: barTop(p)`），
+                 所以只能是 `-NP_SCRUB_PAD`。写成 `barTop(p) - NP_SCRUB_PAD` 会把偏移**加两遍**
+                 ⇒ 命中带落到卡片外面（真机读数：卡片 620..787，命中带 781.95..800.53，
+                 中心点在卡片之下、被同一行的宿主元素接走 ⇒ 拖动事件根本到不了控件）。
+                 几何不变量（门禁 F12 断言）：barTop(p)+RAIL_H+NP_SCRUB_PAD ≤ boxHeight(p)。 */
+              top: -NP_SCRUB_PAD, left: 0, width: "100%",
+              height: M.RAIL_H + NP_SCRUB_PAD * 2,
+            },
+            onPointerDown: (e) => { if (q.onScrubStart) q.onScrubStart(e); },
+            onPointerMove: (e) => { if (q.onScrubMove) q.onScrubMove(e); },
+            onPointerUp: (e) => { if (q.onScrubEnd) q.onScrubEnd(e); },
+            onPointerCancel: (e) => { if (q.onScrubEnd) q.onScrubEnd(e); },
+            onKeyDown: (e) => { if (q.onScrubKey) q.onScrubKey(e); },
+          }),
           h("span", { className: "mpw_np_clock", style: { opacity: late } },
             h("span", null, M.clock(at)),
+            /* ①(NP-4)① 音量：**与静音开关分开的第二件事**（用户原话："打开之后也不能调整它
+               开启的音量"）。它只在卡片里存在 —— 与第四个键同一条 late 约定。 */
+            showVolume ? h("span", { className: "mpw_np_vol" },
+              h("span", {
+                className: "mpw_np_volHit",
+                "data-mpw-np-vol": "",
+                role: "slider",
+                tabIndex: media.canVolume ? 0 : -1,
+                "aria-label": t("np.volume"),
+                "aria-valuemin": 0, "aria-valuemax": 100,
+                "aria-valuenow": Math.round(vol * 100),
+                "aria-disabled": media.canVolume ? void 0 : true,
+                onPointerDown: (e) => { if (q.onVolStart) q.onVolStart(e); },
+                onPointerMove: (e) => { if (q.onVolMove) q.onVolMove(e); },
+                onPointerUp: (e) => { if (q.onVolEnd) q.onVolEnd(e); },
+                onPointerCancel: (e) => { if (q.onVolEnd) q.onVolEnd(e); },
+                onKeyDown: (e) => { if (q.onVolKey) q.onVolKey(e); },
+              },
+                h("span", { className: "mpw_np_volRail" }),
+                h("span", { className: "mpw_np_volRun", style: { width: (vol * 100) + "%" } }),
+                h("span", { className: "mpw_np_volKnob", style: { left: (vol * 100) + "%" } }))) : null,
             /* 数据源没有时长时**不假装**：显示 --:--（见 docs/NOW-PLAYING-DSH.md §4 情形②） */
             h("span", null, known ? ("−" + M.clock(M.remain(at))) : "--:--"))),
         h("button", {
@@ -8468,6 +9172,8 @@ function createNowPlaying(deps) {
     kind: "none", title: "", byline: "", cover: "",
     total: null, playing: false, muted: true, volume: 1,
     canPlay: false, canVolume: false, canPrev: false, canNext: false, hasAudio: null,
+    /* ①(NP-4) 空闲态也把这三项写全：谁读都不该读到 undefined（空闲态 = 不能拖、联动开）。 */
+    canSeek: false, link: true,
   };
 
   /** ①(NP-3) 纯判据：容器里有没有**非本插件**的占用者（让位逻辑的核心，可单独测）。
@@ -8555,8 +9261,15 @@ function createNowPlaying(deps) {
     /* 宿主**自己的**"宽/收起"信号（来自 slot 的 ownerProps.wide）。null = 这版宿主没给。
        ①(NP-2) 它现在只在**量不到物理宽度**时参与判据（见 shouldHide 三档与 hostSaysCollapsed）。 */
     let hostWide = null;
+    /* ── ①(NP-4) 拖动状态 ───────────────────────────────────────────────────────
+       `drag` = 正在拖哪一条（"" / "seek" / "vol"）。拖动期间**媒体事件推来的进度不再回写**
+       （否则手指按着不放，播放器每 250ms 的 timeupdate 会把游标拽回当前播放位置：
+       真机表现就是"拖不动/拖了弹回去"）。松手（或 pointercancel）立刻恢复回写。 */
+    let drag = "";
+    /* ⑤ 当前已经借出去的左右像素（bleedFor 要用它把"量到的盒子"还原成"没借之前的盒子"）。 */
+    let bleedNow = 0;
     const counts = { resize: 0, mutation: 0, raf: 0 };
-    const state = { open: false, playing: false, at: 0, media: Object.assign({}, IDLE_MEDIA) };
+    const state = { open: false, playing: false, at: 0, volume: null, canSeek: false, media: Object.assign({}, IDLE_MEDIA) };
 
     function raf(fn) {
       if (win && typeof win.requestAnimationFrame === "function") return win.requestAnimationFrame(fn);
@@ -8612,6 +9325,8 @@ function createNowPlaying(deps) {
         root.render(h(NowPlaying, {
           p: pCur, mark: mCur, open: state.open, playing: state.playing, at: state.at,
           media: state.media, note: note,
+          volume: state.volume, canSeek: state.canSeek, dragging: drag === "seek",
+          link: state.link,
           onToggle: () => {
             state.open = !state.open;
             tweenTo(state.open ? 1 : 0);
@@ -8633,9 +9348,99 @@ function createNowPlaying(deps) {
             if (!state.media.canVolume) { refuse("np.note.novolume"); return; }
             if (deps.onTransport) deps.onTransport("mute");
           },
+          /* ①(NP-4)① 音量：0..1 交给接线落到真实元素（video / 我们的 audio / web 帧主音量）。
+             与静音键是**两件事**：静音是开关（既有 mute 设置），这里是电平。 */
+          onVolumeLevel: (ratio) => {
+            if (!state.media.canVolume) { refuse("np.note.novolume"); return; }
+            if (deps.onTransport) deps.onTransport("volume", M.clamp(Number(ratio) || 0, 0, 1));
+            state.volume = M.clamp(Number(ratio) || 0, 0, 1);
+            render();
+          },
+          /* ①(NP-4)③ 进度拖动。ratio 是**相对当前媒体时长**的 0..1；
+             换算成秒、以及"联动了要不要同步壁纸"都在 client.js 的接线里（见 §7.8 口径）。 */
+          onScrubStart: (e) => onDragStart("seek", e, (r) => {
+            if (!state.canSeek) { refuse("np.note.noseek"); return; }
+            state.at = r * (typeof state.media.total === "number" ? state.media.total : 0);
+            if (deps.onTransport) deps.onTransport("seek", r);
+            render();
+          }),
+          onScrubMove: (e) => onDragMove("seek", e, (r) => {
+            if (!state.canSeek) return;
+            state.at = r * (typeof state.media.total === "number" ? state.media.total : 0);
+            if (deps.onTransport) deps.onTransport("seek", r);
+            render();
+          }),
+          onScrubEnd: (e) => onDragEnd("seek", e, (r) => {
+            if (!state.canSeek) return;
+            if (deps.onTransport) deps.onTransport("seek", r);
+          }),
+          onScrubKey: (e) => onDragKey("seek", e, () => {
+            const total = typeof state.media.total === "number" ? state.media.total : 0;
+            return total > 0 ? state.at / total : 0;
+          }, (r) => {
+            if (!state.canSeek) { refuse("np.note.noseek"); return; }
+            state.at = r * (typeof state.media.total === "number" ? state.media.total : 0);
+            if (deps.onTransport) deps.onTransport("seek", r);
+            render();
+          }),
+          onVolStart: (e) => onDragStart("vol", e, (r) => fireVol(r)),
+          onVolMove: (e) => onDragMove("vol", e, (r) => fireVol(r)),
+          onVolEnd: (e) => onDragEnd("vol", e, null),
+          onVolKey: (e) => onDragKey("vol", e, () => (typeof state.volume === "number" ? state.volume : 1), (r) => fireVol(r)),
         }));
       } catch (err) { log.error(TAG + "render failed:", err); }
     }
+    function fireVol(r) {
+      if (!state.media.canVolume) { refuse("np.note.novolume"); return; }
+      if (deps.onTransport) deps.onTransport("volume", M.clamp(Number(r) || 0, 0, 1));
+      state.volume = M.clamp(Number(r) || 0, 0, 1);
+      render();
+    }
+
+    /* ── ①(NP-4) 拖动的公共部分（seek 与音量共用；两条只是把 0..1 交给不同的落点） ──
+       `hit` 是承载命中的那个元素（量矩形用它，不是用 e.target —— 指针落到填充/圆点上时
+       target 会是子元素，rect 一样但语义上该以命中带为准）。捕获指针之后，手指滑出元素
+       也还能收到 move/up（否则拖出条子就"卡住"）。 */
+    function dragHitOf(e) {
+      try { return (e && (e.currentTarget || e.target)) || null } catch (err) { return null }
+    }
+    function dragRectOf(e) {
+      const el = dragHitOf(e);
+      try { return el && el.getBoundingClientRect ? el.getBoundingClientRect() : null } catch (err) { return null }
+    }
+    function dragXOf(e) {
+      try {
+        if (e && typeof e.clientX === "number" && isFinite(e.clientX)) return e.clientX;
+        if (e && e.nativeEvent && typeof e.nativeEvent.clientX === "number") return e.nativeEvent.clientX;
+        if (e && e.touches && e.touches[0]) return e.touches[0].clientX;
+      } catch (err) {}
+      return NaN;
+    }
+    function onDragStart(which, e, apply) {
+      drag = which;
+      try { const el = dragHitOf(e); if (el && el.setPointerCapture && e && e.pointerId !== void 0) el.setPointerCapture(e.pointerId); } catch (err) {}
+      try { if (e && e.preventDefault) e.preventDefault(); } catch (err) {}
+      try { apply(ratioOf(dragRectOf(e), dragXOf(e))) } catch (err) {}
+    }
+    function onDragMove(which, e, apply) {
+      if (drag !== which) return;                        /* 没按下的移动不算拖（悬停不算） */
+      try { if (e && e.preventDefault) e.preventDefault(); } catch (err) {}
+      try { apply(ratioOf(dragRectOf(e), dragXOf(e))) } catch (err) {}
+    }
+    function onDragEnd(which, e, apply) {
+      if (drag !== which) return;
+      drag = "";
+      try { if (apply) apply(ratioOf(dragRectOf(e), dragXOf(e))) } catch (err) {}
+      render();                                          /* 去掉 data-mpw-np-drag */
+    }
+    function onDragKey(which, e, curOf, apply) {
+      const key = String((e && e.key) || "");
+      const cur = curOf();
+      const next = stepRatio(cur, key, which === "vol" ? 0.05 : 0.02);
+      if (next === null) return;
+      try { if (e && e.preventDefault) e.preventDefault(); } catch (err) {}
+      try { apply(next) } catch (err) {}
+    }
 
     /** 做不到的事：**不假装**。console 一行 + 面板上一行（用户能看到），4 秒后自己收。 */
     function refuse(key) {
@@ -8720,6 +9525,33 @@ function createNowPlaying(deps) {
       const fromContainer = !!(container && isFinite(cw) && cw > 0 && cw !== measureWidth());
       return fitScale(cw, fromContainer);
     }
+    /** ⑤ 悬浮态放大：把容器往两侧各借 bleed 像素（借的是宿主自己的内边距，本来是空的）。
+        只写**我们自己容器**的内联样式，不碰宿主任何节点：
+          · `width: calc(100% + 2b)` + 左右各 -b 的外边距 ⇒ 盒子在原处**居中变宽**；
+          · 硬边界是最近裁切祖先的内边距盒（bleedFor 里算），所以借满也不会被切。
+            真机读数（悬浮态）：列 256 / 内边距 12 ⇒ 内边距盒 24..256；容器原本 37..243（206），
+            借 12 之后是 25..255（230），两边各留 1px。
+        收敛性：bleedFor 用 `bleedNow` 把量到的盒子还原成"没借之前"，所以这是一步到位的；
+        ResizeObserver 会为这次变宽回调一次，那一次算出来的值与现在相同 ⇒ 不再改样式、不再回调。 */
+    function applyBleed() {
+      if (!container) return 0;
+      const getCS = win && win.getComputedStyle ? win.getComputedStyle.bind(win) : null;
+      const want = bleedFor(container, bleedNow, NP_BLEED_MAX, getCS);
+      if (want === bleedNow) return bleedNow;
+      bleedNow = want;
+      try {
+        if (!want) {
+          container.style.marginLeft = "";
+          container.style.marginRight = "";
+          container.style.width = "";
+        } else {
+          container.style.marginLeft = "-" + want + "px";
+          container.style.marginRight = "-" + want + "px";
+          container.style.width = "calc(100% + " + (want * 2) + "px)";
+        }
+      } catch (e) {}
+      return bleedNow;
+    }
     /** 一帧判据：写/撤 data-mpw-np-hidden + **让位判据**（①(NP-3)）。
      *  让位在**每一次**判据里都跑：挂载前（setEnabled 里单独一次）、挂载后（这里）都要判。
      *  规则：容器里出现非本插件、非宿主自有的占用者 ⇒ 撤下且**不重建**（等它走了再回来）。 */
@@ -8732,6 +9564,7 @@ function createNowPlaying(deps) {
         return hidden;
       }
       if (occupantNow()) { retractForOccupant(); return false; }
+      applyBleed();                                       /* ⑤ 先借宽，再量可用宽度 */
       const next = shouldHide(measureWidth(), hostSaysCollapsed());
       if (next !== hidden) {
         hidden = next;
@@ -8879,6 +9712,8 @@ function createNowPlaying(deps) {
       try {
         container = doc.createElement("div");
         container.setAttribute(NP_ATTR, "");
+        /* ①(NP-4)② 联动开关的可查询落点（值由 setLink/applyNowPlaying 维护）。 */
+        container.setAttribute(NP_LINK_ATTR, state.link === false ? "0" : "1");
         insertInto(a, true);
         enabled = true;
         root = (typeof deps.createRoot === "function") ? deps.createRoot(container) : null;
@@ -8968,6 +9803,7 @@ function createNowPlaying(deps) {
         markYield(null);        /* ①(NP-3) 用户自己关了 ⇒ 让位原因一起清掉（别留下过期状态） */
         enabled = false; hidden = false; anchorMode = "none"; note = "";
         pCur = 0; mCur = 0; state.open = false; state.playing = false;
+        drag = ""; bleedNow = 0;      /* ①(NP-4)/⑤：拖动与借宽都是"挂着才有"的状态 */
         return api;
       }
       if (enabled) { ensureAnchored(); evaluate(); return api; }   /* 重复开 = 只重新锚定，不叠节点 */
@@ -8998,6 +9834,16 @@ function createNowPlaying(deps) {
         if (!(typeof state.media.total === "number" && state.media.total > 0)) state.at = 0;
         const playing = !!state.media.playing;
         if (playing !== state.playing) { state.playing = playing; tweenMark(playing); }
+        /* ①(NP-4) 音量/可拖/联动三个派生量只在**接线送来**时才改（缺省保持"不改既有行为"：
+           音量跟随媒体元素的 volume，能不能拖跟"有没有已知时长"，联动默认开）。 */
+        if (next && next.volume !== void 0 && next.volume !== null && isFinite(Number(next.volume))) {
+          state.volume = M.clamp(Number(next.volume), 0, 1);
+        } else if (state.volume === null && state.media.volume !== void 0 && isFinite(Number(state.media.volume))) {
+          state.volume = M.clamp(Number(state.media.volume), 0, 1);
+        }
+        if (next && next.canSeek !== void 0) state.canSeek = !!next.canSeek;
+        else if (typeof state.media.total === "number" && state.media.total > 0) state.canSeek = true;
+        if (next && next.link !== void 0) state.link = !!next.link;
         render();
         return api;
       },
@@ -9007,7 +9853,24 @@ function createNowPlaying(deps) {
         render();
         return api;
       },
-      setProgress(at) { state.at = Number(at) || 0; render(); return api; },
+      /** 播放进度（媒体事件推来的）。①(NP-4)：**拖动期间直接丢弃** —— 手指按着的时候
+          播放器自己的 timeupdate 会把游标拽回播放位置（真机表现："拖不动"）。
+          拖动那一路由 onScrubMove 自己写 state.at，所以丢弃不会让游标停住。 */
+      setProgress(at) { if (drag) return api; state.at = Number(at) || 0; render(); return api; },
+      /** ①(NP-4) ② 联动开关状态（client.js 的 applyNowPlaying 送）——只影响根上的可查询属性，
+          动作口径在接线里（见 docs/NOW-PLAYING-DSH.md §7.8）。 */
+      setLink(on) {
+        state.link = !!on;
+        try { if (container) container.setAttribute(NP_LINK_ATTR, state.link === false ? "0" : "1"); } catch (e) {}
+        render();
+        return api;
+      },
+      /** ①(NP-4) 音量电平（0..1，接线送；拖动时也用它回写显示）。 */
+      setVolume(level) {
+        const v = Number(level);
+        if (isFinite(v)) { state.volume = M.clamp(v, 0, 1); render(); }
+        return api;
+      },
       /** 给测试/排障看的一眼状态（不参与渲染）。 */
       inspect: () => ({
         enabled, hidden, anchorMode, note,
@@ -9020,6 +9883,8 @@ function createNowPlaying(deps) {
         nextSiblingClass: container && container.nextSibling ? String(container.nextSibling.className || "") : "",
         observers: { resize: counts.resize, mutation: counts.mutation, rafStarts: counts.raf, rafLive: (rafId ? 1 : 0) + (markRafId ? 1 : 0), anchorWatch: anchorWatch || null },
         media: state.media, open: state.open, playing: state.playing, at: state.at, p: pCur, mark: mCur,
+        /* ①(NP-4) 拖动/音量/联动/借宽的可查询状态（真机探针与门禁都读这里）。 */
+        dragging: drag, volume: state.volume, canSeek: state.canSeek, link: state.link, bleed: bleedNow,
       }),
       /** 宿主 slot 交来的容器（我们自己的 div）；null = slot 卸载了 ⇒ 回到降级链。 */
       setSlotNode(node) {
@@ -9037,7 +9902,7 @@ function createNowPlaying(deps) {
         scheduleSettle();
         return api;
       },
-      inspectCollapse: () => ({ hostWide, hidden, fit: npFit(), width: measureAvailWidth(), colWidth: measureWidth(), hostCollapsed: hostSaysCollapsed(), settlePending: !!settleTimer }),
+      inspectCollapse: () => ({ hostWide, hidden, fit: npFit(), width: measureAvailWidth(), colWidth: measureWidth(), hostCollapsed: hostSaysCollapsed(), settlePending: !!settleTimer, bleed: bleedNow }),
       evaluate, ensureAnchored,
       destroy() { return setEnabled(false); },
     };
@@ -9078,7 +9943,9 @@ function createNowPlaying(deps) {
     return MpwNowPlayingAction;
   }
 
-  return { NowPlaying, PlayMark, createController, createSlotAction, shouldHide, resolveAnchor, sidebarRoot, sidebarCol, occupantOf };
+  return {
+    NowPlaying, PlayMark, createController, createSlotAction, shouldHide, resolveAnchor, sidebarRoot, sidebarCol, occupantOf,
+  };
 }
 
 module.exports = {
@@ -9088,7 +9955,13 @@ module.exports = {
   NP_NOTE_ATTR,
   NP_YIELD_ATTR,
   NP_YIELD_FOREIGN,
+  NP_LINK_ATTR,
   NP_COLLAPSE_MAX_W,
+  NP_SCRUB_PAD,
+  NP_VOL_W,
+  NP_BLEED_MAX,
+  /* ①(NP-4) 拖动换算 + ⑤ 借宽判据（纯函数；无浏览器门禁直接断言）。 */
+  ratioOf, stepRatio, clipPadBox, bleedFor,
   NP_CSS,
   NP_SIDEBAR_ROOT_SEL,
   NP_SIDEBAR_ROOT_ATTR,
@@ -13206,7 +14079,8 @@ body[data-mpw-modal] [role="dialog"] {
 					glassColor: "", glassAlpha: 12, accent: "", newStyle: false, mute: true,
 					thinkBg: DEFAULT_THINK_BG,
 					bsCompat: DEFAULT_BS_COMPAT, bsFloat: false, bsFont: false, bsReveal: false, bsAlpha: false, bsAqua: false, bsBottomAvoid: false,
-					enabled: DEFAULT_ENABLED, npNowPlaying: DEFAULT_NP_NOW_PLAYING // ①(NP-1) 恢复默认同样关掉
+					enabled: DEFAULT_ENABLED, npNowPlaying: DEFAULT_NP_NOW_PLAYING, // ①(NP-1) 恢复默认同样关掉
+					npLinkWallpaper: DEFAULT_NP_LINK_WALLPAPER, npVolume: DEFAULT_NP_VOLUME // ①(NP-4) 两个新键一起复位（否则"恢复默认"留下旧电平）
 				}), true);
 				setSection(readSection());
 				applyFromStorage();
@@ -13226,7 +14100,8 @@ body[data-mpw-modal] [role="dialog"] {
 				"brightness", "float", "playbackRate", "newStyle", "mute", "thinkBg", "enabled",
 				"forceEnabled", "propEdits", "clock", "clock24h", "clockSec", "clockDate", "clockPos", "clockSize",
 				"fpsCap", "resMax", "bsCompat", "bsFloat", "bsFont", "bsReveal", "bsRevealAlpha", "bsAlpha", "bsAqua", "bsBottomAvoid",
-				"npNowPlaying" // ①(NP-1) Now playing 挂载开关（可随备份导出/导入）
+				"npNowPlaying", // ①(NP-1) Now playing 挂载开关（可随备份导出/导入）
+				"npLinkWallpaper", "npVolume" // ①(NP-4)②① 联动开关 / 音量电平（同上，随备份走）
 			];
 			const exportBackup = () => {
 				try {
@@ -13263,8 +14138,8 @@ body[data-mpw-modal] [role="dialog"] {
 						const patch = {};
 						// ①(修正) 类型校验（评审指出：原实现直接透传，`opacity:"abc"` 会污染设置）：
 						// 数值类必须为有限数、布尔类必须为 boolean、字符串类必须为 string。
-						const numFields = ["opacity", "blur", "zoom", "headerBlurAmount", "headerFrostAmount", "dialogAmount", "popoverAmount", "popoverAlpha", "maskAmount", "unifyAmount", "sidebarAlpha", "aquaMaskAlpha", "aquaTintStrength", "glassAlpha", "lgCssAmount", "rotateMin", "brightness", "playbackRate", "clockSize", "fpsCap", "resMax", "bsRevealAlpha", "sceneWatchdogSecs"]; // ①(批次15) 四处接线③：导入数值净化
-						const boolFields = ["sidebar", "sharp", "headerBlur", "headerBg", "rightSidebarBlur", "dialogBlur", "popoverBlur", "maskBlur", "unifyTint", "chatFollow", "sessionFollow", "aquaMask", "aquaTint", "aquaInk", "aquaTextEnhance", "todoBlur", "hybrid", "roundCompat", "rotate", "float", "newStyle", "mute", "thinkBg", "enabled", "forceEnabled", "clock", "clock24h", "clockSec", "clockDate", "bsCompat", "bsFloat", "bsFont", "bsReveal", "bsAlpha", "bsAqua", "bsBottomAvoid", "lgTest", "lgCss", "lgComposer", "lgSidebar", "lgHeader", "powPauseHidden", "powPauseBlur", "powPauseBattery", "sceneWatchdog", "npNowPlaying"]; // ①(批次15) 四处接线④：导入布尔净化；①(NP-1) 末尾追加 npNowPlaying
+						const numFields = ["opacity", "blur", "zoom", "headerBlurAmount", "headerFrostAmount", "dialogAmount", "popoverAmount", "popoverAlpha", "maskAmount", "unifyAmount", "sidebarAlpha", "aquaMaskAlpha", "aquaTintStrength", "glassAlpha", "lgCssAmount", "rotateMin", "brightness", "playbackRate", "clockSize", "fpsCap", "resMax", "bsRevealAlpha", "sceneWatchdogSecs", "npVolume"]; // ①(批次15) 四处接线③：导入数值净化；①(NP-4)① 追加 npVolume
+						const boolFields = ["sidebar", "sharp", "headerBlur", "headerBg", "rightSidebarBlur", "dialogBlur", "popoverBlur", "maskBlur", "unifyTint", "chatFollow", "sessionFollow", "aquaMask", "aquaTint", "aquaInk", "aquaTextEnhance", "todoBlur", "hybrid", "roundCompat", "rotate", "float", "newStyle", "mute", "thinkBg", "enabled", "forceEnabled", "clock", "clock24h", "clockSec", "clockDate", "bsCompat", "bsFloat", "bsFont", "bsReveal", "bsAlpha", "bsAqua", "bsBottomAvoid", "lgTest", "lgCss", "lgComposer", "lgSidebar", "lgHeader", "powPauseHidden", "powPauseBlur", "powPauseBattery", "sceneWatchdog", "npNowPlaying", "npLinkWallpaper"]; // ①(批次15) 四处接线④：导入布尔净化；①(NP-1) 末尾追加 npNowPlaying；①(NP-4)② 追加 npLinkWallpaper
 						const strFields = ["aquaColor", "aquaInkColor", "themeColor", "accent", "glassColor", "clockPos", "fontColorGrayColor", "sceneDebugParams"]; // ①(批次15) sceneDebugParams 走字符串净化（非法键/值在写入端丢弃）
 						for (const k of BACKUP_FIELDS) {
 							const v = settings[k];
@@ -13843,6 +14718,8 @@ body[data-mpw-modal] [role="dialog"] {
 				]);
 			};
 
+			/* ①(NP-4)② ② 那一行只在 NP 开着时渲染（渲染用派生量，与持久化默认值同源）。 */
+			const npOnNow = section.npNowPlaying !== void 0 ? !!section.npNowPlaying : DEFAULT_NP_NOW_PLAYING;
 			// ⑳(新) 壁纸设置 tab：计算激活的帧率上限值（缺省=0 无限制）与 ffmpeg 状态文本（渲染用）
 			const fpsCapVal = section.fpsCap !== void 0 && section.fpsCap !== null ? section.fpsCap : 0;
 			const resMaxVal = section.resMax !== void 0 && section.resMax !== null ? section.resMax : DEFAULT_RES_MAX;
@@ -14362,6 +15239,12 @@ body[data-mpw-modal] [role="dialog"] {
 				//   默认关；关 = 一行 DOM 都不注入、一个观察者都不装（见 lib/now-playing.js）。
 				//   左侧栏收起时组件自己隐藏（判据/阈值见 NP_COLLAPSE_MAX_W 的注释）。
 				toggleRow(t("npNowPlaying"), t("npNowPlaying.desc"), "npNowPlaying", DEFAULT_NP_NOW_PLAYING),
+				/* ①(NP-4)② 「播放/暂停是否同时控制壁纸的播放/暂停」——**放在 Now playing 之下**，
+				   并且**只在 npNowPlaying 打开时显示**（NP 关掉 ⇒ 这一行跟着撤掉：一个不挂载的
+				   组件不该还留着它的第二个开关）。判据见 tools/np-control-test.mjs 的 F 组
+				   （两档：NP 开 ⇒ 这一行在；NP 关 ⇒ 这一行不在，且 DOM 里 0 个 mpw_np_* 节点）。
+				   默认值 DEFAULT_NP_LINK_WALLPAPER = **true** ⇒ 默认档与改动前逐字节同行为。 */
+				(npOnNow ? toggleRow(t("npLinkWallpaper"), t("npLinkWallpaper.desc"), "npLinkWallpaper", DEFAULT_NP_LINK_WALLPAPER) : null),
 				// ①(新) 壁纸镜像翻转（Wallpaper Engine 原生基础选项）
 				h("div", { className: "mpw_inline" }, [
 					toggleRow(t("flipX"), t("flipX.desc"), "flipX", false),
@@ -15410,7 +16293,7 @@ body[data-mpw-modal] [role="dialog"] {
 			"scnRender.report": "场景渲染上报（排障）",
 			"scnRender.report.desc": "开启后壁纸每 10 秒把渲染器现场（截图 + 逐层绘制台账 + 纹理统计）写到渲染器的 reports/ 目录，用于定位“坐标/可见性”问题。仅排障时开，默认关（有磁盘写入）",
 			"scnRender.extUrl.ph": "http://127.0.0.1:8899/ext",
-			"scnRender.extUrl.hint": "留空=不启用。填写后按 extbase 拼进场景渲染 iframe（见 we-scene-demo/EXTENSION-HOOKS.md）；点「测试」验证索引可达并显示钩子数量。",
+			"scnRender.extUrl.hint": "留空=不启用。填写后按 extbase 拼进场景渲染 iframe（见渲染器仓文档 EXTENSION-HOOKS.md）；点「测试」验证索引可达并显示钩子数量。",
 			"scnRender.extUrl.save": "保存",
 			"scnRender.extUrl.saved": "扩展钩子地址已保存，下次应用场景壁纸生效",
 			"scnRender.extUrl.cleared": "已清除扩展钩子地址",
@@ -15446,7 +16329,7 @@ body[data-mpw-modal] [role="dialog"] {
 			"diag.fold": "收起开关",
 			"diag.copy": "复制",
 			"diag.copied": "已复制",
-				"diag.more": "全部开关见 we-scene-demo/README-DIAGNOSTICS.md（node diag-flag-check.mjs 校验代码与文档一致）。",
+				"diag.more": "全部开关见渲染器仓文档 README-DIAGNOSTICS.md（node diag-flag-check.mjs 校验代码与文档一致）。",
 				"diagsend.sec": "一键诊断上报",
 				"diagsend.desc": "把关键子系统状态（磨砂 / 侧栏 / 时间线是否被影响、壁纸类型与路径、shim 是否注入、视频解码、表面 token、场景健康）打包发回本机宿主，落在 ~/.dsh/.dsh-mpkg-wallpaper/diag-<时间戳>.json。每个字段都带来源；读不到的字段不会消失，而是标成 null + degraded 原因。宿主不可用时自动改成下载 JSON 文件（离线也能发回来）。",
 				"diagsend.btn": "一键上报",
@@ -15796,6 +16679,14 @@ body[data-mpw-modal] [role="dialog"] {
 			"np.note.nolist": "当前壁纸只有一条音轨，没有上一首/下一首（不假装有列表）",
 			"np.note.novolume": "当前壁纸没有可控制的音量通道：只有视频/网页壁纸的声音可控",
 			"np.note.decode": "音轨加载失败（浏览器不支持这个格式，或宿主取字节失败）",
+			/* ①(NP-4) 新增词的落点（zh）。 */
+			"np.volume": "音量",
+			"np.seek": "播放进度（可拖动）",
+			"np.note.noseek": "这条进度现在不可拖：没有可定位的媒体（联动关掉时壁纸的进度不受控件影响）",
+			"np.note.pkgListOnly": "音轨在包内（scene.pkg），宿主没有能取出它的字节通道 ⇒ 只能列出清单，不能播放",
+			"np.note.linkOff": "「播放/暂停同时控制壁纸」已关：控件只驱动本插件自己的播放器，壁纸本身的播放不受影响",
+			"npLinkWallpaper": "播放/暂停同时控制壁纸",
+			"npLinkWallpaper.desc": "开（默认）：Now playing 的播放/暂停与进度同时驱动壁纸自己的播放；关：只驱动本插件自己的播放器，壁纸的画面播放不受控件影响（壁纸媒体是唯一声源时控件如实禁用，不假装）。默认开 = 与改动前逐字节同行为（详见 docs/NOW-PLAYING-DSH.md §7.8）",
 		};
 		const en = {
 			"nav": "MPKG Wallpaper",
@@ -16170,7 +17061,7 @@ body[data-mpw-modal] [role="dialog"] {
 			"scnRender.report": "Scene render reporting (debug)",
 			"scnRender.report.desc": "When on, the wallpaper sends the renderer's live state (screenshot + per-layer draw ledger + texture stats) to the renderer's reports/ folder every 10s, to diagnose position/visibility bugs. Debug only; off by default (writes to disk)",
 			"scnRender.extUrl.ph": "http://127.0.0.1:8899/ext",
-			"scnRender.extUrl.hint": "Empty = disabled. When set, it is passed to the scene iframe as extbase (see we-scene-demo/EXTENSION-HOOKS.md); press Test to verify the index and show the hook count.",
+			"scnRender.extUrl.hint": "Empty = disabled. When set, it is passed to the scene iframe as extbase (see the renderer repo docs EXTENSION-HOOKS.md); press Test to verify the index and show the hook count.",
 			"scnRender.extUrl.save": "Save",
 			"scnRender.extUrl.saved": "Extension hooks URL saved; takes effect the next time a scene wallpaper is applied",
 			"scnRender.extUrl.cleared": "Extension hooks URL cleared",
@@ -16206,7 +17097,7 @@ body[data-mpw-modal] [role="dialog"] {
 			"diag.fold": "Hide flags",
 			"diag.copy": "Copy",
 			"diag.copied": "Copied",
-			"diag.more": "Full list: we-scene-demo/README-DIAGNOSTICS.md (node diag-flag-check.mjs verifies code/doc consistency).",
+			"diag.more": "Full list: the renderer repo docs README-DIAGNOSTICS.md (node diag-flag-check.mjs verifies code/doc consistency).",
 			"diagsend.sec": "One-click diagnostics report",
 			"diagsend.desc": "Packages the key subsystem state (whether frosting / sidebar / timeline rail are affected, wallpaper type and path, whether the shim was injected, video decode state, surface tokens, scene health) and sends it back to the local host, landing in ~/.dsh/.dsh-mpkg-wallpaper/diag-<timestamp>.json. Every field carries its provenance; unreadable fields are not dropped but marked null + a degraded reason. If the host is unavailable it falls back to downloading the JSON file (works offline).",
 			"diagsend.btn": "Send report",
@@ -16285,6 +17176,14 @@ body[data-mpw-modal] [role="dialog"] {
 			"np.note.nolist": "This wallpaper has a single audio track, so there is no previous/next (no fake playlist)",
 			"np.note.novolume": "This wallpaper has no controllable volume channel: only video/web wallpaper sound can be controlled",
 			"np.note.decode": "The audio track failed to load (unsupported format, or the host could not serve the bytes)",
+			/* ①(NP-4) added strings (en). */
+			"np.volume": "Volume",
+			"np.seek": "Playback position (draggable)",
+			"np.note.noseek": "This position is not draggable right now: there is no seekable media (with the link switch off, the wallpaper's own position is left alone)",
+			"np.note.pkgListOnly": "The audio lives inside the package (scene.pkg) and the host has no route to serve its bytes, so the list is real but playback is not possible",
+			"np.note.linkOff": "\"Play/pause also controls the wallpaper\" is off: the transport only drives this plugin's own player, the wallpaper's own playback is untouched",
+			"npLinkWallpaper": "Play/pause also controls the wallpaper",
+			"npLinkWallpaper.desc": "On (default): the Now playing transport also drives the wallpaper's own playback and position. Off: only this plugin's own player is driven and the wallpaper's playback is untouched (when the wallpaper media is the only sound source the controls are honestly disabled). On by default = byte-identical to the previous behaviour (see docs/NOW-PLAYING-DSH.md §7.8)",
 		};
 
 		// ═══════════════════════════════════════════════════════════════════