@torrent-tv/proxy 2.9.119 → 2.9.120

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2.9.120
+
+- **Fix**: The rest of the file is fetched while the viewer needs nothing, instead of the link sitting idle. The background fill was re-evaluated only when a reader window MOVED, so during exactly the state it exists for — the encoder held back by the look-ahead cap, the viewer comfortably ahead, the link free — nothing was fetched at all. It is now owned by the pool's own timer rather than by the reader, because a parked reader cannot act, and parked is the whole point. Priority 0 against the window's 1, and withdrawn the moment any reader window wants something, so it can never take capacity from the picture.
+- **Fix**: The stall warning stays quiet when a download of zero is correct. It fired all through a healthy session on 2026-08-06 — 65.3% of the file present, the encoder 134-159 s ahead, its window complete — and a warning that goes off when everything is right teaches the reader to ignore it. It now checks whether any reader window is actually missing a piece before saying anything.
+- **New**: The progress response carries what this host takes to create a session and to produce a first segment. Both are on the playback plan too, but the browser reads that once per file: measured 2026-08-06 across four seeks, a proxy that had just restarted answered null for both, so every later seek estimated the wait with one term of four — the figure reached zero after 3.5 s of an 11.8 s wait and read "starting now" for the remaining 8.4 s. This response is polled about every 1.5 s.
+
 ## 2.9.119
 
 - **Fix**: The progress report says the height the viewer is actually watching, not only the one an encoder is producing. It was zero whenever the video was copied — which is most sessions — so the quality menu read a bare "Auto" in exactly the case it was built to explain. Copying reports the source height, re-encoding reports the rung the proxy has settled on.

package/package.json

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

package/services/hls-session-manager.js

@@ -3504,6 +3504,15 @@ export class HlsSessionManager {
       currentHeight: session.transcodeVideo
         ? (session.encodeHeight ?? session.sourceHeight ?? 0)
         : (session.sourceHeight ?? 0),
+      // What this host takes to create a session and to make a first segment.
+      // Also on the playback plan, but the browser reads that once per file:
+      // measured 2026-08-06 across four seeks, a proxy that had just restarted
+      // answered null for both, and every later seek then computed its estimate
+      // with one term of four — the figure hit zero after 3.5 s of an 11.8 s
+      // wait and read "starting now" for the remaining 8.4 s. This response is
+      // polled about every 1.5 s, so carrying them here keeps them current.
+      expectedSessionCreateMs: this.expectedSessionCreateMs(),
+      expectedFirstSegmentMs: this.expectedFirstSegmentMs(),
       updatedAt: session.progress.updatedAt,
       error: session.state === "failed" ? session.lastError : ""
     };

package/services/torrent-pool.js

@@ -450,6 +450,14 @@ export class TorrentPool {
    */
   #readPositionByTorrent = new Map();
 
+  /**
+   * The background-fill selection held for each torrent, so it can be withdrawn
+   * again. See #updateBackgroundFill.
+   *
+   * @type {Map<import("webtorrent").Torrent, { from: number, to: number }>}
+   */
+  #backgroundFill = new Map();
+
   /** When each torrent's download first fell below the stall threshold. */
   #stallSince = new Map();
   /** When each torrent's stall was last reported, so it is not repeated hotly. */
@@ -663,6 +671,97 @@ export class TorrentPool {
     }
   }
 
+  /**
+   * The reader windows of a torrent, and whether any of them still wants
+   * something. Two questions with one answer, because both callers below need
+   * exactly this: the background fill may only run when nothing is wanted, and
+   * a download sitting at zero is only worth warning about when something is.
+   *
+   * @param {import("webtorrent").Torrent} torrent
+   * @returns {{ ranges: Array<{ from: number, to: number }>, missing: boolean }}
+   */
+  #readerDemand(torrent) {
+    const store = findSharedStore(torrent);
+    const ranges = typeof store?.protectedRanges === "function" ? store.protectedRanges() : [];
+    let missing = false;
+    for (const range of ranges) {
+      for (let index = range.from; index <= range.to; index += 1) {
+        if (!torrent.bitfield?.get(index)) {
+          missing = true;
+          break;
+        }
+      }
+      if (missing) {
+        break;
+      }
+    }
+    return { ranges, missing };
+  }
+
+  /**
+   * Keep fetching the rest of the file while the viewer needs nothing.
+   *
+   * Owned here rather than by the reader, because the reader cannot act while
+   * it is parked — and parked is exactly the state this is for. The encoder is
+   * held back by the look-ahead cap, the viewer is comfortably ahead, the link
+   * is idle: that is the cheapest bandwidth of the whole session and it was
+   * going unused, because the fill was re-evaluated only when a reader window
+   * MOVED. Priority 0 against the window's 1, and withdrawn the moment any
+   * window wants something, so it can never take capacity from the picture.
+   *
+   * @param {import("webtorrent").Torrent} torrent
+   * @param {{ ranges: Array<{ from: number, to: number }>, missing: boolean }} demand
+   * @returns {void}
+   */
+  #updateBackgroundFill(torrent, demand) {
+    const held = this.#backgroundFill.get(torrent) ?? null;
+    const wanted = !demand.missing && demand.ranges.length > 0
+      ? this.#tailAfterWindows(torrent, demand.ranges)
+      : null;
+    if (held && (!wanted || held.from !== wanted.from || held.to !== wanted.to)) {
+      try {
+        torrent._deselect?.(held.from, held.to, false);
+      } catch {
+        // Best effort.
+      }
+      this.#backgroundFill.delete(torrent);
+    }
+    if (wanted && !this.#backgroundFill.has(torrent)) {
+      try {
+        torrent._select?.(wanted.from, wanted.to, 0, null, false);
+        this.#backgroundFill.set(torrent, wanted);
+      } catch {
+        // Best effort.
+      }
+    }
+  }
+
+  /**
+   * Everything after the furthest reader window, up to the end of the file it
+   * belongs to. Null when there is nothing left.
+   *
+   * @param {import("webtorrent").Torrent} torrent
+   * @param {Array<{ from: number, to: number }>} ranges
+   * @returns {{ from: number, to: number } | null}
+   */
+  #tailAfterWindows(torrent, ranges) {
+    const pieceLength = Number(torrent.pieceLength);
+    if (!Number.isFinite(pieceLength) || pieceLength <= 0) {
+      return null;
+    }
+    const usage = this.fileUsageByTorrent.get(torrent);
+    let lastPiece = -1;
+    for (const [fileIndex, count] of usage ?? []) {
+      const file = count > 0 ? torrent.files?.[fileIndex] : null;
+      if (!file) {
+        continue;
+      }
+      lastPiece = Math.max(lastPiece, Math.floor((file.offset + file.length - 1) / pieceLength));
+    }
+    const from = Math.max(...ranges.map((range) => range.to)) + 1;
+    return lastPiece >= from ? { from, to: lastPiece } : null;
+  }
+
   #reportStalledDownloads() {
     const now = Date.now();
     for (const torrent of this.torrents.values()) {
@@ -675,6 +774,16 @@ export class TorrentPool {
         this.#stallSince.delete(torrent);
         continue;
       }
+      // Nothing is being downloaded because nothing is wanted: every reader has
+      // all the pieces of its window. That is the encoder being held back, not
+      // a fault, and it warned all through a healthy session on 2026-08-06 —
+      // 65.3% of the file present, the encoder 134-159 s ahead, its window
+      // complete. A warning that fires when everything is right teaches the
+      // reader to ignore it.
+      if (!this.#readerDemand(torrent).missing) {
+        this.#stallSince.delete(torrent);
+        continue;
+      }
       const since = this.#stallSince.get(torrent) ?? now;
       this.#stallSince.set(torrent, since);
       if (now - since < STALL_REPORT_AFTER_MS) {
@@ -703,6 +812,13 @@ export class TorrentPool {
       Date.now()
     );
     this.#reassertReaderWindows();
+    for (const torrent of this.torrents.values()) {
+      const usage = this.fileUsageByTorrent.get(torrent);
+      if (!usage || usage.size === 0 || torrent?.done === true) {
+        continue;
+      }
+      this.#updateBackgroundFill(torrent, this.#readerDemand(torrent));
+    }
     this.#reportStalledDownloads();
     const { bytesPerSec, reason } = decideUploadLimit(active);
     if (bytesPerSec === this.#uploadLimit) {

package/services/torrent-worker/piece-reader.js

@@ -322,90 +322,18 @@ export async function* readFragments({
    * @type {(() => void) | null}
    */
   let releaseHeldPin = null;
-  /**
-   * The rest of the file, claimed at the lowest priority so it is fetched with
-   * whatever capacity the near window does not need. Null whenever it must not
-   * be fetched at all — see {@link updateBackfill}.
-   *
-   * @type {{ from: number, to: number } | null}
-   */
-  let backfill = null;
 
   // Identity of this read, so the store can tell one reader's window from
   // another's. Each read gets its own; `readerSequence` never repeats within a
   // process.
   const readerId = `read-${(readerSequence += 1)}`;
 
-  /**
-   * Whether every piece of the current window is already downloaded.
-   *
-   * A handful of pieces, checked against the bitfield, so this is cheap enough
-   * to re-run on every window move.
-   *
-   * @returns {boolean}
-   */
-  const windowIsComplete = () => {
-    if (!window) {
-      return false;
-    }
-    for (let index = window.from; index <= window.to; index += 1) {
-      if (!torrent.bitfield?.get(index)) {
-        return false;
-      }
-    }
-    return true;
-  };
-
-  /**
-   * Keep the rest of the file downloading in the background, but ONLY while
-   * that cannot cost the viewer anything.
-   *
-   * The rule is deliberately blunt rather than clever: the tail is in the
-   * download set only when every piece of the near window is already on hand.
-   * The moment one is missing — the window slid onto undownloaded content, or a
-   * seek moved it somewhere new — the tail leaves the set, so the swarm has
-   * nothing else to work on. Relying on WebTorrent's priority ordering alone
-   * would be weaker: it decides which selection a wire is offered FIRST, not
-   * what a wire already has outstanding, so a seek would still queue behind
-   * whatever tail blocks were in flight.
-   *
-   * Priority 0 against the window's 1 is kept as well, for the moments between
-   * one evaluation and the next.
-   *
-   * What this buys: a file watched for a while ends up downloaded, and every
-   * later seek into it is instant. What it costs: the pool owner's bandwidth
-   * and disk for a film the viewer may abandon — which is why it never runs
-   * ahead of the viewer's own needs.
-   *
-   * @returns {void}
-   */
-  const updateBackfill = () => {
-    const wanted = window && window.to < lastPiece && windowIsComplete()
-      ? { from: window.to + 1, to: lastPiece }
-      : null;
-    if (backfill && (!wanted || backfill.from !== wanted.from || backfill.to !== wanted.to)) {
-      releaseWindow(torrent, backfill);
-      backfill = null;
-    }
-    if (wanted && !backfill) {
-      claimWindow(torrent, wanted, 0);
-      backfill = wanted;
-    }
-  };
-
   const moveWindowTo = (pieceIndex) => {
     const next = readWindowFor({ pieceIndex, lastPiece, windowPieces });
     if (window && window.from === next.from && window.to === next.to) {
-      updateBackfill();
       return;
     }
     const isJump = !window || next.from > window.to || next.from < window.from;
-    // Whatever was being fetched for later stops being wanted the instant the
-    // window moves: the new position has to have the whole swarm to itself.
-    if (backfill) {
-      releaseWindow(torrent, backfill);
-      backfill = null;
-    }
     if (window) {
       releaseWindow(torrent, window);
     }
@@ -429,9 +357,6 @@ export async function* readFragments({
         );
       }
     }
-    // Only now, with the new window claimed and marked, may anything else be
-    // asked for — and only if the window needs nothing.
-    updateBackfill();
   };
 
   try {
@@ -555,9 +480,6 @@ export async function* readFragments({
     // Reached on completion, on cancellation, on a throw, and when the consumer
     // stops iterating — a window left behind would keep the swarm fetching for
     // a reader that no longer exists.
-    if (backfill) {
-      releaseWindow(torrent, backfill);
-    }
     if (window) {
       releaseWindow(torrent, window);
     }