@torrent-tv/proxy 2.15.1 → 2.15.2

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.15.2
+
+- **Fix**: A segment request that can never be answered is answered as absent instead of being held for a minute. Changing audio track makes hls.js ask the new stream for segment #0 before anything else; the run was at #354, the repair reaches sixty segments back and no further, no seek was coming, and an encoder only moves forward — so the request was unanswerable from the moment it arrived, and holding it simply spent the player's own patience. Measured 2026-08-15: the track was made ready in 7.1 s at the viewer's position, and the viewer then watched a spinner for **63 s** — sixty of them the hold, the rest the player recovering after it failed. Deliberately narrower than the refusal 2.14.1 shipped and 2.14.2 withdrew: a request within the repair's reach, or one with a seek on its way, is still held, because for those the encoder is about to be moved there.
+
 ## 2.15.1
 
 - **Fix**: A magnet that never found its metadata no longer makes the same film unplayable from its own `.torrent`. One infohash is one torrent, so the second add is refused and the pool takes the one already there — which is right when it is ready and wrong when it is not: a magnet whose swarm has not answered has no file list, and everything bound to it is answered 404. Measured 2026-08-15 on the addon host: a magnet with no reachable trackers was added first, the film's own `.torrent` then joined that empty torrent instead of replacing it, `/stream` answered 404, the encoder died on its first read, and the film stayed unplayable until the proxy was restarted. A `.torrent` carries the file list, the piece hashes and the trackers outright, so when it meets a torrent with no metadata it now replaces it; two magnets still wait, because neither has anything the other lacks.

package/package.json

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

package/services/hls-session-manager.js

@@ -6067,6 +6067,35 @@ export class HlsSessionManager {
     // at this position (server-side seeking).  The caller long-polls.
     if (!isPlaylist) {
       const requestedIndex = session.segmentFormat.segmentIndexFromName(fileName);
+      // Unanswerable, and known to be: behind a run that only moves forward,
+      // too far behind for the repair to fetch it, and no seek on its way to
+      // move the encoder there. Holding it changes nothing about whether it can
+      // be produced — it only spends the player's patience.
+      //
+      // This is what a track change costs when it is held instead: measured
+      // 2026-08-15, hls.js asked the new track for segment #0 while the run was
+      // at #354, the request was held for the full minute, and only when it
+      // failed did the player move to the segment it actually needed — 63 s of
+      // spinner after a track that had been made ready in 7.
+      //
+      // Narrow on purpose. A request behind the head is USUALLY temporary: the
+      // repair moves the encoder back for anything within its reach, and a
+      // reported seek is about to move it anyway. Refusing those was 2.14.1,
+      // and it left a viewer retrying a 404 for ever.
+      if (
+        Number.isFinite(requestedIndex) &&
+        requestedIndex < (session.encodeStartIndex ?? 0) &&
+        (session.encodeStartIndex ?? 0) - requestedIndex > BEHIND_HEAD_REPAIR_MAX_SEGMENTS &&
+        session.ffmpeg != null &&
+        session.seekTarget == null &&
+        session.seekSettleTimer == null
+      ) {
+        logger.info(
+          `transcode ${session.id} segment #${requestedIndex} is ${(session.encodeStartIndex ?? 0) - requestedIndex} ` +
+          `segments behind the run and beyond the repair's reach; answered as absent rather than held`
+        );
+        return { kind: "not-found" };
+      }
       this.#ensureEncodingFor(
         session,
         requestedIndex,

package/test/behind-head-repair.test.js

@@ -108,12 +108,11 @@ test("a burst of different segments behind the run is a scan, and moves nothing"
   for (const index of scanned) {
     session.firstWantedAt.set(index, Date.now() - 1000);
   }
-  // Interleaved, as they arrive on the wire: the player opens them together
-  // rather than finishing with one before opening the next.
-  for (const seq of [1, 2]) {
-    for (const index of scanned) {
-      await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(index), { requestSeq: seq });
-    }
+  // Asked ONCE each, which is what a scan is: the player opens them together
+  // and abandons them together. Field log 2026-08-02 — #178, #681, #725, #807,
+  // #74, #245, #387 within half a second, none of them repeated.
+  for (const index of scanned) {
+    await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(index), { requestSeq: 1 });
   }
 
   assert.equal(
@@ -219,3 +218,34 @@ test("a request ahead of the run is not touched", async (t) => {
     "the running encode may yet reach it; restarting on a far request is what produced nine restarts in a minute"
   );
 });
+
+test("a request far beyond the repair's reach is answered at once, not held", async (t) => {
+  const { manager, session, dirPath } = await managerWithRunAhead();
+  t.after(async () => {
+    await manager.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  // What a track change does: hls.js asks the new stream for segment #0 while
+  // the run is hundreds of segments in. The repair cannot reach it, no seek is
+  // coming, and the run only moves forward — so it can never be produced.
+  // Measured 2026-08-15: held for the full minute, and the viewer watched a
+  // spinner for 63 s after a track that had been made ready in 7.
+  const answer = await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(0), { requestSeq: 1 });
+
+  assert.equal(answer.kind, "not-found", "answered, so the player can move on to what it can have");
+  assert.equal(session.seekTarget, null, "and the encoder was not sent to the start of the film for it");
+});
+
+test("a request just behind the run is still held, because the repair will fetch it", async (t) => {
+  const { manager, session, dirPath } = await managerWithRunAhead();
+  t.after(async () => {
+    await manager.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  const name = fmp4Format.segmentFileName(WANTED);
+  session.firstWantedAt.set(WANTED, Date.now() - 1000);
+
+  const answer = await manager.getFileStream(SESSION_ID, name, { requestSeq: 1 });
+
+  assert.equal(answer.kind, "warming-up", "within reach: the encoder is about to be moved there");
+});