@torrent-tv/proxy 2.9.58 → 2.9.60

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 2.9.60
+
+- **Fix**: Seeking restarted the encoder at the position it was **already encoding**, destroying the very work being waited for — visible in the field log 2026-08-02 as `restart at #865` twice within ten seconds, each killing a run that was encoding #865. While the target segment is being produced the player keeps re-requesting it, and every such request looks "far" from where the encoder USED to be, so each one re-triggered a restart at the position we had only just moved to; playback data kept appearing and vanishing, and a seek only completed when a segment happened to reach the player before the next restart. A settled seek whose target equals the current runs start index is now ignored outright. This is distinct from the 2.9.58 guard, which only decides whether to let the current run finish its first segment — not whether a new run is needed at all; that guard behaved correctly here (it logged `run produced 4.5s (first segment done)`) and still let the pointless restart through.
+
+## 2.9.59
+
+- **Chore**: Diagnostics for seek handling. The session-start line now carries the proxy version (`transcode <id> start (proxy 2.9.59) "<file>"`), so a field report answers "is the host running the build I published?" by itself. And the seek restart guard added in 2.9.58 now states its decision: either `seek #N HELD — current run has produced Xs of the Ys first segment` or, on the restart line, why it was allowed (`run is dead` / `run produced Xs (first segment done)` / `grace expired`). Previously a permitted restart was indistinguishable in the log from the runaway ping-pong the guard exists to stop, which made diagnosing "seek still did not work" guesswork.
+
 ## 2.9.58
 
 - **Fix**: A single user seek could leave playback permanently stuck with a flickering loading pill and no video. The encoder was allowed to restart at a new position even when the current run had not yet produced a **single segment**, so each restart destroyed the previous one's work and began the wait again — self-perpetuating, because the first segment after a seek is the slowest thing the pipeline does (field log 2026-08-02: restarts at #617 → #717 → #732 → #732 every 5-7 s, none producing anything). The extra targets were not further user seeks: unable to get its segment, the player SCANS the playlist (our synthetic VOD playlist lists every segment, so from its side they all exist), and each far-enough probe looked like a fresh seek. A seek restart now waits for the current run to produce its first segment (bounded by a 30 s grace, and skipped entirely if the run has died), which makes the scan harmless and lets one genuine seek complete. Independent of segment format.

package/package.json

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

package/services/hls-session-manager.js

@@ -14,7 +14,11 @@ import os from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
 import { logger } from "../utils/logger.js";
+
+/** Own package version, stamped onto session-start log lines. */
+const PROXY_VERSION = createRequire(import.meta.url)("../package.json").version;
 import {
   softwareDescriptor,
   chooseSoftwareEncodeSettings,
@@ -1077,7 +1081,10 @@ export class HlsSessionManager {
     this.sessionIdBySource.set(sourceMapKey, sessionId);
 
     logger.info(
-      `transcode ${sessionId} start "${logName}" ` +
+      // Proxy version on the session-start line: a field report always includes
+      // one of these, so "is the host actually running the build I published?"
+      // is answered by the log itself instead of a round trip to the machine.
+      `transcode ${sessionId} start (proxy ${PROXY_VERSION}) "${logName}" ` +
         `video=${transcodeVideo ? `${this.videoEncoder.name}${softwarePreset ? `/${softwarePreset}` : ""}` : "copy"} ` +
         `audio=${transcodeAudio ? "aac" : "copy"} ` +
         // Branch tag for log correlation: A = video re-encode (fixed GOP, grid
@@ -2006,6 +2013,23 @@ export class HlsSessionManager {
       session.seekFirstFarAt = 0;
       return;
     }
+    // Already encoding exactly this position — there is nothing to seek TO, so
+    // restarting can only destroy the very work being waited for. The player
+    // keeps re-requesting the target segment while it is still being produced,
+    // and every such request looks "far" from where the encoder USED to be, so
+    // without this check each one re-triggered a restart at the position we had
+    // only just moved to: field log 2026-08-02 shows `restart at #865` twice in
+    // ten seconds, each killing a run that was encoding #865. The guard below
+    // did not catch it — it only decides whether to let the current run finish,
+    // not whether a new run is needed at all.
+    if (target === session.encodeStartIndex && session.ffmpeg != null && !hasChildExited(session.ffmpeg)) {
+      logger.info(
+        `transcode ${session.id} seek #${target} ignored — the current run already starts there`
+      );
+      session.seekTarget = null;
+      session.seekFirstFarAt = 0;
+      return;
+    }
     // Minimum gap between actual restarts (the settle already collapses bursts;
     // this only guards back-to-back seeks). If still cooling down, re-arm once
     // for the remaining cooldown instead of restarting now.
@@ -2040,13 +2064,26 @@ export class HlsSessionManager {
       producedThisRun < this.segmentDurationSec &&
       sinceLastRestart < RUN_FIRST_SEGMENT_GRACE_MS
     ) {
+      logger.info(
+        `transcode ${session.id} seek #${target} HELD — current run has produced ` +
+          `${producedThisRun.toFixed(1)}s of the ${this.segmentDurationSec}s first segment ` +
+          `(${(sinceLastRestart / 1000).toFixed(1)}s into a ${RUN_FIRST_SEGMENT_GRACE_MS / 1000}s grace)`
+      );
       session.seekSettleTimer = setTimeout(() => this.#fireSettledSeek(session), SEEK_SETTLE_MS);
       session.seekSettleTimer.unref?.();
       return;
     }
+    // Why the restart was allowed — the counterpart of the HELD line above.
+    // Without it a restart is indistinguishable from the runaway ping-pong this
+    // guard exists to stop, and diagnosing a field report becomes guesswork.
+    const allowedBecause = !runIsAlive
+      ? "run is dead"
+      : producedThisRun >= this.segmentDurationSec
+        ? `run produced ${producedThisRun.toFixed(1)}s (first segment done)`
+        : `grace of ${RUN_FIRST_SEGMENT_GRACE_MS / 1000}s expired`;
     session.seekTarget = null;
     session.seekFirstFarAt = 0;
-    logger.info(`transcode ${session.id} seek settle → restart at segment #${target}`);
+    logger.info(`transcode ${session.id} seek settle → restart at segment #${target} (${allowedBecause})`);
     void this.#startEncodeRun(session, target);
   }