@torrent-tv/proxy 2.9.58 → 2.9.59

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 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.59",
   "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
@@ -2040,13 +2047,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);
   }