@torrent-tv/proxy 2.55.1 → 2.55.3

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2.55.3
+
+- **Fix**: A track's subtitle cues are now walked ahead of being asked for, instead of only when a browser first requests them. `cuesHeldFor` only ever read clusters on demand, inside the `/api/subtitles` request itself — cheap once caught up, but the FIRST call for a track had to walk the whole backlog of already-downloaded-but-unparsed clusters serially, with no `pending`/streaming pattern the way the ffmpeg fallback has one. On a film well into playback that backlog is not small (`Minions.and.Monsters.1080p.mkv` indexes over a thousand cluster positions per track), so a viewer who turned subtitles on after watching for a while waited on that catch-up instead of seeing cues appear at once — the opposite of the rule this file states its own reason for existing ("the region the viewer is watching is downloaded before they reach it, so its cues are ready before they are needed"): true of the DATA, not of when it got READ. A new periodic pass in the torrent worker (`warmSubtitleCues`, every 3 s, one per actively-read file) walks new clusters as they arrive, reusing `cuesHeldFor`'s own memoized state — a file nobody has opened costs nothing, and a file being watched is caught up by the time a track is switched on.
+
+- **Fix**: The decode pipe's sanity log carried a fixed editorial line — "a reading where these are far apart is worth a second look" — printed on every single reading regardless of whether the two figures actually were, which was noise the first time it ran in the field. The comparison is also now taken over the same window the speed itself is (bytes are snapshotted alongside each progress sample), rather than over the whole run from process start, which read systematically low for no reason but that mismatch. The line only says "worth a second look" when the two figures are actually more than 1.5x apart.
+
 ## 2.55.1
 
 - **Fix**: A source is now keyed by its own infohash, not by a hash of the request bytes. A magnet URI and a `.torrent` file for the same content are different bytes, so the old key (`sha1` of the source) named the same film as two unrelated sources — measured 2026-08-19, `a518ff46…` and `7ab2fb5d…` for one infohash `11f09299…` — sharing neither the swarm, nor a cache, nor any work already downloaded, and surfacing as `WebTorrent client error: Cannot add duplicate torrent`. The new key (`services/torrent-source-key.js`) reads the infohash straight out of the magnet's `btih` or the `.torrent`'s own `info` dictionary via `parse-torrent`, synchronously, with no network round trip — so both forms of the same torrent now share one entry from the first request, on both the pool's own map (`torrent-pool.js`) and the worker-thread boundary (`torrent-worker/pool-adapter.js`), instead of relying on WebTorrent's own duplicate-add error to reconcile them after the fact.

package/package.json

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

package/services/hwaccel.js

@@ -1342,17 +1342,23 @@ function decodePipedStream(ffmpegBin, stream, log = { info: () => {}, warn: () =
         return;
       }
       const speed = producedSec / windowSec;
-      // Diagnostic only — logged, not acted on. The required rate is what
-      // THIS reading implies was needed to keep the decoder fed; the achieved
-      // rate is what this process actually pushed over its whole run (a wider
-      // span than `windowSec`, since the feed starts before the first kept
-      // sample — a looser figure is enough for a sanity comparison).
-      const elapsedSec = (Date.now() - startedAt) / 1000;
-      const achievedMBps = elapsedSec > 0 ? bytesWritten / elapsedSec / 1e6 : 0;
+      // Diagnostic only — logged, not acted on. Both figures are taken over the
+      // SAME window the speed itself is: bytesWritten is snapshotted alongside
+      // every progress sample, so this compares like against like rather than
+      // the achieved rate over the whole run (which starts before the first
+      // kept sample and reads systematically low against the window's own
+      // rate for no reason but that mismatch — measured while building this).
+      const windowBytes = last.bytesWritten - first.bytesWritten;
+      const achievedMBps = windowSec > 0 ? windowBytes / windowSec / 1e6 : 0;
       const requiredMBps = ((stream.megabitsPerSecond * 1e6) / 8) * speed / 1e6;
+      // "Far apart" is stated, not left to the reader to eyeball: outside a
+      // factor of 1.5 either way is bigger than the write-timing slop this
+      // comparison carries on a healthy reading.
+      const farApart = requiredMBps > 0 && (achievedMBps / requiredMBps < 1 / 1.5 || achievedMBps / requiredMBps > 1.5);
       log.info(
         `hwaccel: decode pipe fed ${achievedMBps.toFixed(1)} MB/s, ${requiredMBps.toFixed(1)} MB/s ` +
-        `needed for ${speed.toFixed(2)}x — a reading where these are far apart is worth a second look`
+        `needed for ${speed.toFixed(2)}x` +
+        (farApart ? " — far enough apart to be worth a second look" : "")
       );
       resolve({
         speed,
@@ -1399,7 +1405,7 @@ function decodePipedStream(ffmpegBin, stream, log = { info: () => {}, warn: () =
         if (line.startsWith("out_time_ms=")) {
           const microseconds = Number(line.slice("out_time_ms=".length));
           if (Number.isFinite(microseconds)) {
-            samples.push({ wallSec: (Date.now() - startedAt) / 1000, outSec: microseconds / 1e6 });
+            samples.push({ wallSec: (Date.now() - startedAt) / 1000, outSec: microseconds / 1e6, bytesWritten });
           }
         }
         newline = stdout.indexOf("\n");

package/services/torrent-worker/subtitle-cues.js

@@ -316,6 +316,29 @@ export async function cuesHeldFor(torrent, fileIndex, sourceKey, trackNumber) {
 
 }
 
+/**
+ * Walk whatever clusters have newly arrived, for every text track a file
+ * carries — so the browser's first request for a track finds its cues already
+ * caught up instead of paying for the whole backlog inside that request.
+ *
+ * `cuesHeldFor` already skips positions it has walked before (`state.walked`),
+ * so calling this on a timer is cheap once a file is caught up: the only cost
+ * is deciding there is nothing new to read. It is `getSubtitleCues` run ahead
+ * of being asked, on the same state that call itself would build — nothing is
+ * duplicated, and a browser that never asks costs nothing beyond this.
+ *
+ * @param {object} torrent
+ * @param {number} fileIndex
+ * @param {string} sourceKey
+ * @returns {Promise<void>}
+ */
+export async function warmSubtitleCues(torrent, fileIndex, sourceKey) {
+  const plan = await planFor(torrent, fileIndex, `${sourceKey}:${fileIndex}`);
+  for (const track of plan?.tracks ?? []) {
+    await cuesHeldFor(torrent, fileIndex, sourceKey, track.trackNumber);
+  }
+}
+
 /**
  * The text subtitle tracks of a file, for the menu the viewer sees.
  *

package/services/torrent-worker/worker.js

@@ -27,7 +27,7 @@ import { parentPort, workerData } from "node:worker_threads";
 import { createSendStream } from "./channel.js";
 import { createFileClaims } from "./file-claims.js";
 import { readFragments, supplyFiguresFor } from "./piece-reader.js";
-import { cuesHeldFor, declaredSubtitleTracksOf, subtitleTracksOf } from "./subtitle-cues.js";
+import { cuesHeldFor, declaredSubtitleTracksOf, subtitleTracksOf, warmSubtitleCues } from "./subtitle-cues.js";
 import { Command, Event } from "./protocol.js";
 
 // Imported dynamically, and that is load-bearing: static imports are RESOLVED
@@ -507,4 +507,26 @@ setInterval(() => {
   }
 }, STORE_REPORT_INTERVAL_MS).unref();
 
+/**
+ * How often an actively-read file's subtitle cues are walked ahead of being
+ * asked for. Cheap once caught up (`warmSubtitleCues` skips clusters it has
+ * already read), so this can run often; every read.js pass is one it does not
+ * have to do.
+ */
+const SUBTITLE_WARMUP_INTERVAL_MS = 3_000;
+
+setInterval(() => {
+  for (const [sourceKey, torrent] of pool.torrents) {
+    const usage = pool.fileUsageByTorrent.get(torrent);
+    if (!usage) {
+      continue;
+    }
+    for (const fileIndex of usage.keys()) {
+      warmSubtitleCues(torrent, fileIndex, sourceKey).catch((error) => {
+        log(`subtitle warmup ${sourceKey}:${fileIndex} failed: ${error instanceof Error ? error.message : error}`);
+      });
+    }
+  }
+}, SUBTITLE_WARMUP_INTERVAL_MS).unref();
+
 log("torrent worker started");