@torrent-tv/proxy 2.15.0 → 2.15.2

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 2.15.2
+
+- **Fix**: A segment request that can never be answered is answered as absent instead of being held for a minute. Changing audio track makes hls.js ask the new stream for segment #0 before anything else; the run was at #354, the repair reaches sixty segments back and no further, no seek was coming, and an encoder only moves forward — so the request was unanswerable from the moment it arrived, and holding it simply spent the player's own patience. Measured 2026-08-15: the track was made ready in 7.1 s at the viewer's position, and the viewer then watched a spinner for **63 s** — sixty of them the hold, the rest the player recovering after it failed. Deliberately narrower than the refusal 2.14.1 shipped and 2.14.2 withdrew: a request within the repair's reach, or one with a seek on its way, is still held, because for those the encoder is about to be moved there.
+
+## 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.2",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

package/services/hls-session-manager.js

@@ -6067,6 +6067,35 @@ export class HlsSessionManager {
     // at this position (server-side seeking).  The caller long-polls.
     if (!isPlaylist) {
       const requestedIndex = session.segmentFormat.segmentIndexFromName(fileName);
+      // Unanswerable, and known to be: behind a run that only moves forward,
+      // too far behind for the repair to fetch it, and no seek on its way to
+      // move the encoder there. Holding it changes nothing about whether it can
+      // be produced — it only spends the player's patience.
+      //
+      // This is what a track change costs when it is held instead: measured
+      // 2026-08-15, hls.js asked the new track for segment #0 while the run was
+      // at #354, the request was held for the full minute, and only when it
+      // failed did the player move to the segment it actually needed — 63 s of
+      // spinner after a track that had been made ready in 7.
+      //
+      // Narrow on purpose. A request behind the head is USUALLY temporary: the
+      // repair moves the encoder back for anything within its reach, and a
+      // reported seek is about to move it anyway. Refusing those was 2.14.1,
+      // and it left a viewer retrying a 404 for ever.
+      if (
+        Number.isFinite(requestedIndex) &&
+        requestedIndex < (session.encodeStartIndex ?? 0) &&
+        (session.encodeStartIndex ?? 0) - requestedIndex > BEHIND_HEAD_REPAIR_MAX_SEGMENTS &&
+        session.ffmpeg != null &&
+        session.seekTarget == null &&
+        session.seekSettleTimer == null
+      ) {
+        logger.info(
+          `transcode ${session.id} segment #${requestedIndex} is ${(session.encodeStartIndex ?? 0) - requestedIndex} ` +
+          `segments behind the run and beyond the repair's reach; answered as absent rather than held`
+        );
+        return { kind: "not-found" };
+      }
       this.#ensureEncodingFor(
         session,
         requestedIndex,

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/behind-head-repair.test.js

@@ -108,12 +108,11 @@ test("a burst of different segments behind the run is a scan, and moves nothing"
   for (const index of scanned) {
     session.firstWantedAt.set(index, Date.now() - 1000);
   }
-  // Interleaved, as they arrive on the wire: the player opens them together
-  // rather than finishing with one before opening the next.
-  for (const seq of [1, 2]) {
-    for (const index of scanned) {
-      await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(index), { requestSeq: seq });
-    }
+  // Asked ONCE each, which is what a scan is: the player opens them together
+  // and abandons them together. Field log 2026-08-02 — #178, #681, #725, #807,
+  // #74, #245, #387 within half a second, none of them repeated.
+  for (const index of scanned) {
+    await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(index), { requestSeq: 1 });
   }
 
   assert.equal(
@@ -219,3 +218,34 @@ test("a request ahead of the run is not touched", async (t) => {
     "the running encode may yet reach it; restarting on a far request is what produced nine restarts in a minute"
   );
 });
+
+test("a request far beyond the repair's reach is answered at once, not held", async (t) => {
+  const { manager, session, dirPath } = await managerWithRunAhead();
+  t.after(async () => {
+    await manager.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  // What a track change does: hls.js asks the new stream for segment #0 while
+  // the run is hundreds of segments in. The repair cannot reach it, no seek is
+  // coming, and the run only moves forward — so it can never be produced.
+  // Measured 2026-08-15: held for the full minute, and the viewer watched a
+  // spinner for 63 s after a track that had been made ready in 7.
+  const answer = await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(0), { requestSeq: 1 });
+
+  assert.equal(answer.kind, "not-found", "answered, so the player can move on to what it can have");
+  assert.equal(session.seekTarget, null, "and the encoder was not sent to the start of the film for it");
+});
+
+test("a request just behind the run is still held, because the repair will fetch it", async (t) => {
+  const { manager, session, dirPath } = await managerWithRunAhead();
+  t.after(async () => {
+    await manager.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  const name = fmp4Format.segmentFileName(WANTED);
+  session.firstWantedAt.set(WANTED, Date.now() - 1000);
+
+  const answer = await manager.getFileStream(SESSION_ID, name, { requestSeq: 1 });
+
+  assert.equal(answer.kind, "warming-up", "within reach: the encoder is about to be moved there");
+});

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