@torrent-tv/proxy 2.9.103 → 2.9.105

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 2.9.105
+
+- **Fix**: A reader's claim on pieces is put back when WebTorrent drops it, which is what stopped a download dead for eleven minutes. A reader declares the window it needs as a selection and withdraws it when it ends; that claim turns out not to be durable — the library deletes a selection the moment every piece in it is present (`remove fully downloaded selection`). While the reader keeps moving this is invisible, because the next window is claimed at once. It is fatal when the reader STOPS: the encoder gets held back by the look-ahead cap, ffmpeg stops reading, the reader parks on a window that is fully downloaded, the selection disappears, and no code of ours can notice because the reader is parked inside a write. Measured 2026-08-05: the encoder was suspended at 22:44:51, the download hit zero at 22:45:05 and stayed there for eleven minutes with 150 peer connections open and the new diagnostic reading `0 selection(s) covering 0 piece(s), 0 being asked, 0 blocks in flight`; when the encoder was let go there was nothing ahead of it. Live reader windows are now re-asserted from the pool's own timer, using the set the piece store already keeps, and only where something is actually missing — re-claiming a satisfied window would only be deleted again on the next pass.
+
+## 2.9.104
+
+- **Fix**: An encoder run that stops because its input ran dry is no longer reported as a finished file. ffmpeg exits 0 both when it reaches the end of the source and when the source simply stops delivering, and over HTTP it cannot tell the two apart — so when a torrent's download died mid-session (field 2026-08-05), a run that had produced 188 segments of 624 logged `encode-run complete`, the player consumed what was already on disk and then froze for 60 s on the first segment nobody was making. The claim is now checked against the playlist that was published: a run that stopped short is a failure, which the session can restart, rather than a completed file.
+- **New**: A download that stalls says so, and says which of the two possible reasons it is. The same session spent five minutes at **1 KB/s** with 186 peer connections open and trackers reporting ~300 seeders, on a torrent that was not finished, and produced no log line at all — the collapse had to be reconstructed afterwards from three unrelated counters. A torrent with an active reader that drops below 32 KB/s for ten seconds now reports how many pieces are selected and still missing, how many are marked critical, how many peers hold what we want, how many are choking us, how many are being asked and how many blocks are in flight. That separates "the swarm was never told what we need" from "it was told and will not deliver", which the previous evidence could not.
+
 ## 2.9.103
 
 - **Fix**: Playback worked in neither 2.9.101 nor 2.9.102. Both cold-start estimates keep a window of recent samples, and the constant naming that window was used twice and declared nowhere. The session-create one runs on every new session, so `POST /api/transcode-sessions` answered 500 to every viewer and the browser then reported the first segment missing. Field session 2026-08-05: the plan succeeded in 5858 ms, the session request failed 47 ms later, the data channel closed 16 ms after that.

package/package.json

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

package/services/hls-session-manager.js

@@ -7,7 +7,7 @@
  * immediately when all registered consumers release them.
  */
 
-import { createReadStream } from "node:fs";
+import { createReadStream, readdirSync } from "node:fs";
 import { access, mkdir, readdir, readFile, rm, stat } from "node:fs/promises";
 import { Readable } from "node:stream";
 import os from "node:os";
@@ -2394,6 +2394,29 @@ export class HlsSessionManager {
         return;
       }
       if (code === 0) {
+        // ffmpeg exits 0 both when it reaches the end of the file and when its
+        // input simply stops producing bytes — over HTTP the two look identical
+        // to it. Field 2026-08-05: the torrent's download died, the read ended,
+        // and a run that had made 188 segments of 624 reported itself complete;
+        // the player then consumed what was on disk and froze on the first
+        // segment nobody was making. So the claim is checked against the
+        // playlist we published, and a run that stopped short is a FAILURE that
+        // can be restarted, not a finished file.
+        const producedThrough = this.#latestProducedSegment(session);
+        const expectedLast = session.segmentCount > 0 ? session.segmentCount - 1 : null;
+        if (expectedLast !== null && producedThrough !== null && producedThrough < expectedLast) {
+          session.state = "failed";
+          session.progress.state = "failed";
+          session.progress.updatedAt = Date.now();
+          session.lastError =
+            `input ended after segment #${producedThrough} of ${expectedLast} — ` +
+            "the source stopped delivering data";
+          logger.error(
+            `transcode ${session.id} ${session.runLabel ?? "run#?"} encode-run ended early: ` +
+            `${session.lastError} "${session.fileName}"`
+          );
+          return;
+        }
         session.state = "ready";
         session.progress.state = "ready";
         session.progress.updatedAt = Date.now();
@@ -2823,6 +2846,27 @@ export class HlsSessionManager {
     return sorted[Math.floor(sorted.length / 2)];
   }
 
+  /**
+   * The highest segment index this session has on disk, or null when it has
+   * none. Used to tell "the file ended" from "the data ran out".
+   *
+   * @param {HlsSession} session
+   * @returns {number | null}
+   */
+  #latestProducedSegment(session) {
+    let highest = null;
+    for (const name of readdirSync(session.dirPath, { withFileTypes: false })) {
+      if (!this.segmentFormat.isSegmentFileName(name)) {
+        continue;
+      }
+      const index = this.segmentFormat.segmentIndexFromName(name);
+      if (index >= 0 && (highest === null || index > highest)) {
+        highest = index;
+      }
+    }
+    return highest;
+  }
+
   /**
    * How many times the viewer has moved since this session started.
    *

package/services/piece-store/piece-lru.js

@@ -200,6 +200,18 @@ export class PieceLru {
    * @param {string|number} readerId
    * @returns {void}
    */
+  /**
+   * Every live reader's declared window. Read by the pool to check that the
+   * torrent has actually been asked for those pieces — WebTorrent deletes a
+   * selection of its own accord once it is fully downloaded, so a claim made
+   * once does not stay made.
+   *
+   * @returns {Array<{ from: number, to: number }>}
+   */
+  protectedRanges() {
+    return [...this.#protected.values()].map((range) => ({ from: range.from, to: range.to }));
+  }
+
   unprotect(readerId) {
     this.#protected.delete(readerId);
   }