@torrent-tv/proxy 2.15.0 → 2.15.1

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.15.1
+
+- **Fix**: A magnet that never found its metadata no longer makes the same film unplayable from its own `.torrent`. One infohash is one torrent, so the second add is refused and the pool takes the one already there — which is right when it is ready and wrong when it is not: a magnet whose swarm has not answered has no file list, and everything bound to it is answered 404. Measured 2026-08-15 on the addon host: a magnet with no reachable trackers was added first, the film's own `.torrent` then joined that empty torrent instead of replacing it, `/stream` answered 404, the encoder died on its first read, and the film stayed unplayable until the proxy was restarted. A `.torrent` carries the file list, the piece hashes and the trackers outright, so when it meets a torrent with no metadata it now replaces it; two magnets still wait, because neither has anything the other lacks.
+
 ## 2.15.0
 
 - **New**: An audio track is prepared before the player is told to change to it — `GET /transcode/:id/a/:track/warm?position=<seconds>`, the same shape the quality rung has had since 2.12.0. Changing track makes the player discard the audio it holds, and it cannot show a frame until the new track covers the playhead: switching first and producing second therefore put the track's whole cold start on screen as a spinner over a stopped picture. Prepared first, the player finds the bytes already made. A track prepared for a change the viewer then did not make is stopped, as a warmed rung is.

package/package.json

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

package/services/torrent-pool.js

@@ -315,6 +315,30 @@ function computeDefaultDiskCap(storePath) {
  * @param {string} source                   - Magnet URI or base64-encoded .torrent file.
  * @returns {string | Buffer}
  */
+/**
+ * What to do when WebTorrent refuses an add because that infohash is already
+ * here: take the one that exists, replace it, or wait for it to be ready.
+ *
+ * The same content arrives as a `.torrent` and as a magnet — different pool
+ * keys, one swarm — so a duplicate is ordinary. What is NOT ordinary is a
+ * duplicate with no metadata: a magnet whose swarm has not answered has no file
+ * list, and every request bound to it is answered 404 for as long as it lives.
+ * If this add carries metadata — a `.torrent` holds the files, the piece hashes
+ * and the trackers outright — waiting for the swarm to supply what is already
+ * in our hands is waiting for nothing. Measured 2026-08-15: one magnet with no
+ * reachable peers made the same film unplayable from its own `.torrent` until
+ * the proxy was restarted.
+ *
+ * @param {{ existingIsReady: boolean, incomingHasMetadata: boolean }} params
+ * @returns {"adopt" | "replace" | "wait"}
+ */
+export function duplicateAddDecision({ existingIsReady, incomingHasMetadata }) {
+  if (existingIsReady) {
+    return "adopt";
+  }
+  return incomingHasMetadata ? "replace" : "wait";
+}
+
 function decodeTorrentSource(sourceType, source) {
   if (sourceType === "magnet") {
     return source;
@@ -972,11 +996,58 @@ export class TorrentPool {
               this.#pending.delete(key);
               resolve(existing);
             };
-            if (existing.ready) {
+            const decision = duplicateAddDecision({
+              existingIsReady: existing.ready === true,
+              incomingHasMetadata: Buffer.isBuffer(torrentId)
+            });
+            if (decision === "adopt") {
               settle();
-            } else {
-              existing.once("ready", settle);
+              return;
+            }
+            // The one already here has no metadata, and THIS add carries it —
+            // a `.torrent` holds the file list, the piece hashes and the
+            // trackers outright. Waiting for the other one to become ready is
+            // waiting on the swarm to supply what is already in our hands, and
+            // when the swarm cannot (a magnet with no reachable peers) it never
+            // arrives: measured 2026-08-15, a magnet added first left every
+            // later attempt at the same infohash — including the complete
+            // `.torrent` — bound to an empty torrent, `/stream` answering 404
+            // and playback impossible until the proxy was restarted.
+            if (decision === "replace") {
+              logger.info(
+                `torrent-pool: [${dupMatch[1].slice(0, 8)}] replacing a torrent with no metadata ` +
+                `with the .torrent just given, which has it`
+              );
+              // Everything this class remembers about the old one goes with it,
+              // or a later request finds it through a map and works with a
+              // torrent the client no longer has.
+              for (const [otherKey, value] of this.torrents) {
+                if (value === existing) {
+                  this.torrents.delete(otherKey);
+                }
+              }
+              this.fileUsageByTorrent.delete(existing);
+              this.#lastAccess.delete(existing);
+              this.#readPositionByTorrent.delete(existing);
+              this.client.remove(existing, { destroyStore: true }, () => {
+                this.client.add(torrentId, {
+                  store: SharedPieceStore,
+                  storeCacheSlots: 0,
+                  storeOpts: { memoryBytes: this.#memoryBytes }
+                }, (replacement) => {
+                  this.torrents.set(key, replacement);
+                  this.#lastAccess.set(replacement, Date.now());
+                  this.#attachSwarmDiagnostics(dupMatch[1].slice(0, 8), replacement);
+                  this.#pending.delete(key);
+                  resolve(replacement);
+                });
+              });
+              return;
             }
+            // Both are magnets: there is nothing here the other does not have,
+            // so wait for the swarm — the caller's own bound answers if it
+            // takes too long.
+            existing.once("ready", settle);
             return;
           }
         }

package/test/duplicate-add.test.js

@@ -0,0 +1,48 @@
+/**
+ * @file One infohash, two sources: what happens when the second add is refused.
+ *
+ * The same film arrives as a magnet and as a `.torrent`. WebTorrent refuses the
+ * second add — one infohash, one torrent — and the pool then has to decide what
+ * to hand back. Adopting the one already there is right when it is ready, and
+ * wrong when it is not: a magnet whose swarm has not answered has no file list,
+ * so everything bound to it is answered 404.
+ *
+ * Measured 2026-08-15 on the addon host: a magnet with no reachable trackers
+ * was added first and never became ready; the same film's own `.torrent`, which
+ * carries the file list, the piece hashes and the trackers, then joined that
+ * empty torrent instead of replacing it. `/stream` answered 404, the encoder
+ * died on its first read, and the film stayed unplayable until the proxy was
+ * restarted — one bad magnet poisoning every later attempt at that infohash.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { duplicateAddDecision } from "../services/torrent-pool.js";
+
+test("a ready torrent is adopted, whatever the new source carries", () => {
+  assert.equal(
+    duplicateAddDecision({ existingIsReady: true, incomingHasMetadata: true }),
+    "adopt",
+    "one swarm per infohash: a second copy would download the same pieces twice"
+  );
+  assert.equal(
+    duplicateAddDecision({ existingIsReady: true, incomingHasMetadata: false }),
+    "adopt"
+  );
+});
+
+test("an unready torrent is replaced when this add brings the metadata", () => {
+  assert.equal(
+    duplicateAddDecision({ existingIsReady: false, incomingHasMetadata: true }),
+    "replace",
+    "the .torrent holds what the swarm was being asked for; waiting for it is waiting for nothing"
+  );
+});
+
+test("two magnets wait, because neither has anything the other lacks", () => {
+  assert.equal(
+    duplicateAddDecision({ existingIsReady: false, incomingHasMetadata: false }),
+    "wait",
+    "replacing here would only restart the same search, and the caller's own bound answers"
+  );
+});