@torrent-tv/proxy 2.89.14 → 2.89.15

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 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.

package/package.json

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

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/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]);
+});