@torrent-tv/proxy 2.9.104 → 2.9.106

package/services/playback-planner.js

@@ -286,6 +286,31 @@ export function createPlaybackPlanner({
    */
   const mediaInfoCache = new Map();
 
+  /**
+   * Attach what this host currently measures itself taking to create a session
+   * and to produce a first segment.
+   *
+   * Read at RESPONSE time, deliberately. Both are medians of sessions that have
+   * already finished on this host, so at the moment a plan is BUILT the very
+   * first file opened after a restart has none and gets `null` — and the plan
+   * is then cached, so that file kept answering `null` for the life of the
+   * process however many sessions ran afterwards. Measured 2026-08-05: a fresh
+   * 2.9.103 answered `null` for both, then produced the session in 6 ms and the
+   * first segment in 21 479 ms. The figures existed; the plan could not carry
+   * them, and the browser's estimate fell back to its own guess in exactly the
+   * cold-start case the feature was built for.
+   *
+   * @param {PlaybackPlan} plan
+   * @returns {PlaybackPlan}
+   */
+  function withHostTimings(plan) {
+    return {
+      ...plan,
+      expectedFirstSegmentMs: expectedFirstSegmentMs?.() ?? null,
+      expectedSessionCreateMs: expectedSessionCreateMs?.() ?? null
+    };
+  }
+
   return {
     /**
      * Media info the planner already probed for this file, or `null`. Lets the
@@ -322,7 +347,7 @@ export function createPlaybackPlanner({
       const cacheKey = `${sourceKey}:${fileIndex}`;
       const cached = cache.get(cacheKey);
       if (cached) {
-        return cached;
+        return withHostTimings(cached);
       }
       // Where the time before playback goes. `cold-start` already breaks down
       // everything from the transcode-session request onwards, but the plan
@@ -365,7 +390,7 @@ export function createPlaybackPlanner({
           subtitleTracks: []
         };
         cache.set(cacheKey, plan);
-        return plan;
+        return withHostTimings(plan);
       }
 
       // Pre-fetch file edges (head + tail), then probe — retrying while the
@@ -402,8 +427,6 @@ export function createPlaybackPlanner({
       }
       const { audioCodec, videoCodec, container, durationSeconds, videoWidth, videoHeight, audioTracks, subtitleTracks } = probe;
       const codecsDetected = audioCodec.length > 0 || videoCodec.length > 0;
-      const firstSegmentMs = expectedFirstSegmentMs?.() ?? null;
-      const sessionCreateMs = expectedSessionCreateMs?.() ?? null;
       logger.info(
         `plan ${sourceKey.slice(0, 8)}:${fileIndex} torrent-ready=${torrentReadyMs}ms ` +
           `file-edges=${edgesReadyMs - torrentReadyMs}ms probe=${Date.now() - planEntryMs - edgesReadyMs}ms ` +
@@ -463,9 +486,9 @@ export function createPlaybackPlanner({
             timeoutMs: 60_000
           })
           .catch(() => {});
-        return plan;
+        return withHostTimings(plan);
       }
-      return { ...plan, pending: true };
+      return withHostTimings({ ...plan, pending: true });
     }
   };
 }

package/services/torrent-pool.js

@@ -12,7 +12,7 @@ import path from "node:path";
 import { rmSync, statfsSync } from "node:fs";
 import WebTorrent from "webtorrent";
 import { logger } from "../utils/logger.js";
-import { SharedPieceStore } from "./piece-store/shared-piece-store.js";
+import { SharedPieceStore, findSharedStore } from "./piece-store/shared-piece-store.js";
 
 // WebTorrent's default download root (see webtorrent lib/torrent.js: TMP =
 // path.join(os.tmpdir(), 'webtorrent')). We use the default store, so all
@@ -596,6 +596,73 @@ export class TorrentPool {
    *
    * @returns {void}
    */
+  /**
+   * Put back the reader windows WebTorrent has quietly dropped.
+   *
+   * A reader claims its window as a stream selection and releases it when it
+   * ends. That claim is NOT durable: `_gcSelections` deletes a selection the
+   * moment every piece in it is present, so a window that has been satisfied
+   * stops existing — and with it, everything the swarm had been asked for.
+   *
+   * While a reader keeps moving that is invisible, because the next window is
+   * claimed immediately. It becomes fatal when the reader STOPS: the encoder is
+   * held back by the look-ahead cap, ffmpeg stops reading, the reader parks on a
+   * window that is fully downloaded, the selection disappears — and nothing our
+   * code runs can notice, because the reader is parked inside a write. Measured
+   * 2026-08-05: the encoder was suspended at 22:44:51, the download hit zero at
+   * 22:45:05 and stayed there for **eleven minutes** with 150 peer connections
+   * open, `0 selection(s) covering 0 piece(s), 0 being asked, 0 blocks in
+   * flight`. When the encoder was let go there was nothing ahead of it, and the
+   * viewer's picture stopped.
+   *
+   * So the claim is re-asserted from outside, on this timer, using the windows
+   * the store already knows about — those are declared by live readers and
+   * withdrawn when they end, which is exactly the set that should be selected.
+   *
+   * @returns {void}
+   */
+  #reassertReaderWindows() {
+    for (const torrent of this.torrents.values()) {
+      const usage = this.fileUsageByTorrent.get(torrent);
+      if (!usage || usage.size === 0 || torrent?.done === true) {
+        continue;
+      }
+      const store = findSharedStore(torrent);
+      const ranges = typeof store?.protectedRanges === "function" ? store.protectedRanges() : [];
+      if (ranges.length === 0) {
+        continue;
+      }
+      const items = Array.isArray(torrent?._selections?._items) ? torrent._selections._items : [];
+      for (const range of ranges) {
+        const present = items.some((item) => item?.from === range.from && item?.to === range.to);
+        if (present) {
+          continue;
+        }
+        // Only worth re-claiming what is actually missing: re-claiming a window
+        // that is already complete would be deleted again on the next pass and
+        // the two would take turns forever.
+        let missing = false;
+        for (let index = range.from; index <= range.to && !missing; index += 1) {
+          if (!torrent.bitfield?.get(index)) {
+            missing = true;
+          }
+        }
+        if (!missing) {
+          continue;
+        }
+        try {
+          torrent._select(range.from, range.to, 1, null, true);
+          logger.info(
+            `torrent-pool: [${String(torrent.infoHash).slice(0, 8)}] re-claimed reader window ` +
+            `${range.from}-${range.to} — the selection had been dropped once it was satisfied`
+          );
+        } catch {
+          // Best effort: a torrent being torn down is not worth failing over.
+        }
+      }
+    }
+  }
+
   #reportStalledDownloads() {
     const now = Date.now();
     for (const torrent of this.torrents.values()) {
@@ -635,6 +702,7 @@ export class TorrentPool {
       this.fileUsageByTorrent,
       Date.now()
     );
+    this.#reassertReaderWindows();
     this.#reportStalledDownloads();
     const { bytesPerSec, reason } = decideUploadLimit(active);
     if (bytesPerSec === this.#uploadLimit) {

package/test/plan-host-timings.test.js

@@ -0,0 +1,68 @@
+/**
+ * @file The host's own timings must reach the browser for the file that needs
+ * them most.
+ *
+ * The plan carries two figures the browser cannot measure for itself: how long
+ * this host takes to create a session, and how long it takes to produce a first
+ * segment. Both are medians of sessions that have already finished here, so at
+ * the moment a plan is BUILT the very first file opened after a restart has
+ * neither — and the plan is cached, so that file kept answering `null` for the
+ * life of the process however many sessions ran afterwards. Measured
+ * 2026-08-05: a fresh proxy answered `null` for both, then created the session
+ * in 6 ms and produced the first segment in 21 479 ms.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createPlaybackPlanner } from "../services/playback-planner.js";
+
+/**
+ * A planner whose host timings can be changed between calls, over a source that
+ * needs no torrent: transcoding disabled short-circuits to a cached direct plan
+ * without probing anything.
+ */
+function plannerWithTimings() {
+  const timings = { create: null, first: null };
+  const planner = createPlaybackPlanner({
+    ffmpegBin: "ffmpeg",
+    localBaseUrl: "http://127.0.0.1:9090/stream",
+    sourceRegistry: { get: () => ({ sourceType: "magnet", source: "magnet:?xt=urn:btih:0" }) },
+    torrentPool: { getTorrent: async () => ({ files: [{ name: "a.mkv", length: 10 }] }) },
+    transcodeAudioEnabled: false,
+    expectedSessionCreateMs: () => timings.create,
+    expectedFirstSegmentMs: () => timings.first
+  });
+  return { planner, timings };
+}
+
+test("a plan built before the host had measured anything still reports them later", async () => {
+  const { planner, timings } = plannerWithTimings();
+
+  const cold = await planner.getPlan({ sourceKey: "src", fileIndex: 0 });
+  assert.equal(cold.expectedSessionCreateMs, null, "nothing has finished yet, so there is nothing to report");
+  assert.equal(cold.expectedFirstSegmentMs, null);
+
+  // Sessions run; the host now knows what it costs.
+  timings.create = 6;
+  timings.first = 21_479;
+
+  const warm = await planner.getPlan({ sourceKey: "src", fileIndex: 0 });
+  assert.equal(
+    warm.expectedSessionCreateMs,
+    6,
+    "the cached plan withheld the figure the browser needed"
+  );
+  assert.equal(warm.expectedFirstSegmentMs, 21_479);
+});
+
+test("the figures follow the host as they change", async () => {
+  const { planner, timings } = plannerWithTimings();
+  timings.create = 100;
+  timings.first = 800;
+  const first = await planner.getPlan({ sourceKey: "src", fileIndex: 0 });
+  assert.equal(first.expectedFirstSegmentMs, 800);
+
+  timings.first = 7_000; // a re-encode session — an order of magnitude slower
+  const later = await planner.getPlan({ sourceKey: "src", fileIndex: 0 });
+  assert.equal(later.expectedFirstSegmentMs, 7_000, "the plan reported a stale figure");
+});