@torrent-tv/proxy 2.9.114 → 2.9.115

package/CHANGELOG.md

@@ -1,7 +1,7 @@
 ## 2.9.114
 
 - **Fix**: A seek leaked a pinned piece, and enough of them destroyed the torrent. A piece is pinned before its fragment is handed to the reader and released by whoever received it — but a consumer that ABANDONS the read never gets the chance, and a seek abandons it every time: the encoder is killed, the response is torn down, the loop is left between two fragments. Field 2026-08-06, one seek was enough: the store answered `Every resident piece is pinned; no slot can be freed`, and it answered it to the WebTorrent client, which closed the store and destroyed the torrent — after which every read failed with `File 0 not found`, the session went terminal, and the segment the viewer was waiting for returned an instant error. The pin of a fragment still in the consumer's hands is now dropped by the reader itself on every exit, abandonment included. Covered by a test that abandons a read mid-fragment and checks the store has nothing pinned.
-- **Chore**: The look-ahead's report that ffmpeg's position and the segments on disk disagree is limited to once a minute. It is a diagnostic, not an event, and it printed three hundred times a minute after a seek — for as long as a fresh run had not caught up with the segments an older one left behind.
+- **Chore**: The look-ahead reports that ffmpeg's position and the segments on disk disagree on the EDGES of that state — once when they part company, once when they meet again, with how long it lasted. It was printed per call of a function that runs on every segment request, which after a seek meant three hundred times a minute; a rate limit would only have hidden that the line was in the wrong place, and it could not have said how long the disagreement went on.
 
 ## 2.9.113
 

package/package.json

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

package/services/hls-session-manager.js

@@ -162,9 +162,6 @@ const MAX_SEEK_FAILURES = 3;
 // wait, not a verdict. Backed off so a source that is truly unavailable costs a
 // process every few seconds rather than continuously, and never given up on —
 // the session's own idle TTL is what ends it if the viewer leaves.
-// How often the look-ahead may report that ffmpeg's position and the segments
-// on disk disagree. It is a diagnostic, not an event.
-const LOOKAHEAD_DISAGREEMENT_LOG_MS = 60_000;
 const INPUT_RETRY_BASE_MS = 2_000;
 const INPUT_RETRY_MAX_MS = 15_000;
 // Idle TTL: a session is disposed this long after the last segment/playlist
@@ -1847,22 +1844,29 @@ export class HlsSessionManager {
     }
     // Worth knowing when the two disagree wildly — it is the only trace of
     // whatever made ffmpeg report a position it had not reached.
+    // Reported on its EDGES, because it is a state and not a stream: it starts
+    // when the two figures part company and ends when they meet again, however
+    // often this function happens to run. Printing it per call meant printing
+    // it at the rate of segment requests — three hundred times a minute after
+    // one seek — and a limit of one a minute would only have hidden that the
+    // line was in the wrong place. Two lines per occurrence also say how long
+    // it lasted, which no sampled version could.
     const claimed = Number(session.progress?.processedSeconds);
-    // Once a minute at most. The check runs on every segment request, and the
-    // two figures disagree for as long as a fresh run has not caught up with
-    // the segments an older one left on disk — which printed this line three
-    // hundred times a minute after one seek.
-    const now = Date.now();
-    if (
-      Number.isFinite(claimed) &&
-      Math.abs(claimed - encodedTo) > LOOKAHEAD_PAUSE_SECONDS &&
-      now - (session.lookAheadDisagreementLoggedAt ?? 0) > LOOKAHEAD_DISAGREEMENT_LOG_MS
-    ) {
-      session.lookAheadDisagreementLoggedAt = now;
+    const disagrees =
+      Number.isFinite(claimed) && Math.abs(claimed - encodedTo) > LOOKAHEAD_PAUSE_SECONDS;
+    if (disagrees && !session.lookAheadDisagreementSince) {
+      session.lookAheadDisagreementSince = Date.now();
       logger.info(
         `transcode ${session.id} ffmpeg claims ${Math.round(claimed)}s processed ` +
           `but has produced through ${Math.round(encodedTo)}s (segment #${producedThrough})`
       );
+    } else if (!disagrees && session.lookAheadDisagreementSince) {
+      const lastedMs = Date.now() - session.lookAheadDisagreementSince;
+      session.lookAheadDisagreementSince = 0;
+      logger.info(
+        `transcode ${session.id} ffmpeg's position and the segments on disk agree again ` +
+          `after ${(lastedMs / 1000).toFixed(1)}s (produced through ${Math.round(encodedTo)}s)`
+      );
     }
     // Where the viewer is. Before the first segment request, the position the
     // run started at — so a session nobody has read from yet is bounded too.