@torrent-tv/proxy 2.9.92 → 2.9.93

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2.9.93
+
+- **Fix**: A seek could kill playback outright. Restarting at a position that lands exactly on a keyframe leaves a floating-point residue — `seekSeconds - snappedKeyframe` came out as `3.3333333249174757e-7` — and `String()` renders anything below 1e-6 in exponential notation, which ffmpeg's duration parser rejects: `Invalid duration for option ss`. The run died on startup, and from then on every segment request answered 500. Time arguments are now formatted in fixed notation, and a residue under a millisecond is dropped rather than passed on, because it is not a real offset.
+- **Fix**: A session could never recover from a dead encoder. The "already covered by the running encode, not restarting" shortcut did not check that the run was alive, so once one had died `session.ffmpeg` still pointed at the corpse and every later seek was waved through as already covered. One ffmpeg failure therefore became a session that answered 500 for as long as the viewer kept trying.
+- **Fix**: The look-ahead bound held the encoder back but did not keep it there. Any segment request released it, including a request for something produced ten minutes earlier, so it sawtoothed between suspended and running and drifted from 155 s to 922 s ahead of the viewer over three minutes. A request now re-evaluates the same condition the monitor uses instead of resuming outright.
+
 ## 2.9.92
 
 - **Fix**: A seek acts on what the viewer asked for, instead of waiting out guards built for a signal that no longer exists. Three delays sat in front of every seek, all of them there because a far segment REQUEST used to steer the encoder and the player's playlist scan produced dozens of them. Requests stopped steering anything when the position became explicit, so what arrives now is only ever a position the viewer stated. The settle window drops from 1.2 s to 300 ms (the browser already collapses a drag into one report at 300 ms — this was a second debounce on an already-debounced signal, and it cost 1.2 s of every measured seek). The floor between restarts drops from 4 s to 500 ms, now a guard against a client spamming the endpoint rather than a policy about noise. And a run in progress is no longer protected for up to 30 s while it reaches its first segment: finishing a segment for a position the viewer has left is work nobody wants, and the hold could delay a genuine second seek by the whole grace. Measured cost of the old behaviour, 2026-08-04: two seeks 1.3 s apart produced two restarts 4.4 s apart, the first encoding 119.5 s of content before the second killed it.

package/package.json

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

package/services/hls-session-manager.js

@@ -573,6 +573,28 @@ async function probeVideoKeyframeTimes(ffmpegBin, inputUrl, timeoutMs = 25_000)
   });
 }
 
+/**
+ * A number of seconds as ffmpeg will accept it.
+ *
+ * `String(n)` switches to exponential notation below 1e-6, and ffmpeg's
+ * duration parser rejects that outright: a field session died on
+ * `Invalid duration for option ss: 3.3333333249174757e-7`, after which the
+ * transcode was in state `failed` and every segment request answered 500 for
+ * as long as the viewer kept trying. Anything under a millisecond is also not a
+ * real offset — it is the residue of subtracting two nearly equal floats — so
+ * it is dropped rather than passed on.
+ *
+ * @param {number} value
+ * @returns {string}
+ */
+export function ffmpegSeconds(value) {
+  if (!Number.isFinite(value) || Math.abs(value) < 0.001) {
+    return "0";
+  }
+  // Microsecond resolution, fixed notation, no trailing zero noise.
+  return value.toFixed(6).replace(/\.?0+$/, "");
+}
+
 /**
  * Compute segment START times (a 0-based timeline) for a session.
  *
@@ -1588,24 +1610,41 @@ export class HlsSessionManager {
    */
   #enforceLookAhead() {
     for (const session of this.sessionsById.values()) {
-      if (!session || session.state === "disposed" || !session.ffmpeg) {
-        continue;
-      }
-      const encodedTo = Number(session.progress?.processedSeconds);
-      if (!Number.isFinite(encodedTo)) {
-        continue;
-      }
-      // 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.
-      const viewerAt = Number.isInteger(session.lastRequestedSegment)
-        ? this.#segmentStartTime(session, session.lastRequestedSegment)
-        : this.#segmentStartTime(session, session.encodeStartIndex ?? 0);
-      const ahead = encodedTo - viewerAt;
-      if (!session.encoderPaused && ahead > LOOKAHEAD_PAUSE_SECONDS) {
-        this.#pauseEncoder(session, `${Math.round(ahead)}s ahead of the viewer`);
-      } else if (session.encoderPaused && ahead <= LOOKAHEAD_RESUME_SECONDS) {
-        this.#resumeEncoder(session, `${Math.round(ahead)}s ahead of the viewer`);
-      }
+      this.#enforceLookAheadFor(session);
+    }
+  }
+
+  /**
+   * Decide whether one session's encoder should be running right now.
+   *
+   * Called both on the monitor's interval and the moment a segment is
+   * requested. It must be the SAME decision in both places: an earlier version
+   * simply resumed on any request, which meant a request for a segment produced
+   * ten minutes ago released an encoder that had nothing left to do — measured
+   * 2026-08-04, the encoder sawtoothed between suspended and running and drifted
+   * from 135 s to 702 s ahead of the viewer while doing it.
+   *
+   * @param {HlsSession} session
+   * @returns {void}
+   */
+  #enforceLookAheadFor(session) {
+    if (!session || session.state === "disposed" || !session.ffmpeg) {
+      return;
+    }
+    const encodedTo = Number(session.progress?.processedSeconds);
+    if (!Number.isFinite(encodedTo)) {
+      return;
+    }
+    // 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.
+    const viewerAt = Number.isInteger(session.lastRequestedSegment)
+      ? this.#segmentStartTime(session, session.lastRequestedSegment)
+      : this.#segmentStartTime(session, session.encodeStartIndex ?? 0);
+    const ahead = encodedTo - viewerAt;
+    if (!session.encoderPaused && ahead > LOOKAHEAD_PAUSE_SECONDS) {
+      this.#pauseEncoder(session, `${Math.round(ahead)}s ahead of the viewer`);
+    } else if (session.encoderPaused && ahead <= LOOKAHEAD_RESUME_SECONDS) {
+      this.#resumeEncoder(session, `${Math.round(ahead)}s ahead of the viewer`);
     }
   }
 
@@ -1933,17 +1972,17 @@ export class HlsSessionManager {
     if (snappedKeyframe !== null) {
       const residualSeconds = Math.max(0, seekSeconds - snappedKeyframe);
       if (snappedKeyframe > 0) {
-        args.push("-ss", String(snappedKeyframe));
+        args.push("-ss", ffmpegSeconds(snappedKeyframe));
       }
       args.push("-i", session.inputUrl);
       if (residualSeconds > 0) {
-        args.push("-ss", String(residualSeconds));
+        args.push("-ss", ffmpegSeconds(residualSeconds));
       }
     } else {
       if (seekSeconds > 0) {
         // No keyframe map (probe failed/timed out) — fall back to the previous
         // behaviour: trust the container's own accurate seek.
-        args.push("-accurate_seek", "-ss", String(seekSeconds));
+        args.push("-accurate_seek", "-ss", ffmpegSeconds(seekSeconds));
       }
       args.push("-i", session.inputUrl);
     }
@@ -1952,7 +1991,7 @@ export class HlsSessionManager {
       // segment grid; relabel output onto the original timeline so segment N
       // carries PTS = N × segmentDuration.
       if (startSeconds > 0) {
-        args.push("-output_ts_offset", String(startSeconds));
+        args.push("-output_ts_offset", ffmpegSeconds(startSeconds));
       }
     } else {
       // Branch B (video copied — only audio is transcoded): we cannot insert
@@ -1964,7 +2003,7 @@ export class HlsSessionManager {
       // beginning and desyncs audio/video). Audio is transcoded on this timeline.
       args.push("-copyts");
       if (sourceStartTime !== 0) {
-        args.push("-output_ts_offset", String(-sourceStartTime));
+        args.push("-output_ts_offset", ffmpegSeconds(-sourceStartTime));
       }
     }
     args.push(
@@ -2389,8 +2428,14 @@ export class HlsSessionManager {
       : this.#segmentStartTime(session, head);
     const currentSeg = Math.max(head, this.#segmentIndexForTime(session, processed));
     // Already covered by the running encode — the data is on its way, so
-    // restarting would only destroy work the viewer is waiting for.
-    if (index >= head && index <= currentSeg + MAX_LOOKAHEAD_SEGMENTS) {
+    // restarting would only destroy work the viewer is waiting for. The run has
+    // to be ALIVE for that to hold: after a run died, `session.ffmpeg` still
+    // pointed at the dead process and every later seek was waved through as
+    // "already covered", so nothing could ever restart it. Measured 2026-08-04:
+    // one ffmpeg failure turned into a session that answered 500 to every
+    // segment for as long as the viewer kept trying.
+    const runIsAlive = session.ffmpeg != null && !hasChildExited(session.ffmpeg);
+    if (runIsAlive && index >= head && index <= currentSeg + MAX_LOOKAHEAD_SEGMENTS) {
       logger.info(
         `transcode ${session.id} seek to ${positionSeconds.toFixed(1)}s (#${index}) ` +
           `already within the running encode (#${head}..#${currentSeg}) — not restarting`
@@ -2678,8 +2723,10 @@ export class HlsSessionManager {
       const requested = session.segmentFormat.segmentIndexFromName(fileName);
       if (requested >= 0) {
         session.lastRequestedSegment = requested;
-        // A viewer who has caught up must not wait out the monitor's interval.
-        this.#resumeEncoder(session, "a segment was requested");
+        // A viewer who has caught up must not wait out the monitor's interval —
+        // but only if they HAVE caught up, which is why this re-evaluates the
+        // same condition instead of resuming outright.
+        this.#enforceLookAheadFor(session);
       }
     }
     try {