@torrent-tv/proxy 2.14.0 → 2.14.1

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.14.1
+
+- **Fix**: Changing the audio track no longer costs twenty seconds of silence. The player asks the NEW rendition for its segment #0 before anything else — measured 2026-08-15, a track changed at 159 s with the rendition correctly placed at #26 — and the repair that exists for a run placed WRONGLY took that literally: it killed the run and restarted the encoder at the beginning of the film, so the segment the viewer was waiting for arrived 20.5 s later. A rendition is never repaired by moving it, because its run is placed where the viewer is and the request behind it is the player probing; and such a request is now answered at once rather than held, since holding it spends the player's patience on a fragment that can never be produced. The refusal stands down while a seek of the rendition's own is settling: a viewer going BACKWARDS is reported to the base and forwarded to the rendition, but its run only moves when the settle fires, so until then the requests for the new position are behind the old one — and those are exactly the ones the viewer is waiting for.
+
 ## 2.14.0
 
 - **Fix**: A rung the source is served at by COPY is never withdrawn from the offer, and the offer is one answer for the whole file rather than one per rung. Which heights this host can serve is a property of the FILE, but a rung is a session of its own and knows only its own encode — so, asked while the viewer watched 240p, the 240p session priced the 1080p rung as a re-encode, because ITS video is re-encoded, and refused it on a machine that had been serving that exact height by copy a minute earlier. Field 2026-08-15: `proxy now offers 360p 240p` four seconds after the switch, and the viewer could not go back to the quality that worked. A copied rung costs no encoder at all, so no measurement of the host can be a reason to drop it — it is precisely where a viewer on a rung the machine cannot hold returns to.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.14.0",
+  "version": "2.14.1",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

package/services/hls-session-manager.js

@@ -3570,6 +3570,17 @@ export class HlsSessionManager {
     if (head - index > BEHIND_HEAD_REPAIR_MAX_SEGMENTS) {
       return;
     }
+    // An audio rendition is never repaired by moving it. Its run is placed
+    // where the VIEWER is, from the session they are watching, so a request
+    // behind that is not a run in the wrong place — it is the player probing.
+    // Measured 2026-08-15: changing track at 159 s, hls.js asked for the new
+    // rendition's segment #0, the repair obligingly took the encoder to the
+    // start of the film, and the audio the viewer was waiting for arrived
+    // 20.5 s later instead of at once. Left where it is, the right segment is
+    // already being produced.
+    if (session.audioOnly === true) {
+      return;
+    }
     // Nothing is encoding: a rung the viewer has switched away from is left
     // exactly so, and its held requests must not bring its encoder back.
     if (session.ffmpeg == null || hasChildExited(session.ffmpeg)) {
@@ -5863,6 +5874,34 @@ export class HlsSessionManager {
     // at this position (server-side seeking).  The caller long-polls.
     if (!isPlaylist) {
       const requestedIndex = session.segmentFormat.segmentIndexFromName(fileName);
+      // An audio rendition asked for something behind its run says so at once
+      // instead of holding. Its run is placed where the viewer is and is not
+      // moved from there, so the request can never be answered — and holding it
+      // for the full window costs the player its own patience on the fragment
+      // it needs NEXT. Measured 2026-08-15: on a track change at 159 s hls.js
+      // asked for segment #0, and a held request plus a repaired encoder cost
+      // 20.5 s of silence. Refused promptly, the player moves to the segment
+      // that is genuinely being produced.
+      if (
+        session.audioOnly === true &&
+        Number.isFinite(requestedIndex) &&
+        requestedIndex < (session.encodeStartIndex ?? 0) &&
+        session.ffmpeg != null &&
+        // Not while a seek of its own is settling. A viewer seeking BACKWARDS
+        // is reported to the base and forwarded here, but the run only moves
+        // when the settle fires — until then `encodeStartIndex` still names the
+        // old position, and every request for the new one is "behind" it. Those
+        // are exactly the requests the viewer is waiting for, so they are held,
+        // as they were before this refusal existed.
+        session.seekTarget == null &&
+        session.seekSettleTimer == null
+      ) {
+        logger.info(
+          `transcode ${session.id} audio segment #${requestedIndex} is behind this rendition's run ` +
+          `(#${session.encodeStartIndex}); it is not made and the run stays where the viewer is`
+        );
+        return { kind: "not-found" };
+      }
       this.#ensureEncodingFor(
         session,
         requestedIndex,

package/test/quality-variants.test.js

@@ -637,3 +637,47 @@ test("a rung served by copy stays offered while a re-encoded rung is on screen",
     "one answer for the family: a rung asked while watching another must not disagree with the base"
   );
 });
+
+test("an audio rendition refuses a segment behind its run instead of chasing it", async (t) => {
+  const { manager, dirPath } = await managerWithBase();
+  t.after(async () => {
+    await manager.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  // The field case of 2026-08-15: the viewer changes track at 159 s, the
+  // rendition is placed there (#26), and hls.js asks for its segment #0.
+  const RENDITION_ID = "99999999-8888-7777-6666-555555555555";
+  const rendition = fakeSession({ id: RENDITION_ID, encodeHeight: 0, dirPath });
+  rendition.audioOnly = true;
+  rendition.audioTrackIndex = 1;
+  rendition.encodeStartIndex = 26;
+  rendition.usesExplicitCuts = true;
+  rendition.ffmpeg = fakeEncoder();
+  rendition.variantBases = new Set([BASE_ID]);
+  manager.sessionsById.set(RENDITION_ID, rendition);
+
+  const answer = await manager.getFileStream(RENDITION_ID, "segment-00000.mp4");
+  // The distinction that matters: "not-found" is an answer, "warming-up" is the
+  // long poll — and holding this one is what cost 20.5 s of silence, because it
+  // can never be produced.
+  assert.notEqual(answer.kind, "warming-up", "not held: this request is unanswerable, not early");
+  assert.equal(
+    answer.kind,
+    "not-found",
+    "answered at once: the run stays where the viewer is, so this can never be produced"
+  );
+  assert.equal(rendition.encodeStartIndex, 26, "and the encoder was not moved to the start of the film");
+  assert.equal(rendition.seekTarget ?? null, null, "no seek was armed for it either");
+
+  // A seek of its own is the case where "behind the run" is temporary and real:
+  // the viewer went backwards, the base forwarded it here, and the run moves
+  // when the settle fires. Until then the request is held, not refused — it is
+  // the one the viewer is waiting for.
+  rendition.seekTarget = 4;
+  rendition.seekSettleTimer = setTimeout(() => {}, 60_000);
+  t.after(() => clearTimeout(rendition.seekSettleTimer));
+
+  const duringSeek = await manager.getFileStream(RENDITION_ID, "segment-00005.mp4");
+
+  assert.equal(duringSeek.kind, "warming-up", "held: the run is about to move there");
+});