@memef1f1y/dsh-plugin-tts 0.6.2 → 0.6.3

package/lib/index.mjs

@@ -1184,6 +1184,37 @@ function isLatinHeavy(text) {
  */
 const ATOM_RE = /https?:\/\/[^\s，。！？；,!?;]+|[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}|\d+(?:\.\d+)+/g;
 
+/**
+ * Character spans of each part within the source text: [[start,end), …].
+ * Walks the text once, tolerating whitespace differences (trimmed part edges,
+ * collapsed newlines, Cloud's synthetic join gaps) — never message content
+ * aware beyond ordering. Returns null when the parts cannot be walked in
+ * order (then callers fall back to equal division). Pure, unit-tested.
+ * Lets the client map "chunk k" to an exact text slice for scroll-follow
+ * highlight (docs/scroll-follow-v2.md P1-3) instead of guessing by length.
+ */
+function spanParts(text, parts) {
+  const src = String(text || '');
+  const spans = [];
+  let pos = 0;
+  for (const part of parts) {
+    while (pos < src.length && /\s/.test(src[pos])) pos++;
+    const start = pos;
+    let ok = true;
+    for (const ch of String(part)) {
+      if (/\s/.test(ch)) {
+        while (pos < src.length && /\s/.test(src[pos])) pos++;
+      } else {
+        if (src[pos] !== ch) { ok = false; break; }
+        pos++;
+      }
+    }
+    if (!ok) return null;
+    spans.push([start, pos]);
+  }
+  return spans;
+}
+
 /** Split text into chunks of <= maxChars, preferring sentence/segment boundaries. */
 function splitText(text, maxChars) {
   const atoms = [];
@@ -1893,6 +1924,9 @@ function ingestSessionEvent(event) {
 // NEVER the message text itself, and NEVER API keys.
 // ---------------------------------------------------------------------------
 const recentErrors = [];
+// Ring capacity: 20 used to evict real evidence under test traffic (smoke
+// runs share this file), so chunk-triage entries went missing from exports.
+const RECENT_CAP = 30;
 // Persisted alongside calibration.json/settings.json so the failure history
 // survives dsh restarts (a fresh update erases in-memory history otherwise).
 // Same schema as the in-memory entries; no message text, no keys.
@@ -1916,14 +1950,14 @@ function recordHostError(entry) {
     const e = Object.assign({ at: Date.now() }, entry);
     if (!e.kind) e.kind = classifyHostError(e.error);
     recentErrors.push(e);
-    while (recentErrors.length > 20) recentErrors.shift();
+    while (recentErrors.length > RECENT_CAP) recentErrors.shift();
     saveRecentErrors();
   } catch (err) { /* logging must never break synthesis */ }
 }
 function saveRecentErrors() {
   try {
     mkdirSync(CAL_DIR, { recursive: true });
-    writeFileSync(RECENT_FILE, JSON.stringify(recentErrors.slice(-20)));
+    writeFileSync(RECENT_FILE, JSON.stringify(recentErrors.slice(-RECENT_CAP)));
   } catch (e) { /* best-effort */ }
 }
 function loadRecentErrors() {
@@ -1931,7 +1965,7 @@ function loadRecentErrors() {
     if (!existsSync(RECENT_FILE)) return;
     const data = JSON.parse(readFileSync(RECENT_FILE, 'utf8'));
     if (Array.isArray(data)) {
-      for (const e of data.slice(-20)) {
+      for (const e of data.slice(-RECENT_CAP)) {
         if (e && typeof e === 'object') recentErrors.push(e);
       }
     }
@@ -1953,6 +1987,11 @@ const WORKER_META = {
   spawnTimeoutMs: 45000,
   retry: 'transient-once-800ms-backoff'
 };
+// Host chunk-pipeline build tag, surfaced in /diagnose next to worker meta.
+// Bump on every Host-side playback fix: package.json versions only move on
+// releases, so without this two different Host builds are indistinguishable
+// in an exported log (exactly what stalled the 1/3/2 swap triage).
+const HOST_BUILD = '2026-09-26.02-job-summary';
 
 export function apply(ctx) {
   const webServer = ctx.get('webServer');
@@ -2059,6 +2098,30 @@ export function apply(ctx) {
     return p;
   }
 
+  // One summary line per finished chunked job (drained or cancelled): without
+  // it a serve-order incident leaves zero host trace (the 1/3/2 swap recorded
+  // nothing). Idempotent — re-polls after completion must not duplicate it.
+  // No message text, only counts (same privacy rule as the error ring).
+  function noteJobDone(job, outcome) {
+    if (!job || job.doneLogged) return;
+    job.doneLogged = true;
+    try {
+      const skipped = Object.keys(job.skipErrors || {}).map((k) => Number(k) + 1).sort((a, b) => a - b);
+      recordHostError({
+        provider: job.provider || '?',
+        voice: job.voice,
+        total: job.parts.length,
+        served: job.serveIdx,
+        skipped,
+        stage: 'job',
+        kind: 'info',
+        ms: Date.now() - (job.created || Date.now()),
+        error: 'outcome=' + outcome + ' served=' + job.serveIdx + '/' + job.parts.length +
+          ' skipped=[' + skipped.join(',') + ']'
+      });
+    } catch (e) { /* logging must never break serving */ }
+  }
+
   // Serve the next index in order, awaiting its own synthesis when needed.
   // Never synthesizes serveIdx+1 before serveIdx resolves, so the client —
   // which fills queue[want] in request order — always gets parts in order.
@@ -2069,13 +2132,17 @@ export function apply(ctx) {
     const idx = job.serveIdx;
     if (idx >= job.parts.length) {
       job.finishedAt = job.finishedAt || Date.now();
+      noteJobDone(job, 'drained');
       return { done: true };
     }
     const known = job.urls[idx];
     if (typeof known === 'string' || known === false) {
       job.serveIdx++;
       const more = job.serveIdx < job.parts.length;
-      if (!more) job.finishedAt = job.finishedAt || Date.now();
+      if (!more) {
+        job.finishedAt = job.finishedAt || Date.now();
+        noteJobDone(job, 'drained');
+      }
       if (known === false) {
         return { skipped: idx + 1, error: job.skipErrors ? job.skipErrors[idx] || '' : '', more, index: idx };
       }
@@ -2090,7 +2157,10 @@ export function apply(ctx) {
     }
     job.serveIdx++;
     const more = job.serveIdx < job.parts.length;
-    if (!more) job.finishedAt = job.finishedAt || Date.now();
+    if (!more) {
+      job.finishedAt = job.finishedAt || Date.now();
+      noteJobDone(job, 'drained');
+    }
     if (r && r.url) return { url: r.url, more, index: idx };
     if (r && r.skipped) return { skipped: idx + 1, error: r.error || '', more, index: idx };
     return { done: true };
@@ -2106,6 +2176,7 @@ export function apply(ctx) {
     if (!job) return false;
     job.done = true;
     job.finishedAt = job.finishedAt || Date.now();
+    noteJobDone(job, 'cancelled');
     jobs.delete(jobId);
     return true;
   }
@@ -2227,6 +2298,9 @@ export function apply(ctx) {
           const parts = provider === 'google-cloud-tts'
             ? splitCloudPackets(text)
             : splitText(text, maxChars);
+          // Block spans for scroll-follow highlight mapping (P1-3); omitted
+          // when unwalkable — the client falls back to equal division.
+          const spans = spanParts(text, parts);
           if (parts.length > 1) {
             const jobId = 'j' + (++jobSeq).toString(36);
             const job = {
@@ -2277,7 +2351,8 @@ export function apply(ctx) {
                 chunks: [first.url],
                 total: parts.length,
                 ratio: cal.ratio,
-                chunkSec: cal.chunkSec
+                chunkSec: cal.chunkSec,
+                ...(spans ? { spans } : {})
               });
               return;
             }
@@ -2308,7 +2383,8 @@ export function apply(ctx) {
               total: parts.length,
               ratio: cal.ratio,
               chunkSec: cal.chunkSec,
-              skipped: prewarmSkipped
+              skipped: prewarmSkipped,
+              ...(spans ? { spans } : {})
             });
             return;
           }
@@ -2756,8 +2832,9 @@ export function apply(ctx) {
           checks,
           plugin: PLUGIN_META,
           worker: WORKER_META,
+          hostBuild: HOST_BUILD,
           activeJobs,
-          recent: recentErrors.slice(-20)
+          recent: recentErrors.slice(-RECENT_CAP)
         });
       } catch (e) {
         writeRouteError(res, e);
@@ -3268,6 +3345,7 @@ export const __test = {
   classifyHostError,
   countWorkerRetries,
   splitText,
+  spanParts,
   splitCloudPackets,
   chunkCal,
   cloudTier,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@memef1f1y/dsh-plugin-tts",
   "description": "Edge TTS 语音大集成插件：消息朗读按钮、自动朗读开关、语音设置面板（Edge TTS / RVC / Index-TTS2 / CosyVoice / Google Cloud TTS）",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "type": "module",
   "engines": {
     "node": ">=22"

package/tests/client-load.mjs

@@ -324,40 +324,53 @@ if (!failed) {
     // 4) onBarClick never throws on missing event + reads live shared.speaking
     const clickOk = /const onBarClick[\s\S]{0,600}?typeof e\.stopPropagation[\s\S]{0,200}?shared\.speaking\) togglePause\(\)/.test(src);
     check('onBarClick hardened (no-throw + live speaking)', clickOk);
-    // 5) live scroll-follow: continuous ratio + 250ms heartbeat + user yield
-    const liveOk = /ttsLiveRatio/.test(src) && /el\.currentTime \/ el\.duration/.test(src) && /chunkStartedAt/.test(src);
-    const beatOk = /setInterval\(keepVisible,\s*250\)/.test(src);
-    const yieldOk = /ttsUserScrollAt\.t\s*=\s*Date\.now\(\)/.test(src) && /Date\.now\(\) - ttsUserScrollAt\.t < 5000/.test(src);
-    check('scroll-follow tracks live ratio', liveOk && beatOk && yieldOk,
-      `live=${liveOk} beat=${beatOk} yield=${yieldOk}`);
-    // 5b) self-scroll guard: our own scrollTo() must not refresh the user
-    // yield window (that froze follow after the first nudge), and the needle
-    // must track the live ratio (not the fixed text head).
-    const selfOk = /ttsSelfScroll\.on = true/.test(src) && /if \(ttsSelfScroll\.on\) return/.test(src);
-    const needleOk = /fullNeedle\.length \* Math\.min\(0\.99/.test(src);
-    check('follow not frozen by own scroll + live needle', selfOk && needleOk,
-      `self=${selfOk} needle=${needleOk}`);
+    // 5) scroll-follow v2: block-index stepwise signal, visibility-driven
+    // minimal scrolling (no polling loop), latch-off with manual resume.
+    const stepOk = /const ttsBlockIdx = \(\) =>/.test(src) && /ttsBlockHead/.test(src) &&
+      !/ttsLiveRatio/.test(src) && !/chunkStartedAt \|\| Date\.now\(\)\)\) \/ 1000/.test(src);
+    const noPoll = !/setInterval\(keepVisible/.test(src) && !/setInterval\(ttsFollowTick/.test(src);
+    const latchOk = /ttsFollow\.latched = false/.test(src) && /follow\.resume/.test(src) &&
+      !/ttsUserScrollAt\.t < 5000/.test(src);
+    check('scroll-follow v2 stepwise signal, no poll, latch-off resume', stepOk && noPoll && latchOk,
+      `step=${stepOk} noPoll=${noPoll} latch=${latchOk}`);
+    // 5b) self-scroll fence via timestamp + scrollend (covers smooth-scroll
+    // duration); takeover sources are wheel/touchmove/pointer-drag only, so
+    // host autoscroll during streaming never latches follow off.
+    const selfOk = /ttsFollow\.selfUntil = Date\.now\(\) \+ 600/.test(src) && /scrollend/.test(src);
+    const takeOk = /onTouchMove/.test(src) && /onPointerMove/.test(src) && /onWheel/.test(src);
+    check('follow self-fence + gesture takeover sources', selfOk && takeOk,
+      `self=${selfOk} take=${takeOk}`);
     // 5c) message anchor: button click climbs to the message root (WeakRef),
-    // text-resolved anchors are cached for auto-read reuse.
+    // fingerprint relocate survives re-renders; paragraph hits are never
+    // cached as anchors (fragile, single-tick use).
     const anchorOk = /shared\.readingMsgEl = new WeakRef\(best\)/.test(src) &&
       /shared\.readingMsgEl \? shared\.readingMsgEl\.deref\(\) : null/.test(src);
     check('follow uses anchored message element', anchorOk);
     // 5d) anchor survives re-render (fingerprint relocate) + wrong-element
-    // guard (never rubber-band to top on a fragment hit).
+    // guard (never rubber-band on an absurd hit) + nearest-scroll.
     const relocOk = /shared\.readingMsgKey = \{ head/.test(src) && /mark\("relocated"\)/.test(src);
-    const guardOk = /mark\("bad-target"\)/.test(src);
+    const guardOk = /mark\("bad-target"\)/.test(src) && /block:"nearest"/.test(src);
     check('anchor relocates + bad target skipped', relocOk && guardOk,
       `reloc=${relocOk} guard=${guardOk}`);
+    // 5e) reduced-motion respected: follow bails before touching the view.
+    check('follow respects prefers-reduced-motion', /ttsReducedMotion\(\)/.test(src) && /mark\("reduced-motion"\)/.test(src));
+    // 5f) exact server spans feed the block locator when present (P1-3),
+    // equal-division fallback otherwise; spans reset per utterance.
+    const spansOk = /shared\.chunkSpans = Array\.isArray\(result\.spans\)/.test(src) &&
+      /shared\.chunkSpans = null/.test(src) && /sp\[idx - 1\]\[0\]/.test(src);
+    check('follow consumes server block spans with fallback', spansOk);
     // 6) compact bar: no "n / total" counter in bar text (tooltip only)
     const noCounter = !/overlay\.reading"\)\) \+ "  " \+ idx/.test(src) && !/\("overlay\.paused"\) : t\("overlay\.reading"\)\) \+/.test(src);
     const pausedOk = /shared\.paused \? t\("overlay\.paused"\) : t\("overlay\.reading"\)(?!\) \+)/.test(src);
     check('bar compact: paused/reading text only, no counter', noCounter && pausedOk,
       `noCounter=${noCounter} pausedOk=${pausedOk}`);
-    // 7) box-shadow sentence highlight removed (ugly)
+    // 7) v2 block highlight restored as the visual anchor for follow: soft
+    // background, never the old box-shadow style.
+    const hlCss = /\.dsh-tts-sentence-active\{[^}]*background/.test(src);
     const noShadowCss = !/\.dsh-tts-sentence-active\{[^}]*box-shadow/.test(src);
-    const noAddActive = !/classList\.add\("dsh-tts-sentence-active"\)/.test(src);
-    check('sentence shadow highlight removed', noShadowCss && noAddActive,
-      `noShadowCss=${noShadowCss} noAddActive=${noAddActive}`);
+    const addActive = /classList\.add\("dsh-tts-sentence-active"\)/.test(src);
+    check('block highlight restored (soft bg, no shadow)', hlCss && noShadowCss && addActive,
+      `css=${hlCss} noShadow=${noShadowCss} add=${addActive}`);
     // 8) playback mutual exclusion: playSeq generation guards all audio
     // callbacks; stop hard-aborts decode via load(); chunk queue is indexed
     // (no push-on-resolve reorder).

package/tests/smoke.mjs

@@ -330,6 +330,23 @@ if (speakRoute && audioRoute) {
         drained++;
       }
       check('rvc-next drains to total chunks', fetched === longParsed.total && more === false, `fetched=${fetched} total=${longParsed.total}`);
+      // Job-completion summary: draining to the end must leave exactly one
+      // stage=job outcome=drained entry (served==total) in the diagnose log —
+      // the trace a serve-order incident would previously have left none of.
+      {
+        const dgJob = routes.find((r) => r.kind === 'exact' && r.path === '/dsh-tts-api/diagnose');
+        const drJob = await call(dgJob, mockReq('/dsh-tts-api/diagnose', JSON.stringify({})), mockRes());
+        const ddJob = JSON.parse(drJob.body);
+        const jobHit = Array.isArray(ddJob.recent) && ddJob.recent.find((e) =>
+          e && e.stage === 'job' && /outcome=drained/.test(e.error || '') &&
+          e.total === longParsed.total && e.served === longParsed.total &&
+          Array.isArray(e.skipped) && e.skipped.length === 0);
+        check('drained job leaves a served==total summary in diagnose.recent',
+          !!jobHit, JSON.stringify((ddJob.recent || []).filter((e) => e && e.stage === 'job')));
+        check('diagnose exposes hostBuild tag (which Host code ran)',
+          typeof ddJob.hostBuild === 'string' && ddJob.hostBuild.length > 0,
+          JSON.stringify(ddJob.hostBuild));
+      }
       check('rvc-next done for unknown job', (await call(nextRoute, mockReq('/dsh-tts-api/rvc-next?job=unknown'), mockRes())).body === JSON.stringify({ done: true, gone: true }));
       // a prewarmed chunk url must serve wav through the audio route
       const cRes = await call(audioRoute, mockReq(longParsed.chunks[0]), mockRes());
@@ -404,6 +421,17 @@ if (speakRoute && audioRoute) {
           && skipParsed.chunks.length >= 2 && skipParsed.chunks[0] && skipParsed.chunks[1] === false
           && Array.isArray(skipParsed.skipped) && skipParsed.skipped.length === 1 && skipParsed.skipped[0] === 2,
           skipRes.body.slice(0, 200));
+        // P1-3 spans ride the same response: count matches total and the span
+        // slices rebuild the sent text (whitespace-insensitive).
+        {
+          const sps = skipParsed.spans;
+          const rebuilt = Array.isArray(sps)
+            ? sps.map(([a, b]) => skipText.slice(a, b)).join('').replace(/\s/g, '')
+            : null;
+          check('chunked /speak carries exact block spans',
+            Array.isArray(sps) && sps.length === skipParsed.total && rebuilt === skipText.replace(/\s/g, ''),
+            `spans=${sps && sps.length} total=${skipParsed.total}`);
+        }
         if (typeof skipParsed.jobId === 'string' && Array.isArray(skipParsed.chunks)) {
           const nextRoute = routes.find((r) => r.kind === 'exact' && r.path === '/dsh-tts-api/rvc-next');
           // serveIdx starts past prewarm; the on-demand serves must be the
@@ -800,6 +828,33 @@ if (speakRoute && audioRoute) {
     // short text: single chunk, unchanged semantics
     const r4 = splitText('你好。', 30);
     check('splitText: short text stays one chunk', r4.length === 1 && r4[0] === '你好。', JSON.stringify(r4));
+
+    // spanParts (scroll-follow P1-3): per-part char spans walk the source in
+    // order; concatenated span slices reproduce the text minus whitespace.
+    const spanOf = plugin.__test.spanParts;
+    check('__test.spanParts exposed', typeof spanOf === 'function');
+    if (typeof spanOf === 'function') {
+      const st = '第一句。第二句很长很长，需要切块 Parece que sí。第三句。';
+      const sp = splitText(st, 12);
+      const ssp = spanOf(st, sp);
+      const rebuilt = Array.isArray(ssp)
+        ? ssp.map(([a, b]) => st.slice(a, b)).join('').replace(/\s/g, '')
+        : null;
+      check('spanParts: spans walk in order and rebuild the text',
+        Array.isArray(ssp) && ssp.length === sp.length &&
+        rebuilt === st.replace(/\s/g, ''),
+        `parts=${sp.length} spans=${JSON.stringify(ssp)}`);
+      // Cloud synthetic join gaps (latin alnum boundary spaces) match zero
+      // source whitespace instead of failing the walk.
+      const cl = 'Visit https://example.com/a.b.c now please ok。'.repeat(6);
+      const cp = plugin.__test.splitCloudPackets(cl);
+      const csp = spanOf(cl, cp);
+      check('spanParts: cloud packets walk despite synthetic gaps',
+        Array.isArray(csp) && csp.length === cp.length,
+        `packets=${cp.length} spans=${csp && csp.length}`);
+      check('spanParts: unwalkable parts return null (fallback signal)',
+        spanOf('abc', ['zzz']) === null);
+    }
   }
 }