@torrent-tv/proxy 2.83.1 → 2.83.2

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2.83.2
+
+- **Fix**: 2.83.1 COULD NOT START PLAYBACK AT ALL, and the cause was its own new rule. A torrent nobody has stated anything about leaves its swarm — and a torrent that has just been added has stated nothing yet, because the read of the file's edges is still in flight and the playback plan is still being built. Field 2026-09-11: added at 20:57:17, first peer at 20:57:18, out of the swarm at 20:57:21 with 741 connections let go. Nothing ever rejoined it: rejoining waits for a reader, and the reader was waiting for the header the swarm had been fetching. `[stats]` then read `peers=0 connected of 0 known (94 queued, 5 tracker(s) offered up to 683 seeders)` for as long as the viewer was willing to wait.
+- **Fix**: The condition is a state rather than a period: a torrent is left only once it has been read at least once. That is what separates a film somebody left from a film being opened right now, and a torrent nobody ever reads still goes by the pool's own idle removal, which is where that belongs.
+- **Chore**: Two checks that asserted the old behaviour now read a torrent through its real sequence — read once, then left — and two more cover the state this release is about.
+
 ## 2.83.1
 
 - **Fix**: THE PIECE STORE COULD END A TORRENT, AND ON 2026-09-11 IT DID. Switching to the second episode of a five-file torrent reached a store that had shrunk to three blocks of 4 MB while the machine offered 4.3 GB; a claim for a block failed after five seconds, the failure travelled out through the torrent client's own write callback, and the client destroyed the torrent. For the rest of the process every read answered `File 1 not found in torrent:d4022ff4...`, `/stats` said `peers=0 connected of 1186 known`, the header of the new episode never downloaded, and the viewer waited on a plan that could not be built until the addon was restarted. Memory is no longer a reason to refuse anything: an arriving piece that cannot have a block is written straight to disk, which is where it was going anyway.

package/package.json

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

package/services/torrent-pool.js

@@ -971,7 +971,28 @@ export class TorrentPool {
     }
     const usage = this.fileUsageByTorrent.get(torrent);
     const isRead = Boolean(usage && usage.size > 0);
+    if (isRead) {
+      // Recorded on the torrent, as `hasActiveReader` and `hasUnmetDemand`
+      // beside it are: it is a fact about this torrent and it lives as long as
+      // the torrent does.
+      torrent.hasBeenRead = true;
+    }
     const isWanted = isRead || demandFor(torrent).register.windows().length > 0;
+    // A TORRENT NOBODY HAS READ YET IS BEING SET UP, NOT ABANDONED. Field
+    // 2026-09-11, and it broke playback outright: a torrent was added at
+    // 20:57:17, its first peer connected at 20:57:18, and this pass took it out
+    // of the swarm at 20:57:21 — while the read of the file's edges was still
+    // in flight and the playback plan was being built. Nothing rejoined it,
+    // because rejoining waits for a reader and a reader cannot arrive: the
+    // header it needs is downloaded by the swarm that was just let go.
+    //
+    // The condition is a state and not a period: having been read at least once
+    // is what tells a film somebody left from a film nobody has opened yet. One
+    // that is never read at all goes by the pool's own idle removal, which is
+    // where that belongs.
+    if (!isWanted && torrent.hasBeenRead !== true) {
+      return;
+    }
     if (isWanted && torrent.paused === true) {
       torrent.resume();
       logger.info(

package/test/swarm-follows-readers.test.js

@@ -67,6 +67,11 @@ test("a torrent nobody is reading is let go of, and its data is not", () => {
   const torrent = torrentWith(6);
   const pool = poolWith(torrent);
   try {
+    // Read once and left, which is the state this is about: a film nobody has
+    // opened yet is being set up, and the test below covers that.
+    pool.fileUsageByTorrent.set(torrent, new Map([[0, 1]]));
+    pool.followTheReaders(torrent);
+    pool.fileUsageByTorrent.set(torrent, new Map());
     pool.followTheReaders(torrent);
 
     assert.equal(torrent.paused, true, "the swarm was not left");
@@ -114,6 +119,9 @@ test("the swarm is rejoined when a reader comes back", () => {
   const torrent = torrentWith(3);
   const pool = poolWith(torrent);
   try {
+    pool.fileUsageByTorrent.set(torrent, new Map([[0, 1]]));
+    pool.followTheReaders(torrent);
+    pool.fileUsageByTorrent.set(torrent, new Map());
     pool.followTheReaders(torrent);
     assert.equal(torrent.paused, true);
 
@@ -124,3 +132,37 @@ test("the swarm is rejoined when a reader comes back", () => {
     forgetTorrent(torrent);
   }
 });
+
+test("a torrent nobody has read yet is being set up, and is left alone", () => {
+  // Field 2026-09-11, and it broke playback outright: a torrent added at
+  // 20:57:17 had its first peer at 20:57:18 and was taken out of the swarm at
+  // 20:57:21 — while the read of the file's edges was still in flight. Nothing
+  // rejoined it, because rejoining waits for a reader and the reader was
+  // waiting for the header the swarm was fetching.
+  const torrent = torrentWith(103);
+  const pool = poolWith(torrent);
+  try {
+    pool.followTheReaders(torrent);
+    assert.equal(torrent.paused, false, "a torrent being opened was taken out of its swarm");
+    assert.equal(torrent._peers.size, 103, "and its connections were let go");
+  } finally {
+    forgetTorrent(torrent);
+  }
+});
+
+test("once it has been read, leaving is allowed again", () => {
+  const torrent = torrentWith(4);
+  const pool = poolWith(torrent);
+  try {
+    // A reader arrives and goes.
+    pool.fileUsageByTorrent.set(torrent, new Map([[0, 1]]));
+    pool.followTheReaders(torrent);
+    assert.equal(torrent.paused, false);
+
+    pool.fileUsageByTorrent.set(torrent, new Map());
+    pool.followTheReaders(torrent);
+    assert.equal(torrent.paused, true, "a film somebody left keeps its swarm for nobody");
+  } finally {
+    forgetTorrent(torrent);
+  }
+});