@torrent-tv/proxy 2.89.13 → 2.89.15

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 2.89.15
+
+- **Fix**: A torrent downloaded whole is no longer removed while something is still reading it. The sweep that writes whole files out and removes the torrent asked only who had stated a need, and a read whose pieces are all here waits for nothing and states nothing. On the stand on 2026-10-04 the torrent was removed under ffmpeg's own read of the film: the read ended with "Piece store is closed" 277 MB in, ffmpeg reported `Stream ends prematurely`, the copied picture lost 2.6 s, and the page refused to start with "Prepared media contains a timestamp gap" (torrent-tv/meta#105). Open reads now count as use.
+
+## 2.89.14
+
+- **Fix**: A failed run counts only the source's own streams. The planner probes with an output, so ffmpeg's banner goes on to list the streams it maps and writes, and those were counted too: a file with one picture, one soundtrack, one subtitle and one font read as `2 video, 2 audio, 1 subtitle, 3 other` in the field — enough to make a second soundtrack look present when it is not.
+
 ## 2.89.13
 
 - **Fix**: The proxy no longer stops answering everybody when one output is priced near zero. Asking how many encoders an output may run counted them one at a time until the machine was full, so the number of steps grew as the price shrank. On the stand on 2026-10-04 a soundtrack priced at 5.4e-14 s of machine per second of film held the main thread in that count for minutes, past 3.3 billion steps: no data channel was served, `/healthz` did not answer, and every viewer stopped. The count is now found by doubling and halving, in at most a few hundred steps whatever the price. The price itself is wrong and is not corrected here.

package/package.json

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

package/services/media/ffmpeg-banner.js

@@ -141,7 +141,13 @@ export function parseFfmpegStreamCounts(stderrText) {
   if (typeof stderrText !== "string" || stderrText.length === 0) {
     return null;
   }
-  const lines = stderrText.match(/^\s*Stream #\d+:\d+.*$/gim);
+  // The source's streams only. A probe that writes somewhere — the planner's
+  // `-f null -` does — goes on to print `Stream mapping:` and `Output #0` with
+  // stream lines of their own, and counting those doubled the picture and the
+  // sound (field 2026-10-04: one soundtrack read as two).
+  const end = stderrText.search(/^(?:Stream mapping:|Output #\d+)/m);
+  const inputText = end >= 0 ? stderrText.slice(0, end) : stderrText;
+  const lines = inputText.match(/^\s*Stream #\d+:\d+.*$/gim);
   if (!lines || lines.length === 0) {
     return null;
   }

package/services/torrent/worker/files-in-use.js

@@ -0,0 +1,35 @@
+/**
+ * @file Which files of a torrent somebody is using, for the sweep that writes
+ * whole files out and removes a torrent that has nothing left to fetch.
+ *
+ * Two facts, and both are needed. A file somebody has stated a need for is in
+ * use. So is a file being read: a read whose pieces are all here waits for
+ * nothing, and so states nothing in the demand register. Field 2026-10-04: a
+ * torrent was removed under such a read, ffmpeg's input ended with "Piece store
+ * is closed" 277 MB in, and the copied picture lost 2.6 s that the readiness
+ * forecast then refused as a timestamp gap (torrent-tv/meta#105).
+ */
+
+/** Claimants that keep pieces coming without anybody reading. */
+const NOT_A_READER = ["file-edges:", "torrent-fill:", "background-fill:"];
+
+/**
+ * @param {object} options
+ * @param {object} options.torrent
+ * @param {Array<{ claimant: unknown, fileIndex: number }>} options.windows - The demand register's windows.
+ * @param {Iterable<{ torrent: object, fileIndex: number }>} options.openReads - Reads in flight.
+ * @returns {Set<number>} File indices in use.
+ */
+export function filesInUse({ torrent, windows, openReads }) {
+  const used = new Set(
+    windows
+      .filter((window) => !NOT_A_READER.some((prefix) => String(window.claimant).startsWith(prefix)))
+      .map((window) => window.fileIndex)
+  );
+  for (const read of openReads) {
+    if (read.torrent === torrent) {
+      used.add(read.fileIndex);
+    }
+  }
+  return used;
+}

package/services/torrent/worker/worker.js

@@ -34,6 +34,7 @@ import { heldRangesOf, ownsItsMemory, readHeldBytes } from "./held-bytes.js";
 import { CompletedFiles, completedFilesRoot } from "../../storage/files/CompletedFiles.js";
 import { pieceFromWholeFiles, pieceIsInWholeFiles } from "../../storage/files/piece-from-whole-file.js";
 import { Command, Event } from "./protocol.js";
+import { filesInUse } from "./files-in-use.js";
 import { startMemoryReport, WORKER_MEMORY_SAMPLE_MS } from "../../storage/memory-report.js";
 import { forwardLogsTo, logger } from "../../../utils/logger.js";
 
@@ -94,6 +95,14 @@ const torrentsByKey = new Map();
 const sourceRecipes = new Map();
 /** In-flight reads, so a cancel can stop one mid-body. */
 const readsById = new Map();
+/**
+ * What each in-flight read is reading. A read whose pieces are all here waits
+ * for nothing and so states nothing in the demand register; this is how the
+ * thread knows it is still open.
+ *
+ * @type {Map<number, { torrent: object, fileIndex: number }>}
+ */
+const openReads = new Map();
 
 /**
  * Shorthand for this file. The same path as `logger.info` anywhere else in the
@@ -257,6 +266,7 @@ async function streamRange({ id, sourceKey, fileIndex, start, end, windowBytes }
 
   const sender = createSendStream({ port: parentPort, requestId: id });
   readsById.set(id, sender);
+  openReads.set(id, { torrent, fileIndex });
 
   const rangeStart = start ?? 0;
   const rangeEnd = end ?? file.length - 1;
@@ -295,6 +305,7 @@ async function streamRange({ id, sourceKey, fileIndex, start, end, windowBytes }
     throw error;
   } finally {
     readsById.delete(id);
+    openReads.delete(id);
     // Any fragment still awaiting confirmation will never get one now; settling
     // it here releases its pin rather than leaking a held slot.
     settleFragment(id);
@@ -947,18 +958,12 @@ async function keepWholeFiles() {
     if (!infoHash || !Array.isArray(torrent.files)) {
       continue;
     }
-    // What anybody wants of this torrent. A file something is stated for is a
-    // file somebody may be reading, and this is the same list the reader counts
-    // used to give.
-    const wanted = new Set(
-      demandFor(torrent).register.windows()
-        .filter((window) =>
-          !String(window.claimant).startsWith("file-edges:") &&
-          !String(window.claimant).startsWith("torrent-fill:") &&
-          !String(window.claimant).startsWith("background-fill:")
-        )
-        .map((window) => window.fileIndex)
-    );
+    // What anybody wants of this torrent or is reading from it now.
+    const wanted = filesInUse({
+      torrent,
+      windows: demandFor(torrent).register.windows(),
+      openReads: openReads.values()
+    });
     for (const [fileIndex, file] of torrent.files.entries()) {
       const key = `${infoHash}/${fileIndex}`;
       if (file?.done !== true || completedFiles.find(infoHash, fileIndex) || beingKept.has(key)) {

package/test/ffmpeg-stream-counts.test.js

@@ -76,3 +76,26 @@ test("a stream carrying metadata in brackets is still read", () => {
   `);
   assert.deepEqual(counts, { video: 1, audio: 1, subtitle: 0, other: 0 });
 });
+
+test("only the input's streams are counted, not the output ffmpeg describes after them", () => {
+  // The planner probes with `-i <file> -t 0.1 -f null -`, so the banner goes on
+  // to describe what it maps and the null output it writes. Counted whole, this
+  // field file (one picture, one soundtrack, one subtitle, one font) read as
+  // "2 video, 2 audio, 1 subtitle, 3 other" on 2026-10-04 — which would make a
+  // second soundtrack look present when it is not.
+  const banner = `
+Input #0, matroska,webm, from 'http://127.0.0.1:9090/stream?sourceKey=torrent%3A84acab5f&fileIndex=35':
+  Duration: 00:23:41.44, start: 0.000000, bitrate: 3195 kb/s
+  Stream #0:0: Video: h264 (High), yuv420p(progressive), 1920x1080 [SAR 1:1 DAR 16:9], 23.81 fps, 23.81 tbr, 1k tbn (default)
+  Stream #0:1(jpn): Audio: aac (LC), 44100 Hz, stereo, fltp (default)
+  Stream #0:2(eng): Subtitle: ass (ssa) (default)
+  Stream #0:3: Attachment: ttf
+Stream mapping:
+  Stream #0:0 -> #0:0 (h264 (native) -> wrapped_avframe (native))
+  Stream #0:1 -> #0:1 (aac (native) -> pcm_s16le (native))
+Output #0, null, to 'pipe:':
+  Stream #0:0: Video: wrapped_avframe, yuv420p(progressive), 1920x1080 [SAR 1:1 DAR 16:9], q=2-31, 200 kb/s, 23.81 fps, 23.81 tbn (default)
+  Stream #0:1(jpn): Audio: pcm_s16le, 44100 Hz, stereo, s16, 1411 kb/s (default)
+`;
+  assert.deepEqual(parseFfmpegStreamCounts(banner), { video: 1, audio: 1, subtitle: 1, other: 1 });
+});

package/test/files-in-use.test.js

@@ -0,0 +1,34 @@
+/**
+ * @file Which files of a torrent are in use for the whole-file sweep. Pure:
+ * no torrent is started (see services/torrent/worker/files-in-use.js).
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { filesInUse } from "../services/torrent/worker/files-in-use.js";
+
+test("a file being read is in use though nobody states a need for it", () => {
+  // Field 2026-10-04: every piece was here, so the read waited for nothing and
+  // stated nothing, and the torrent was removed under it.
+  const torrent = {};
+  const used = filesInUse({ torrent, windows: [], openReads: [{ torrent, fileIndex: 0 }] });
+  assert.deepEqual([...used], [0]);
+});
+
+test("a read of another torrent does not count", () => {
+  const used = filesInUse({ torrent: {}, windows: [], openReads: [{ torrent: {}, fileIndex: 0 }] });
+  assert.equal(used.size, 0);
+});
+
+test("stated needs count, and the fills that read nothing do not", () => {
+  const used = filesInUse({
+    torrent: {},
+    windows: [
+      { claimant: "reader:7", fileIndex: 2 },
+      { claimant: "file-edges:1", fileIndex: 1 },
+      { claimant: "torrent-fill:x", fileIndex: 3 },
+      { claimant: "background-fill:x", fileIndex: 4 }
+    ],
+    openReads: []
+  });
+  assert.deepEqual([...used], [2]);
+});