dsh-music-player 0.7.1 → 0.7.2

package/README.md

@@ -30,9 +30,15 @@ DeepSeek Harness 音乐/小说播放插件。
 
 ![播放QQ音乐](assets/screenshot-qq.png)
 
+![播放酷狗音乐](assets/screenshot-kg.png)
+
 ![播放AI讲书](assets/screenshot-spectrum.png)
 
-![播放面板](assets/screenshot-panel.png)
+![播放面板1](assets/screenshot-panel-qq.png)
+
+![播放面板2](assets/screenshot-panel-kg.png)
+
+![播放面板3](assets/screenshot-panel.png)
 
 ## 安装
 

package/lib/client.js

@@ -1723,7 +1723,23 @@ window.__ModuleLoader__.load({
     let vizScratchB = null;
     let vizBandPeak = null;      // 每频段慢峰值（自适应增益的响度参考）
     let vizBandGain = null;      // 每频段自适应增益（默认 VIZ_WAVE_GAIN）
+    let vizBandMean = null;      // 每频段波形均值（分析路径算好，绘制直接复用免每帧重扫）
     let vizFilterTime = null;    // 上次消费音频缓冲的 vizCtx.currentTime（用于算新增样本数）
+    // 降采样包络缓冲：每像素列的最小/最大偏差（复用缓冲，避免每帧分配）。
+    let vizEnvMin = null;
+    let vizEnvMax = null;
+    let vizEnvW = 0;             // 包络缓冲对应的画布列数（变化时才重建）
+    // 2d context 缓存：canvas 元素在播放条重挂载时才换新实例，按实例比对复用，
+    // 省掉每帧 2-3 次 getContext('2d') 调用。
+    let vizCanvas2d = null;
+    let vizCanvas2dFor = null;
+    function vizGet2D(canvas) {
+      if (vizCanvas2dFor !== canvas || vizCanvas2d === null) {
+        vizCanvas2d = canvas.getContext('2d');
+        vizCanvas2dFor = canvas;
+      }
+      return vizCanvas2d;
+    }
     // Cached per-band frequency-weighting gain for the live analyser; shared code is
     // bandTiltGain(sampleRate) in the spectrum section. Recomputing is needed only when the
     // AudioContext sample rate changes (a new tap), so it's reset in setupLiveViz.
@@ -1790,13 +1806,14 @@ window.__ModuleLoader__.load({
         return true;
       } catch (e) {
         if (vizCtx !== null) { try { vizCtx.close(); } catch (e2) {} }
-        vizCtx = null; vizAnalyser = null; vizFreq = null; vizWave = null; vizWaveSmooth = null; vizBandSmooth = null; vizBandFilter = null; vizScratchA = null; vizScratchB = null; vizBandPeak = null; vizBandGain = null; vizFilterTime = null; vizLive = false; vizSetupState = 2;
+        vizCtx = null; vizAnalyser = null; vizFreq = null; vizWave = null; vizWaveSmooth = null; vizBandSmooth = null; vizBandFilter = null; vizScratchA = null; vizScratchB = null; vizBandPeak = null; vizBandGain = null; vizBandMean = null; vizEnvMin = null; vizEnvMax = null; vizEnvW = 0; vizFilterTime = null; vizLive = false; vizSetupState = 2;
         return false;
       }
     }
     function closeLiveViz() {
       if (vizCtx !== null) { try { vizCtx.close(); } catch (e) {} }
-      vizCtx = null; vizAnalyser = null; vizFreq = null; vizWave = null; vizWaveSmooth = null; vizBandSmooth = null; vizBandFilter = null; vizScratchA = null; vizScratchB = null; vizBandPeak = null; vizBandGain = null; vizFilterTime = null; vizLive = false; vizSetupState = 0;
+      vizCtx = null; vizAnalyser = null; vizFreq = null; vizWave = null; vizWaveSmooth = null; vizBandSmooth = null; vizBandFilter = null; vizScratchA = null; vizScratchB = null; vizBandPeak = null; vizBandGain = null; vizBandMean = null; vizEnvMin = null; vizEnvMax = null; vizEnvW = 0; vizFilterTime = null; vizLive = false; vizSetupState = 0;
+      vizCanvas2d = null; vizCanvas2dFor = null;
     }
     // Map AnalyserNode's per-bin byte data (dB→0..255) into the VIZ_BARS
     // log-spaced bands. Marks vizLiveOK once the tap actually yields signal.
@@ -1871,9 +1888,20 @@ window.__ModuleLoader__.load({
         vizScratchB = new Float32Array(n);
         vizBandPeak = new Float32Array(VIZ_WAVE_BANDS.length);
         vizBandGain = new Float32Array(VIZ_WAVE_BANDS.length);
+        vizBandMean = new Float32Array(VIZ_WAVE_BANDS.length);
         for (let i = 0; i < vizBandSmooth.length; i++) vizBandSmooth[i] = 0.5;
+        for (let i = 0; i < vizBandMean.length; i++) vizBandMean[i] = 0.5;
         vizFilterTime = null;
       }
+      // 时域路径的 tap 信号确认（与 analyseLiveBands 的 m>4 等价）：死 tap 只会给
+      // 恒定 128（静音），任一样本偏离中心 >4 即视为真实信号。wave 模式不再调
+      // analyseLiveBands，vizLiveOK 改由这里维护。
+      if (!vizLiveOK) {
+        for (let i = 0; i < n; i++) {
+          const d = vizWave[i] >= 128 ? vizWave[i] - 128 : 128 - vizWave[i];
+          if (d > 4) { vizLiveOK = true; break; }
+        }
+      }
       // 算出「自上次处理后新增的样本数」hop：只把缓冲末尾的新样本喂给滤波器。
       // 关键：若整窗都喂且滤波器状态跨帧保留，重叠区会被重复滤波、状态跑得比
       // 真实时间快 → 强低音会错误地在高频段激起（实测 100Hz → 中频 0.46）。
@@ -1918,6 +1946,7 @@ window.__ModuleLoader__.load({
         let bm = 0;
         for (let i = 0; i < n; i++) bm += vizBandSmooth[base + i];
         bm /= n;
+        vizBandMean[bi] = bm; // 绘制侧直接复用（drawOneWave 免每帧重扫一遍求均值）
         let bp = 0;
         for (let i = 0; i < n; i++) { const d = Math.abs(vizBandSmooth[base + i] - bm); if (d > bp) bp = d; }
         const sp = Math.max(bp, vizBandPeak[bi] * VIZ_WAVE_PEAK_DECAY);
@@ -1925,18 +1954,22 @@ window.__ModuleLoader__.load({
         vizBandGain[bi] = Math.min(VIZ_WAVE_GAIN, Math.max(VIZ_WAVE_GAIN_MIN, VIZ_WAVE_PEAK_TARGET / Math.max(sp, 1e-3)));
       }
       // 单条回落波形（vizWaveSmooth）同样以 0.5 为中线、对称平滑；仅作降级回退用。
-      for (let i = 0; i < vizWave.length; i++) {
-        // 用 256 作归一化基准：getByteTimeDomainData 的静音中心是 128，128/256 = 0.5
-        // 正好是画布垂直中线，波形严格围绕中线上下对称（若用 /255 则中心落在 ~0.502，
-        // 整条线会系统性偏上约 0.002*(h-1)）。
-        const t = vizWave[i] / 256;
-        const s = vizWaveSmooth[i];
-        vizWaveSmooth[i] = s + (t - s) * 0.4;
+      // 分段缓冲已就绪时回退路径不可达（drawWaveform 走分频段多线），跳过缓动省
+      // 每帧 2048 次无效运算。
+      if (vizBandSmooth === null) {
+        for (let i = 0; i < vizWave.length; i++) {
+          // 用 256 作归一化基准：getByteTimeDomainData 的静音中心是 128，128/256 = 0.5
+          // 正好是画布垂直中线，波形严格围绕中线上下对称（若用 /255 则中心落在 ~0.502，
+          // 整条线会系统性偏上约 0.002*(h-1)）。
+          const t = vizWave[i] / 256;
+          const s = vizWaveSmooth[i];
+          vizWaveSmooth[i] = s + (t - s) * 0.4;
+        }
       }
       return true;
     }
     function drawBars(canvas, useCaps) {
-      const c = canvas.getContext('2d');
+      const c = vizGet2D(canvas);
       const w = canvas.width; const h = canvas.height;
       c.clearRect(0, 0, w, h);
       const gap = 2;
@@ -1963,8 +1996,8 @@ window.__ModuleLoader__.load({
     // reads as the main contour while mids/highs layer on top, vertically centered on the
     // canvas midline (0.5) to line up with the left-aligned track name.
     function drawWaveform(canvas) {
-      if (vizWaveSmooth === null) { canvas.getContext('2d').clearRect(0, 0, canvas.width, canvas.height); return; }
-      const c = canvas.getContext('2d');
+      if (vizWaveSmooth === null) { vizGet2D(canvas).clearRect(0, 0, canvas.width, canvas.height); return; }
+      const c = vizGet2D(canvas);
       const w = canvas.width; const h = canvas.height;
       c.clearRect(0, 0, w, h);
       c.lineCap = 'round';
@@ -1983,14 +2016,20 @@ window.__ModuleLoader__.load({
         // 用该频段的自适应增益（安静感知）替换固定放大：大声归一全幅、安静提亮，
         // 见 analyseLiveWave 的 vizBandGain。
         const gain = (vizBandGain !== null && vizBandGain.length === bands.length) ? vizBandGain[b] : VIZ_WAVE_GAIN;
-        drawOneWave(c, w, h, n, src, bands[b].alpha, bands[b].width, color, gain);
+        const mean = (vizBandMean !== null && vizBandMean.length === bands.length) ? vizBandMean[b] : undefined;
+        drawOneWave(c, w, h, n, src, bands[b].alpha, bands[b].width, color, gain, mean);
       }
     }
     // Draw a single waveform curve from a normalized(0..1) sample buffer. The curve is
     // centered on its OWN mean so its vertical centroid always lands on the canvas midline
     // (0.5), regardless of any DC bias or content asymmetry — otherwise a non-symmetric
     // waveform (real vocals/rock) would sit visibly toward the top or bottom.
-    function drawOneWave(c, w, h, n, samples, alpha, width, color, gain) {
+    //
+    // 绘制前按像素列做 min/max 包络降采样：画布只有 ~60px 宽，逐点画 n=2048 的折线
+    // 点间距仅 ~0.03px（~30 倍超采样），抗锯齿描边是波形模式的主要绘制开销。每列
+    // 只取最大/最小偏差各 1 点（峰值保留 → 与全点绘制视觉无差），描边顶点数从
+    // 3×2048 降到 3×2×w（~94%↓）。分析路径已算出均值时直接复用（mean 参数）。
+    function drawOneWave(c, w, h, n, samples, alpha, width, color, gain, mean) {
       const col = color || currentAccent();
       // gain：该频段的自适应增益（默认固定放大 VIZ_WAVE_GAIN）。
       const g = (typeof gain === 'number' && Number.isFinite(gain) && gain > 0) ? gain : VIZ_WAVE_GAIN;
@@ -1999,18 +2038,41 @@ window.__ModuleLoader__.load({
       c.strokeStyle = col;
       c.lineWidth = width;
       // 求本条波形自身的均值，作为竖直居中轴（强制质心落在画布中线 0.5）。
-      let mean = 0;
-      for (let i = 0; i < n; i++) mean += samples[i];
-      mean /= n;
-      c.beginPath();
+      let mu = mean;
+      if (typeof mu !== 'number' || !Number.isFinite(mu)) {
+        mu = 0;
+        for (let i = 0; i < n; i++) mu += samples[i];
+        mu /= n;
+      }
+      // 逐列聚合 min/max 偏差（相对均值）。缓冲按列数复用，宽度变化才重建。
+      const cols = Math.max(1, Math.min(w, n));
+      if (vizEnvW !== cols || vizEnvMin === null || vizEnvMax === null) {
+        vizEnvMin = new Float32Array(cols);
+        vizEnvMax = new Float32Array(cols);
+        vizEnvW = cols;
+      }
+      vizEnvMin.fill(Infinity);
+      vizEnvMax.fill(-Infinity);
       for (let i = 0; i < n; i++) {
-        const x = (i / (n - 1)) * w;
-        // 以均值 mean 为对称轴放大偏差，再映射到画布高度。y 用 +0.5 把中心精确对齐到
-        // 画布视觉正中 h/2（20px 画布的 y=10）：直接用 (1-norm)*(h-1) 会把中心落在
-        // 9.5，整整偏上 0.5px，直线/波形都会看起来没垂直居中。
-        const norm = 0.5 + (samples[i] - mean) * g;
-        const y = (1 - norm) * (h - 1) + 0.5; // norm=0.5 → y = h/2 → 竖直居中
-        if (i === 0) c.moveTo(x, y); else c.lineTo(x, y);
+        const ci = Math.min(cols - 1, Math.floor((i * cols) / n));
+        const d = samples[i] - mu;
+        if (d < vizEnvMin[ci]) vizEnvMin[ci] = d;
+        if (d > vizEnvMax[ci]) vizEnvMax[ci] = d;
+      }
+      c.beginPath();
+      // min/max 之字形：每列先 max 后 min（列内竖直连线），相邻列首尾相接，
+      // 形成与全点折线等观的连续包络。y 用 +0.5 把中心精确对齐到画布视觉正中
+      // h/2（20px 画布的 y=10）：直接用 (1-norm)*(h-1) 会把中心落在 9.5，
+      // 整整偏上 0.5px，直线/波形都会看起来没垂直居中。
+      let started = false;
+      for (let ci = 0; ci < cols; ci++) {
+        const lo = vizEnvMin[ci]; const hi = vizEnvMax[ci];
+        if (!(lo <= hi)) continue; // 空列（理论上不发生，防御 NaN/Inf）
+        const x = ((ci + 0.5) / cols) * w;
+        const yHi = (1 - (0.5 + hi * g)) * (h - 1) + 0.5;
+        const yLo = (1 - (0.5 + lo * g)) * (h - 1) + 0.5;
+        if (!started) { c.moveTo(x, yHi); started = true; } else { c.lineTo(x, yHi); }
+        c.lineTo(x, yLo);
       }
       c.stroke();
       c.globalAlpha = 1;
@@ -2019,16 +2081,22 @@ window.__ModuleLoader__.load({
       if (barCanvasNode === null) return;
       const canvas = barCanvasNode;
       const w = canvas.width; const h = canvas.height;
-      // Always probe the live tap (so vizLiveOK gets set the moment it yields signal).
-      if (vizLive && vizAnalyser !== null) {
-        analyseLiveBands();
-        analyseLiveWave();
+      // 暂停/无 tap 时只清画布，不做任何 DSP——对静音做 FFT/时域读取 + 3 频段
+      // biquad 滤波（vizCtx.currentTime 暂停时照走，hop 每帧 ~800 样本）都是无效功。
+      // vizLiveOK 的确认因此发生在播放首帧，不影响显示（未确认本来就不画）。
+      if (!vizLive || vizAnalyser === null || !store.playing) {
+        vizGet2D(canvas).clearRect(0, 0, w, h);
+        return;
       }
+      // 模式互斥读取：wave 只走时域（biquad 分频段），bars 只走频域（对数分段）——
+      // 另一条路径的读取+映射对当前显示是纯开销。vizLiveOK 由各自路径确认
+      // （bars：analyseLiveBands 内频段能量 m>4；wave：analyseLiveWave 内 |x-128|>4）。
+      const waveMode = store.vizMode === 'wave';
+      const analysed = waveMode ? analyseLiveWave() : analyseLiveBands();
       // 失败/未确认信号 -> 直接不显示（无离线回退）。仅当实时路径确认在出信号
       // 且正在播放时才画，否则清空画布。
-      const confirmed = vizLive && vizLiveOK && store.playing;
-      if (!confirmed) { canvas.getContext('2d').clearRect(0, 0, w, h); return; }
-      if (store.vizMode === 'wave') {
+      if (!analysed || !vizLiveOK) { vizGet2D(canvas).clearRect(0, 0, w, h); return; }
+      if (waveMode) {
         drawWaveform(canvas);
         return;
       }
@@ -2214,6 +2282,9 @@ window.__ModuleLoader__.load({
     const BOOK_MAX_CHUNK_SEC = 180;
     let restoredMusicPos = null; // restored music position to display until the audio truly reaches it
     let bookRestorePos = -1;   // restored book's in-chunk position, seeked on play
+    // 刚发生过 ended→切块：其后到达的重复 ended 属于旧块陈旧事件（吞掉）；
+    // 下一块真正开始播放（play promise 兑现）或用户主动重播/停止时清除。
+    let bookJustAdvanced = false;
     // 当前块是否已自动重试过一次（瞬时 LLM 合成失败时先静音重试一次，
     // 只有重试仍失败才弹错误 + 手动重试）。成功播放后复位。
     let bookAutoRetried = false;
@@ -2370,7 +2441,11 @@ window.__ModuleLoader__.load({
         loadBookSubtitle(id, from);
         const promise = audio.play();
         if (promise !== undefined && typeof promise.then === 'function') {
-          promise.then(() => { clearStuck(); doneBuffering(); }).catch((e) => {
+          promise.then(() => {
+            clearStuck();
+            doneBuffering();
+            bookJustAdvanced = false; // 新块真正开始播放：其后同块的 ended 是真实结束
+          }).catch((e) => {
             clearStuck();
             // Distinguish a real autoplay block (NotAllowedError) from a media
             // load/decode failure. Load failures are already surfaced by the
@@ -2395,7 +2470,7 @@ window.__ModuleLoader__.load({
       }
     }
     // `from` lets the toc jump straight to a chapter's chunk index.
-    function playBook(id, from = 0) { unlockAutoplay(); bookTotal = -1; bookBufferedFrom = -1; bookBaseTime = 0; bookRestorePos = -1; bookAutoRetried = false; playBookFrom(id, from, false); saveCurrentBookPlayback(); }
+    function playBook(id, from = 0) { unlockAutoplay(); bookTotal = -1; bookBufferedFrom = -1; bookBaseTime = 0; bookRestorePos = -1; bookAutoRetried = false; bookJustAdvanced = false; playBookFrom(id, from, false); saveCurrentBookPlayback(); }
     // Play a novel from its saved progress when available (e.g. switching to
     // music and back), otherwise start fresh from the beginning. Explicit
     // chapter jumps keep using playBook(id, fromChunk) and are unaffected.
@@ -2429,7 +2504,13 @@ window.__ModuleLoader__.load({
         restoredMusicPos = null;
         const endedDur = Number.isFinite(audio.duration) ? audio.duration : (audio.currentTime || 0);
         if (Number.isFinite(endedDur)) bookBaseTime += endedDur;
-        playBookFrom(id, bookFromRef + 1, true);
+        // 只有下一块确已预热（preAudio 缓冲就绪、切换瞬时完成）才静默切块；
+        // 冷启动续播跳块时下一块尚未合成（需数秒~数十秒），必须显示「AI 合成中」
+        // 并带上 60s 超时兜底，否则用户看到的是无声无息的「卡住」（既没声音、
+        // 字幕也不动，又没有任何反馈）。
+        const warmed = bookBufferedFrom === bookFromRef + 1;
+        bookJustAdvanced = true; // 后续紧到的重复 ended 属旧块陈旧事件（onEnded 据此吞掉）
+        playBookFrom(id, bookFromRef + 1, warmed);
         // Persist the new chunk/base immediately so a refresh after the switch
         // resumes from here (with the continuous clock) rather than the old chunk.
         lastPosSaveAt = Date.now();
@@ -2438,10 +2519,45 @@ window.__ModuleLoader__.load({
       }
       return false;
     }
+    // 恢复续播的定位钉评估（onTime 与 onDur 共用）：
+    //   真实播放明显越过恢复点 → 释放定位钉，交给实时时间；
+    //   恢复点已超出本块实际时长（重启后冷合成可能更短）→ 用户其实已读完这一块，
+    //     直接跳到下一块继续，而不是重听本块（否则整块重播，或钳到块尾卡住）；
+    //   时长已知且恢复点在块内 → 才把音频 seek 到恢复点；
+    //   时长未知 → 什么都不做（绝不提前把可能越界的位置塞进 currentTime）。
+    // 关键：onDur（durationchange）也调用——只挂在 timeupdate 上时，若元素被钳在
+    // 块尾（不再播放、不再派发 timeupdate），pastEnd 补救永远不会被评估，续播就会
+    // 永久卡在「没声音、字幕不动」。
+    function evaluateBookRestorePin() {
+      if (!(bookRestorePos >= 0) || !String(store.currentId || '').startsWith('book:')) return false;
+      const ct = audio.currentTime || 0;
+      const dur = (Number.isFinite(audio.duration) && audio.duration > 0) ? audio.duration : 0;
+      if (ct > bookRestorePos + 1) {
+        bookRestorePos = -1; // real playback advanced past the spot — live time
+        return false;
+      }
+      if (dur > 0 && bookRestorePos >= dur) {
+        // maybeAdvanceBook 内部会清 bookRestorePos 并推进 bookBaseTime；若已到最后一
+        // 块（无下一块）则释放定位钉、让本块自然播完后再结束。
+        if (!maybeAdvanceBook()) bookRestorePos = -1;
+        return true;
+      }
+      if (dur > 0) {
+        if (store.playing && ct < bookRestorePos - 0.5) {
+          try { audio.currentTime = bookRestorePos; } catch (e) {}
+        }
+        set({ position: bookBaseTime + bookRestorePos });
+        // 补齐：pin 阶段也推进字幕——续播时该块的实时字幕可能还没就绪，这里在
+        // 每次 timeupdate 都尝试定位当前句，避免「先空白、切块后才出字幕」。
+        updateLyric();
+        return true;
+      }
+      return false; // dur 尚未知（元数据未加载）：等 onDur/onTime 再评估
+    }
     function stopBookHelper() {
       preAudio.removeAttribute('src'); preAudio.load();
       if (bookStuckTimer !== null) { clearTimeout(bookStuckTimer); bookStuckTimer = null; }
-      bookTotal = -1; bookFromRef = 0; bookBufferedFrom = -1; bookBaseTime = 0; bookRestorePos = -1;
+      bookTotal = -1; bookFromRef = 0; bookBufferedFrom = -1; bookBaseTime = 0; bookRestorePos = -1; bookJustAdvanced = false;
     }
     function togglePlay() {
       if (store.pendingId !== null && store.currentId === null) { startPlay(store.pendingId); return; }
@@ -2491,9 +2607,12 @@ window.__ModuleLoader__.load({
             audio.src = chunkUrl;
             audio.load();
           }
-          if ((audio.currentTime || 0) < bookRestorePos - 0.5) {
-            try { audio.currentTime = bookRestorePos; } catch (e) {}
-          }
+          // 注意：这里绝不能提前 seek（旧实现 load() 后立刻 currentTime=bookRestorePos）。
+          // 冷启动续播时本块是重新合成的（TTS 非确定性，时长会变），此时 readyState=0、
+          // 时长未知；若保存位置超出新块时长，越界 seek 会被浏览器钳到块末尾，元素停在
+          // 块尾且不再派发 timeupdate/ended → onTime 的 pastEnd 守卫永远不评估 →
+          // 「没声音、字幕不动」。seek 统一交给定位钉：onDur（时长就绪）/onTime（播放中）
+          // 确认恢复点在块内后才 seek（见 evaluateBookRestorePin）。
           if (bookTotal >= 0 && bookFromRef + 1 < bookTotal) preloadBook(id, bookFromRef + 1);
           // 恢复续播的这块之前没有拉取过字幕（restore 不动 audio、playBookFrom 不经过
           // 这里），必须补一次 loadBookSubtitle，否则续播后整块无字幕、直到切块才出现。
@@ -2517,6 +2636,7 @@ window.__ModuleLoader__.load({
               if (bookStuckTimer !== null) { clearTimeout(bookStuckTimer); bookStuckTimer = null; }
               set({ bookBuffering: false, bookBufferingSilent: false, bookBufferingSince: 0 });
             }
+            bookJustAdvanced = false; // 本块真正开始播放：其后同块的 ended 是真实结束
           }).catch((err) => {
             // 播放被拒绝（如 autoplay 拦截）时同样清掉缓冲/超时：否则「AI 合成中…」
             // 会一直挂着，而错误提示又不显示（这里只对 autoplay 拦截报错）。
@@ -2714,41 +2834,10 @@ window.__ModuleLoader__.load({
           }
         }
         // A restored book applies the same pin to its in-chunk position (its
-        // deferred seek is applied on play, so currentTime is still at the chunk
-        // start until then) — anchored on top of the book-wide clock.
-        if (bookRestorePos >= 0 && String(store.currentId).startsWith('book:')) {
-          const ct = audio.currentTime || 0;
-          // 释放/处理条件：真实播放已明显越过恢复点（正常放过去），或恢复点已超出本块
-          // 的实际时长。块可能被重新合成得更短（尤其重启后冷合成）——此时若仍把
-          // currentTime seek 到保存位置，会被浏览器钳到块末尾，且未必派发 ended，于是
-          // 「响一下→没声音、字幕不动」。若用户其实已越过本块（保存位置 ≥ 块长），则
-          // 直接跳到下一块；否则释放定位钉、让它从当前处自然播到块尾再切块。
-          const dur = (Number.isFinite(audio.duration) && audio.duration > 0) ? audio.duration : 0;
-          const pastSpot = ct > bookRestorePos + 1;
-          const pastEnd = dur > 0 && bookRestorePos >= dur;
-          if (pastSpot) {
-            bookRestorePos = -1; // real playback advanced past the spot — live time
-          } else if (pastEnd) {
-            // 保存位置已越过本块实际末尾（重启后重合成块变短）→ 用户其实已读完这一块，
-            // 直接跳到下一块继续，而不是重听本块（否则会整块重播，或响一下→卡住）。
-            // maybeAdvanceBook 内部会清 bookRestorePos 并推进 bookBaseTime；若已到最后一
-            // 页（无下一块）则释放定位钉、让本块自然播完后再结束。
-            if (!maybeAdvanceBook()) bookRestorePos = -1;
-          } else if (dur > 0) {
-            // 时长已就绪且恢复点在本块内：才把音频 seek 到恢复点（以免提前 seek 到一个
-            // 随后才发现越界、被钳到块末尾的位置而卡死）。
-            if (store.playing && ct < bookRestorePos - 0.5) {
-              try { audio.currentTime = bookRestorePos; } catch (e) {}
-            }
-            set({ position: bookBaseTime + bookRestorePos });
-            // 补齐：pin 阶段也推进字幕——续播时该块的实时字幕可能还没就绪，这里在
-            // 每次 timeupdate 都尝试定位当前句，避免「先空白、切块后才出字幕」。
-            updateLyric();
-            return;
-          }
-          // dur 尚未知（元数据未加载）：先不 seek，走下方正常读值；等时长就绪后上面的
-          // pin 会再次评估并正确 seek/释放，绝不提前把一个可能越界的位置塞进 currentTime。
-        }
+        // deferred seek is applied once duration is known and we're playing) —
+        // anchored on top of the book-wide clock. Shared with onDur so the
+        // pastEnd rescue runs even when no timeupdate ever fires.
+        if (bookRestorePos >= 0 && String(store.currentId).startsWith('book:') && evaluateBookRestorePin()) return;
         set({ position: bookTimeBase() + (audio.currentTime || 0) });
         // Persist the playback spot periodically (≈every 5s) for BOTH music and
         // novels, so a refresh at any moment resumes here instead of jumping
@@ -2780,6 +2869,11 @@ window.__ModuleLoader__.load({
               return; // retry re-loads; don't clobber duration yet
             }
           }
+          // 恢复定位钉在「时长就绪」的瞬间先评估一次：这是 pastEnd（保存位置 ≥ 新块
+          // 实际时长，冷合成块变短）能被最早发现的时机。只靠 onTime 评估会在元素被
+          // 钳到块尾、不再播放、不再派发 timeupdate 时永远轮不到补救（冷启动续播
+          // 「响一下→没声音、字幕不动」的残留卡死点）。
+          if (bookRestorePos >= 0 && String(store.currentId).startsWith('book:')) evaluateBookRestorePin();
           set({ duration: (bookTimeBase() + audio.duration) });
         }
       };
@@ -2790,9 +2884,16 @@ window.__ModuleLoader__.load({
         // next block until the whole book is done, then stop (never step into
         // the music list). Book ids are 'book:'-prefixed.
         if (store.currentId !== null && String(store.currentId).startsWith('book:')) {
-          // 切块进行中（bookBuffering 为真，新块还没开始播放）忽略旧块的
-          // ended：防止陈旧事件重复触发导致跳块/时间空走。
-          if (store.bookBuffering) return;
+          // 切块进行中（bookBuffering 为真）时要区分两种 ended：
+          //   ① 刚切块过（bookJustAdvanced）：这是旧块的陈旧重复事件，吞掉——否则
+          //      会连跳两块；标记在下一块真正开始播放（play promise 兑现）时清除。
+          //   ② 尚未切块过：这是「本块真结束」带着缓冲态到达（恢复续播被钳到块尾
+          //      等场景），若一并吞掉就会不切块、不报错地永久卡住——清缓冲并正常切块。
+          if (store.bookBuffering && bookJustAdvanced) return;
+          if (store.bookBuffering) {
+            if (bookStuckTimer !== null) { clearTimeout(bookStuckTimer); bookStuckTimer = null; }
+            set({ bookBuffering: false, bookBufferingSilent: false, bookBufferingSince: 0 });
+          }
           if (!maybeAdvanceBook()) stop();
           return;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-music-player",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "DeepSeek Harness 音乐 + AI 讲书插件：Vibe coding人工作时的伴侣",
   "type": "module",
   "main": "lib/index.js",
@@ -37,7 +37,7 @@
   "scripts": {
     "test": "vitest run",
     "test:watch": "vitest",
-    "ci": "vitest run"
+    "ci": "vitest run --retry=2 --testTimeout=20000"
   },
   "dsh": {
     "bundle": {