@torrent-tv/proxy 2.40.2 → 2.41.0

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 2.41.0
+
+- **Fix**: An embedded subtitle track is prepared in the background and kept, instead of being extracted afresh inside a request the browser cannot hold open. Extracting one makes ffmpeg read the WHOLE film, because subtitles are interleaved through it — measured 2026-08-19 on a release with three tracks: track 0 produced **3040 bytes over 752 seconds**, track 1 76 KB over 193 s, track 2 68 KB over 55 s, with the data channel idle throughout (`maxBuffered=0`, the time all in reading the body). The browser gives up at sixty seconds, and every retry started the same twelve-minute scan again, so the first track never arrived at all. The route now starts the work once per `(source, file, track)`, answers `202 { pending: true }` while it runs, and serves the kept result the moment it exists. The scan still takes what it takes; what changes is that it happens once and its result is not thrown away.
+- **New**: Every read says which way it claimed its pieces, whatever the outcome. The arm — `flat` or `bands`, chosen at random per read so the two accumulate side by side — was named only beside a WAIT, and across eight sessions on 2026-08-19 there were none: the swarm kept up, the log recorded nothing, and the comparison the arms exist for could not tell whether either had ever run. A read now reports its arm, what it delivered, how long it took and how much of that was spent waiting, at its end and under every outcome. "No wait" is the result worth counting, and it was the one being discarded.
+
 ## 2.40.2
 
 - **Fix**: The second place `utp-native` read a callback result that was never written. 2.40.1 got our patched build into the loading path at last, and the process went on dying — twice within an hour, 22:32 and 22:50 — with a stack naming `on_utp_accept` rather than the `on_utp_read` the patch had covered. The code there carried the comment "will never throw due to the event being NTed in js" and then read `next` unconditionally; throwing is not the only way a callback fails, and once the environment is closing or the function reference has gone, `napi_make_callback` returns without writing anything. `next` was then whatever the stack happened to hold, and V8 dereferenced it. Both places are now guarded the same way, and every other call in that file passes NULL for the result and cannot have the fault. `@torrent-tv/utp-native@2.5.3-ttv.2`.

package/package.json

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

package/routes/api/subtitles/get.js

@@ -27,6 +27,7 @@
 import { spawn } from "node:child_process";
 import { convertSubtitleToVtt, decodeSubtitleBytes } from "../../../services/subtitle-convert.js";
 import { detectLanguage } from "../../../services/language-detect.js";
+import { logger } from "../../../utils/logger.js";
 
 // Safety cap: no embedded extraction may outlive this.
 const EXTRACTION_TIMEOUT_MS = 30 * 60 * 1000;
@@ -99,6 +100,53 @@ export async function handleApiSubtitlesGet(req, reply, { sourceRegistry, torren
   inputUrl.searchParams.set("sourceKey", sourceKey);
   inputUrl.searchParams.set("fileIndex", String(fileIndex));
 
+  const key = `${sourceKey}:${fileIndex}:${trackIndex}`;
+  const known = extractions.get(key);
+  if (known?.state === "done") {
+    setLanguageHeaders(reply, known.language);
+    reply.header("content-type", "text/vtt; charset=utf-8");
+    reply.header("cache-control", "no-store");
+    reply.header("access-control-allow-origin", "*");
+    return reply.send(known.body);
+  }
+  if (known?.state === "failed") {
+    return reply.code(422).send({ error: known.error });
+  }
+  if (known?.state !== "running") {
+    startExtraction({ key, ffmpegBin, localBaseUrl, sourceKey, fileIndex, trackIndex });
+  }
+  // Being prepared. The connection is NOT held: extracting an embedded track
+  // makes ffmpeg read the whole file, because subtitles are interleaved through
+  // it, and that means downloading the film for the sake of a few kilobytes of
+  // text. Measured 2026-08-19: track 0 of one release produced 3040 bytes over
+  // **752 seconds**, with the data channel idle the whole time — the browser
+  // gave up at its own sixty-second limit, and every retry started the same
+  // twelve-minute scan again. So the work runs once in the background and the
+  // caller is told to come back.
+  return reply.code(202).send({ pending: true });
+}
+
+/**
+ * Extractions by `sourceKey:fileIndex:trackIndex`, so the scan happens once per
+ * track however many times it is asked for.
+ *
+ * @type {Map<string, { state: "running" | "done" | "failed", body?: Buffer, language?: string, error?: string }>}
+ */
+const extractions = new Map();
+
+/**
+ * Run one extraction to completion in the background, keeping the result.
+ *
+ * @param {{ key: string, ffmpegBin: string, localBaseUrl: string, sourceKey: string, fileIndex: number, trackIndex: number }} params
+ * @returns {void}
+ */
+function startExtraction({ key, ffmpegBin, localBaseUrl, sourceKey, fileIndex, trackIndex }) {
+  const inputUrl = new URL("/stream", `${localBaseUrl}/`);
+  inputUrl.searchParams.set("sourceKey", sourceKey);
+  inputUrl.searchParams.set("fileIndex", String(fileIndex));
+
+  extractions.set(key, { state: "running" });
+  const startedAt = Date.now();
   const ffmpeg = spawn(
     ffmpegBin,
     ["-hide_banner", "-loglevel", "error", "-i", inputUrl.toString(), "-map", `0:s:${trackIndex}`, "-f", "webvtt", "pipe:1"],
@@ -112,56 +160,34 @@ export async function handleApiSubtitlesGet(req, reply, { sourceRegistry, torren
     }
   });
 
+  /** @type {Buffer[]} */
+  const chunks = [];
+  ffmpeg.stdout.on("data", (chunk) => chunks.push(chunk));
+
   const killTimer = setTimeout(() => {
     if (!ffmpeg.killed) {
       ffmpeg.kill("SIGKILL");
     }
   }, EXTRACTION_TIMEOUT_MS);
   killTimer.unref?.();
-  req.raw.on("close", () => {
-    clearTimeout(killTimer);
-    if (!ffmpeg.killed) {
-      ffmpeg.kill("SIGTERM");
-    }
-  });
-
-  const firstChunk = await new Promise((resolve) => {
-    let settled = false;
-    const settle = (value) => {
-      if (!settled) {
-        settled = true;
-        resolve(value);
-      }
-    };
-    ffmpeg.stdout.once("data", (chunk) => settle(chunk));
-    ffmpeg.once("exit", () => settle(null));
-    ffmpeg.once("error", () => settle(null));
-  });
 
-  if (firstChunk === null) {
+  const settle = () => {
     clearTimeout(killTimer);
-    return reply
-      .code(422)
-      .send({ error: `Subtitle track could not be extracted: ${stderr.trim() || "no output from ffmpeg"}` });
-  }
-
-  // Detect language from the first chunk of the produced VTT (embedded tracks
-  // frequently lack a language tag in their container metadata).
-  setLanguageHeaders(reply, detectLanguage(String(firstChunk)));
-  reply.raw.writeHead(200, {
-    "content-type": "text/vtt; charset=utf-8",
-    "cache-control": "no-store",
-    "access-control-allow-origin": "*"
-  });
-  reply.raw.write(firstChunk);
-  ffmpeg.stdout.pipe(reply.raw);
-  await new Promise((resolve) => {
-    ffmpeg.stdout.once("end", resolve);
-    ffmpeg.once("error", resolve);
-  });
-  clearTimeout(killTimer);
-  reply.raw.end();
-  return reply;
+    const seconds = ((Date.now() - startedAt) / 1000).toFixed(1);
+    const body = Buffer.concat(chunks);
+    if (body.length === 0) {
+      extractions.set(key, {
+        state: "failed",
+        error: `Subtitle track could not be extracted: ${stderr.trim() || "no output from ffmpeg"}`
+      });
+      logger.warn(`subtitles ${key}: nothing produced after ${seconds}s`);
+      return;
+    }
+    extractions.set(key, { state: "done", body, language: detectLanguage(String(body.subarray(0, 4096))) });
+    logger.info(`subtitles ${key}: ${body.length} bytes in ${seconds}s`);
+  };
+  ffmpeg.once("close", settle);
+  ffmpeg.once("error", settle);
 }
 
 /**

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

@@ -761,6 +761,10 @@ export async function* readFragments({
    * nothing passed in and no assumption about who is reading.
    */
   let deliveredBytes = 0;
+  // How often this read had to stop, and for how long in total. Reported at the
+  // end whatever the outcome, so a read that never stopped is counted too.
+  let waitCount = 0;
+  let waitedTotalMs = 0;
   const readStartedAt = Date.now();
   const consumeBytesPerSec = () => {
     const seconds = (Date.now() - readStartedAt) / 1000;
@@ -979,6 +983,8 @@ export async function* readFragments({
         const supplyKey = `${torrent?.infoHash ?? "?"}/${file?.name ?? "?"}`;
         noteSteeringOutcome(supplyKey, waitedMs, pushed.asked > 0 || duplicated > 0);
         noteReadMode(supplyKey, waitedMs, readMode);
+        waitCount += 1;
+        waitedTotalMs += waitedMs;
         noteSupplyWait(supplyKey, file?.name ?? "", waitedMs);
       }
       const widened = nextWindowPieces({
@@ -1097,9 +1103,22 @@ export async function* readFragments({
       releaseHeldPin();
       releaseHeldPin = null;
     }
-    // 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.
+    // What this read did, said once at its end and under EVERY outcome — the
+    // arm it ran under, how much it delivered, and how much of that time was
+    // spent waiting. Until now the arm was named only beside a wait, so a read
+    // that never waited left no trace of which way it had claimed its pieces:
+    // measured 2026-08-19 across eight sessions with zero waits, the log could
+    // not say whether `flat` or `bands` had run even once. A comparison that
+    // only records the bad outcomes cannot say that the good ones happened at
+    // all, and "no wait" is exactly the result worth counting.
+    const readSeconds = (Date.now() - readStartedAt) / 1000;
+    if (deliveredBytes > 0) {
+      logger.info(
+        `read "${String(file?.name ?? "?").slice(0, 40)}" mode=${readMode} ` +
+        `delivered=${(deliveredBytes / 1e6).toFixed(1)}MB in ${readSeconds.toFixed(1)}s ` +
+        `waits=${waitCount} waited=${(waitedTotalMs / 1000).toFixed(1)}s`
+      );
+    }
     // Reached on completion, on cancellation, on a throw, and when the consumer
     // stops iterating — a band left behind would keep the swarm fetching for a
     // reader that no longer exists.