@torrent-tv/proxy 2.9.67 → 2.9.69

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 2.9.69
+
+- **Fix**: Removed the last traces of the seek-start "pull", so nothing can move the encode position except the viewer's own seek. Root cause now measured rather than guessed: **during a scrub the player loads from wherever the slider pauses on its way**. Browser log 2026-08-02 — dragging from 0 to 23:34 lingered at 863.4 s, the player fetched segment #82 for that intermediate point, and a seek that had correctly resolved to start at #134 was dragged back to **#82**, then crawled forward for a minute. The browser's 300 ms debounce exists precisely to discard intermediate scrub positions; reading them back off the segment-request stream defeated it. Gone with it: `lowestAwaitedIndex` tracking, `SEEK_PULL_LIMIT_SEGMENTS`, and the reset paths they needed.
+
+## 2.9.68
+
+- **Fix**: A seek could be dragged back to the position the viewer had just left. The encoder start was pulled down to the lowest segment the player had outstanding — a stand-in from when the distance to the preceding keyframe was unknown — but at seek time those requests still describe where the player was PLAYING, not where it is going. Field 2026-08-02: a seek to 23:34 (#135) correctly resolved to a start of #134, then got pulled to **#82** (14:15, the position just left) and crawled forward from there. Removed: since boundaries became real keyframes (2.9.65), exactly one segment back always suffices, so the pull has nothing left to correct for.
+
 ## 2.9.67
 
 - **Fix**: A seek waited far longer than it needed to — 56 s measured in the field, of which roughly 50 s was self-inflicted. `SEEK_BACKOFF_SEGMENTS` (how far before the requested segment the encoder starts) was **12**, chosen when segments were an invented 4 s apart and the distance to a usable keyframe was unknown. Since 2.9.65 every boundary IS a real keyframe read from the container index, so the single preceding segment is guaranteed to start on one — and with real 10.43 s segments the old value meant encoding **125 s of content** before reaching the viewer position. Lowered to **1**. Observed: the encoder started at #332 for a seek to #344 and the requested segment only arrived 56 s later, while every segment after it was served in ~100 ms.

package/package.json

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

package/services/hls-session-manager.js

@@ -84,7 +84,6 @@ const ENCODER_STALL_MS = 12_000;
 // encoding 125 s of content before reaching the viewer's position. Field
 // 2026-08-02: a seek took 56 s, of which ~50 s was this backoff.
 const SEEK_BACKOFF_SEGMENTS = 1;
-const SEEK_PULL_LIMIT_SEGMENTS = 120;
 const SEEK_SETTLE_MS = 1_200;
 // Hard cap on the total settle wait, measured from the first far request of a
 // burst, so a still-moving scrubber cannot delay a genuine seek forever.
@@ -1107,9 +1106,6 @@ export class HlsSessionManager {
       // #wireEncodeProcess and MAX_SEEK_FAILURES.
       seekFailureTarget: -1,
       seekFailureCount: 0,
-      // Lowest segment index the player is currently waiting for; -1 when
-      // nothing is pending. See getFileStream and #fireSettledSeek.
-      lowestAwaitedIndex: -1,
       progress: {
         state: "starting",
         processedSeconds: 0,
@@ -2139,10 +2135,6 @@ export class HlsSessionManager {
     // player needs a segment containing the preceding keyframe, so one that
     // begins exactly at the target is useless to it.
     const startIndex = Math.max(0, index - SEEK_BACKOFF_SEGMENTS);
-    // A new seek invalidates everything the player was waiting for before it:
-    // those requests describe where it USED to be. Clearing here is what keeps
-    // the pull below anchored to this seek.
-    session.lowestAwaitedIndex = -1;
     logger.info(
       `transcode ${session.id} viewer seek to ${positionSeconds.toFixed(1)}s → segment #${index}, ` +
         `starting at #${startIndex} (${SEEK_BACKOFF_SEGMENTS} back for the preceding keyframe)`
@@ -2244,23 +2236,23 @@ export class HlsSessionManager {
       : producedThisRun >= this.segmentDurationSec
         ? `run produced ${producedThisRun.toFixed(1)}s (first segment done)`
         : `grace of ${RUN_FIRST_SEGMENT_GRACE_MS / 1000}s expired`;
-    // The player may be waiting on something below our fixed backoff — its own
-    // requests say exactly how far back it needs the keyframe, so honour that
-    // rather than a guess. Only ever pulls the start EARLIER, never later.
-    const awaited = session.lowestAwaitedIndex;
-    const pullFloor = Math.max(0, target - SEEK_PULL_LIMIT_SEGMENTS);
-    const effectiveTarget = awaited >= pullFloor && awaited < target ? awaited : target;
-    if (effectiveTarget !== target) {
-      logger.info(
-        `transcode ${session.id} pulling encode start #${target} → #${effectiveTarget} ` +
-          `(lowest segment the player is waiting on)`
-      );
-    }
+    // The start is exactly what requestSeek computed — one segment before the
+    // viewer's position — and nothing else may move it.
+    //
+    // An earlier version pulled it down to the lowest segment the player had
+    // outstanding, guessing how far back the preceding keyframe lay. That guess
+    // is unnecessary now (boundaries ARE keyframes since 2.9.65) and was
+    // actively wrong: during a scrub the player loads from wherever the slider
+    // paused on its way, so those requests describe INTERMEDIATE positions, not
+    // the destination. Measured 2026-08-02: dragging from 0 to 23:34 paused at
+    // 863.4 s, the player fetched #82 for it, and a seek correctly resolved to
+    // #134 was dragged back to #82. The browser's 300 ms debounce exists to
+    // discard those intermediate positions — reading them back off the request
+    // stream defeated it.
     session.seekTarget = null;
     session.seekFirstFarAt = 0;
-    session.lowestAwaitedIndex = -1;
-    logger.info(`transcode ${session.id} seek settle → restart at segment #${effectiveTarget} (${allowedBecause})`);
-    void this.#startEncodeRun(session, effectiveTarget);
+    logger.info(`transcode ${session.id} seek settle → restart at segment #${target} (${allowedBecause})`);
+    void this.#startEncodeRun(session, target);
   }
 
   /**
@@ -2464,16 +2456,6 @@ export class HlsSessionManager {
     // at this position (server-side seeking).  The caller long-polls.
     if (!isPlaylist) {
       const requestedIndex = this.segmentFormat.segmentIndexFromName(fileName);
-      // Remember the LOWEST segment currently being waited on. The player
-      // always fetches below the seek target (it needs the preceding keyframe),
-      // and by how much varies — 8 segments in one measured seek, 57 in
-      // another. This is that figure straight from the player, and
-      // #fireSettledSeek uses it to pull the encode start down when the fixed
-      // SEEK_BACKOFF_SEGMENTS floor is not deep enough. Reset whenever a run
-      // starts, so it only ever describes the pending seek.
-      if (requestedIndex >= 0 && (session.lowestAwaitedIndex < 0 || requestedIndex < session.lowestAwaitedIndex)) {
-        session.lowestAwaitedIndex = requestedIndex;
-      }
       this.#ensureEncodingFor(
         session,
         requestedIndex,