@torrent-tv/proxy 2.83.2 → 2.83.4

package/test/priority-map-emptied.test.js

@@ -0,0 +1,207 @@
+/**
+ * @file WHEN NOBODY WANTS A FILE ANY MORE, THE MAP SAYS SO.
+ *
+ * The map is the only statement of what is wanted, and until 2.83.4 it could
+ * make only one of the two statements it exists for. A file whose viewers had
+ * gone was deleted from the orchestrator's own memory and published nowhere, so
+ * the bands it had stated on the swarm's behalf stood until the torrent itself
+ * was removed — read from the demand register, a film nobody had watched for an
+ * hour was indistinguishable from one being watched now.
+ *
+ * Two halves, and both are here: the side that builds the map has to say it,
+ * and the side that receives it has to act on it without needing the file's
+ * length, the torrent's list, or the torrent to exist at all.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { PriorityOrchestrator } from "../services/priority/PriorityOrchestrator.js";
+import { Viewers } from "../services/viewer/Viewers.js";
+import { viewersOf } from "../services/viewer/Viewer.js";
+import { TorrentPool } from "../services/torrent-pool.js";
+import { demandFor, forgetTorrent } from "../services/download/registry.js";
+import { Urgency } from "../services/demand/index.js";
+
+const STALE_AFTER_MS = 60_000;
+
+/**
+ * A session, as much of one as the orchestrator reads.
+ *
+ * @param {{ id: string, fileIndex?: number }} params
+ * @returns {object}
+ */
+function outputOf({ id, fileIndex = 0 }) {
+  return {
+    id,
+    outputKey: `out:${id}`,
+    sourceKey: "source-1",
+    fileIndex,
+    file: { key: `film-${fileIndex}`, durationSeconds: 600 }
+  };
+}
+
+/**
+ * The real orchestrator, with everything it publishes kept.
+ *
+ * @param {object[]} sessions
+ * @returns {{ priority: PriorityOrchestrator, viewers: Viewers, published: object[], publish: (sessions?: object[]) => void }}
+ */
+function over(sessions) {
+  const published = [];
+  const viewers = new Viewers();
+  const priority = new PriorityOrchestrator({
+    publish: (one) => published.push(one),
+    viewersOf: (session) => viewersOf(session),
+    allowanceFor: () => 10
+  });
+  return {
+    priority,
+    viewers,
+    published,
+    publish: (live = sessions) =>
+      priority.publishFor({ sessionGroups: [live], staleAfterMs: STALE_AFTER_MS })
+  };
+}
+
+test("a file whose viewers have all gone is published as wanting nothing", () => {
+  const picture = outputOf({ id: "pic" });
+  const { viewers, published, publish } = over([picture]);
+  const person = viewers.of(picture, "p");
+  person.moveTo(300);
+  publish();
+  assert.ok(published.at(-1).zones.length > 0, "somebody is watching, so something is wanted");
+
+  // They stop answering. The session is still there — it outlives them by half
+  // an hour — so this is the case that used to say nothing at all.
+  person.seen(Date.now() - STALE_AFTER_MS * 2);
+  publish();
+
+  const last = published.at(-1);
+  assert.deepEqual(last.zones, []);
+  assert.equal(last.sourceKey, "source-1");
+  assert.equal(last.fileIndex, 0);
+});
+
+test("a file whose session has gone is published as wanting nothing, once", () => {
+  const picture = outputOf({ id: "pic" });
+  const { viewers, published, publish } = over([picture]);
+  viewers.of(picture, "p").moveTo(300);
+  publish();
+  const said = published.length;
+
+  // The session is disposed: it is not among the live ones any more.
+  publish([]);
+  assert.deepEqual(published.at(-1).zones, []);
+  assert.equal(published.length, said + 1);
+
+  // And it is not repeated on every pass afterwards — the file is gone from
+  // this class's memory, and a departure is said once.
+  publish([]);
+  publish([]);
+  assert.equal(published.length, said + 1);
+});
+
+test("an unchanged map is still not republished", () => {
+  const picture = outputOf({ id: "pic" });
+  const { viewers, published, publish } = over([picture]);
+  viewers.of(picture, "p").moveTo(300);
+  publish();
+  const said = published.length;
+  publish();
+  publish();
+  assert.equal(published.length, said, "the downloading rebuilds its requests on every one");
+});
+
+/** A torrent that is nothing but one file of a known length. */
+function torrentOf({ length = 1_000_000 } = {}) {
+  return {
+    infoHash: `hash-${Math.random().toString(36).slice(2)}`,
+    pieceLength: 1024,
+    files: [{ offset: 0, length, name: "film.mkv" }],
+    _selections: { _items: [] },
+    _select() {},
+    _deselect() {},
+    critical() {}
+  };
+}
+
+const applyPriorityMap = TorrentPool.prototype.applyPriorityMap;
+
+/**
+ * @param {object} torrent
+ * @returns {object[]}
+ */
+function stated(torrent) {
+  return demandFor(torrent)
+    .register.windows()
+    .filter((one) => String(one.claimant).startsWith("priority-map:"));
+}
+
+test("a map with nothing in it withdraws everything that file had stated", () => {
+  const torrent = torrentOf();
+  try {
+    applyPriorityMap.call(null, torrent, 0, [
+      { from: 0, to: 100, priority: 100 },
+      { from: 100, to: 600, priority: 50 }
+    ], 600);
+    assert.equal(stated(torrent).length, 2);
+
+    applyPriorityMap.call(null, torrent, 0, [], 600);
+    assert.equal(stated(torrent).length, 0);
+  } finally {
+    forgetTorrent(torrent);
+  }
+});
+
+test("it withdraws that file's bands and nobody else's", () => {
+  const torrent = torrentOf();
+  try {
+    const { register } = demandFor(torrent);
+    applyPriorityMap.call(null, torrent, 0, [{ from: 0, to: 600, priority: 100 }], 600);
+    // A read stopped on a piece right now, which only a read can say, and the
+    // background fill, which the pool states for itself. Neither is the map's
+    // to withdraw.
+    register.state({
+      claimant: "read-7:blocked",
+      fileIndex: 0,
+      byteStart: 0,
+      byteEnd: 999,
+      urgency: Urgency.BLOCKED
+    });
+    register.state({
+      claimant: "background-fill:0",
+      fileIndex: 0,
+      byteStart: 1000,
+      byteEnd: 9999,
+      urgency: Urgency.TAIL
+    });
+
+    applyPriorityMap.call(null, torrent, 0, [], 600);
+
+    assert.equal(stated(torrent).length, 0);
+    assert.deepEqual(
+      register.windows().map((one) => one.claimant).sort(),
+      ["background-fill:0", "read-7:blocked"]
+    );
+  } finally {
+    forgetTorrent(torrent);
+  }
+});
+
+test("a departure is answered even when nothing else about the file is known", () => {
+  // The length, the duration and the torrent's own list are what the ordinary
+  // path needs to turn seconds into bytes. A departure needs none of them, and
+  // it arrives exactly when they are going away: the map that says it is
+  // published as the last viewer leaves.
+  const torrent = torrentOf();
+  try {
+    applyPriorityMap.call(null, torrent, 0, [{ from: 0, to: 600, priority: 100 }], 600);
+    assert.equal(stated(torrent).length, 1);
+
+    torrent.files = [];
+    applyPriorityMap.call(null, torrent, 0, [], 0);
+    assert.equal(stated(torrent).length, 0);
+  } finally {
+    forgetTorrent(torrent);
+  }
+});

package/test/source-files-route.test.js

@@ -0,0 +1,103 @@
+/**
+ * @file WHAT THE BROWSER IS TOLD IS IN A TORRENT.
+ *
+ * This is the one place the product answers it. The browser used to answer it
+ * as well — a list of video extensions in its parser and a second, shorter pair
+ * inside its picker — and the three had already diverged: measured 2026-09-12,
+ * `.dat` was offered there as video and not counted here, which also decides
+ * whether a sidecar whose name matches nothing can belong to the only video
+ * present.
+ *
+ * So the shape of this answer is a contract with the page, and the page shows
+ * what it is given without looking at a name.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { handleApiSourceFilesGet } from "../routes/api/sources/files/get.js";
+
+/**
+ * A request, a reply and the torrent behind them.
+ *
+ * @param {Array<{ path: string, length: number }>} files
+ * @returns {{ req: object, reply: object, sent: { body: object | null, code: number }, deps: object }}
+ */
+function harness(files) {
+  const sent = { body: null, code: 200 };
+  const reply = {
+    code(value) {
+      sent.code = value;
+      return reply;
+    },
+    send(body) {
+      sent.body = body;
+      return reply;
+    }
+  };
+  const deps = {
+    sourceRegistry: { get: () => ({ sourceType: "magnet", source: "magnet:?xt=urn:btih:abc" }) },
+    torrentPool: {
+      async getTorrent() {
+        return { name: "Drifters", infoHash: "abc", files };
+      }
+    }
+  };
+  return { req: { params: { sourceKey: "key" }, query: {} }, reply, sent, deps };
+}
+
+test("the files come back in reading order, each saying what it is", () => {
+  const { req, reply, sent, deps } = harness([
+    { path: "Drifters/ep 10.mkv", length: 9 },
+    { path: "Drifters/ep 2.mkv", length: 9 },
+    { path: "Drifters/Rus Sound/ep 2.mka", length: 2 },
+    { path: "Drifters/notes.nfo", length: 1 }
+  ]);
+
+  return handleApiSourceFilesGet(req, reply, deps).then(() => {
+    assert.equal(sent.code, 200);
+    assert.deepEqual(
+      sent.body.files.map((file) => [file.relativePath, file.kind]),
+      [
+        // Runs of digits compare as numbers, so 2 comes before 10; the torrent's
+        // own order is whatever the tool that made it chose.
+        ["ep 2.mkv", "video"],
+        ["ep 10.mkv", "video"],
+        ["notes.nfo", "other"],
+        ["Rus Sound/ep 2.mka", "audio"]
+      ]
+    );
+    // Relative to the torrent root: WebTorrent prefixes its own name to every
+    // path, and stripping it here means one rule in the product rather than two
+    // that can disagree.
+    assert.ok(sent.body.files.every((file) => !file.relativePath.startsWith("Drifters/")));
+  });
+});
+
+test("each picture is named with what belongs to it, by index", () => {
+  const { req, reply, sent, deps } = harness([
+    { path: "Drifters/ep 1.mkv", length: 9 },
+    { path: "Drifters/Rus Sound/ep 1.mka", length: 2 },
+    { path: "Drifters/Sub/ep 1.ass", length: 1 },
+    { path: "Drifters/ep 2.mkv", length: 9 }
+  ]);
+
+  return handleApiSourceFilesGet(req, reply, deps).then(() => {
+    assert.deepEqual(sent.body.items, [
+      { fileIndex: 0, audio: [1], subtitles: [2], images: [] },
+      { fileIndex: 3, audio: [], subtitles: [], images: [] }
+    ]);
+    // The files themselves are in the list above; saying them twice is how two
+    // copies of one fact start.
+    assert.ok(sent.body.items.every((item) => item.audio.every((one) => Number.isInteger(one))));
+  });
+});
+
+test("a torrent whose metadata has not arrived says so and lists nothing", () => {
+  const { req, reply, sent, deps } = harness([]);
+
+  return handleApiSourceFilesGet(req, reply, deps).then(() => {
+    assert.deepEqual(sent.body.files, []);
+    assert.deepEqual(sent.body.items, []);
+    assert.equal(sent.body.name, "Drifters");
+  });
+});

package/test/stream-route.test.js

@@ -19,11 +19,11 @@ import { handleStreamGet } from "../routes/stream/get.js";
  * Minimal stand-ins for the parts of Fastify and the pool this route touches.
  *
  * @param {{ method: string, range?: string }} request
- * @returns {{ req: object, reply: object, sent: object, opened: string[], claims: number }}
+ * @returns {{ req: object, reply: object, sent: object, opened: string[], state: object }}
  */
 function harness({ method, range }) {
   const opened = [];
-  const state = { claims: 0, prioritized: [] };
+  const state = { prioritized: [] };
 
   const sent = { code: 200, headers: {}, body: undefined, called: false };
   const reply = {
@@ -71,10 +71,6 @@ function harness({ method, range }) {
     async getTorrent() {
       return { files: [file], sourceKey: "key" };
     },
-    acquireFile() {
-      state.claims += 1;
-      return () => undefined;
-    },
     prioritizeByteRange(_torrent, fileIndex, byteStart, _windowBytes, options) {
       state.prioritized.push({ byteStart, wholeFileRead: options?.wholeFileRead === true });
     }
@@ -96,7 +92,7 @@ test("HEAD reports the size without opening a read", async () => {
   await handleStreamGet(req, reply, deps);
 
   assert.deepEqual(opened, [], "HEAD started a read of the file");
-  assert.equal(state.claims, 0, "HEAD claimed the file it never read");
+  assert.deepEqual(state.prioritized, [], "HEAD asked the swarm for a read it never made");
   // The real size, not the zero Fastify substitutes for an empty payload — the
   // keyframe index reads this header and treats 0 as "no index".
   assert.equal(sent.headers["content-length"], "5869669065");
@@ -182,5 +178,5 @@ test("a file this proxy does not have whole still goes to the torrent", async ()
   const { req, reply, state, deps } = harness({ method: "GET", range: "bytes=0-99" });
   deps.torrentPool.wholeFiles = new Map([["other/7", { path: "/nowhere", length: 1, name: "x" }]]);
   await handleStreamGet(req, reply, deps);
-  assert.equal(state.claims, 1, "the ordinary path was not taken");
+  assert.equal(state.prioritized.length, 1, "the ordinary path was not taken");
 });

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

@@ -3,21 +3,38 @@
  *
  * WebTorrent enforces `maxConns` only on peers it dials (`_drain`), while
  * `_addIncomingPeer` checks that the torrent is neither destroyed nor paused
- * and registers the peer. A proxy with its port mapped is reachable, so
- * connections arrive and are never turned away — field 2026-09-11: 249
- * connected at the start of one viewing, 596 at the end, 15 862 more queued, on
- * a file that had been complete for three quarters of an hour, each connection
- * served by reading a 4 MB piece off the disk for every 16 KB sent.
+ * and registers the peer. A proxy with its port mapped is reachable, so on a
+ * popular torrent connections arrive and are never turned away — field
+ * 2026-09-11: 249 connected at the start of one viewing, 596 at the end, 15 862
+ * more queued, on a file complete for three quarters of an hour.
  *
- * The rule is not a limit on connections. While anybody is reading, every
- * connection is worth keeping: the one that has delivered nothing yet may
- * deliver next. It is about a torrent nobody is reading at all.
+ * The rule is not a limit on connections. While anybody is reading, every one is
+ * worth keeping: the one that has delivered nothing yet may deliver next.
+ *
+ * AND IT IS ASKED OF WHAT HAS BEEN STATED, never of a count of readers. The
+ * first version asked every five seconds whether anybody was READING, and a
+ * torrent added three seconds earlier answered no — its edges still being read,
+ * its plan still being built. It left the swarm with 741 connections let go,
+ * and nothing rejoined it: rejoining waited for a reader, and the reader was
+ * waiting for the header the swarm had been fetching. Playback did not start at
+ * all.
+ *
+ * The question now is whether anything is WANTED of it, which the priority map,
+ * the ends of an open file and a stopped read all answer — and which is true
+ * from the moment a torrent is opened.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { TorrentPool } from "../services/torrent-pool.js";
+import {
+  isWanted,
+  leaveSwarm,
+  rejoinSwarm,
+  stateFileEdges,
+  swarmDecisionFor
+} from "../services/torrent-pool.js";
 import { demandFor, forgetTorrent } from "../services/download/registry.js";
+import { Urgency } from "../services/demand/index.js";
 
 /**
  * A torrent that records what was done to it. Only the surface the rule
@@ -39,7 +56,7 @@ function torrentWith(peerCount) {
   }
   return {
     infoHash: "f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0",
-    files: [{ length: 1024 }],
+    files: [{ length: 1024 }, { length: 2048 }],
     paused: false,
     wires: [...peers.values()].map((peer) => peer.wire),
     _peers: peers,
@@ -52,117 +69,106 @@ function torrentWith(peerCount) {
   };
 }
 
-/**
- * @param {object} torrent
- * @returns {TorrentPool}
- */
-function poolWith(torrent) {
-  const pool = Object.create(TorrentPool.prototype);
-  pool.torrents = new Map([["source", torrent]]);
-  pool.fileUsageByTorrent = new WeakMap();
-  return pool;
-}
-
-test("a torrent nobody is reading is let go of, and its data is not", () => {
+test("letting a swarm go pauses the torrent and closes what the pause does 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");
-    assert.equal(torrent._peers.size, 0, "the connections the pause does not close were not let go");
-  } finally {
-    forgetTorrent(torrent);
-  }
-});
 
-test("a torrent somebody is reading keeps every connection it has", () => {
-  const torrent = torrentWith(6);
-  const pool = poolWith(torrent);
-  pool.fileUsageByTorrent.set(torrent, new Map([[0, 1]]));
-  try {
-    pool.followTheReaders(torrent);
+  const closed = leaveSwarm(torrent);
 
-    assert.equal(torrent.paused, false, "a torrent being read was taken out of its swarm");
-    assert.equal(torrent._peers.size, 6, "connections were closed while somebody was reading");
-  } finally {
-    forgetTorrent(torrent);
-  }
+  assert.equal(torrent.paused, true, "the library's own word for this was not used");
+  assert.equal(closed, 6);
+  assert.equal(torrent._peers.size, 0, "the connections the pause does not close were not let go");
 });
 
-test("a stated window keeps the swarm even with no file held", () => {
-  // The register is what the download layer states; a reader that has declared
-  // a window but not yet taken a file hold is still a reader.
-  const torrent = torrentWith(2);
-  const pool = poolWith(torrent);
-  demandFor(torrent).register.state({
-    claimant: "read-1",
-    fileIndex: 0,
-    byteStart: 0,
-    byteEnd: 1023,
-    urgency: 0
-  });
-  try {
-    pool.followTheReaders(torrent);
-    assert.equal(torrent.paused, false, "a declared window did not count as somebody reading");
-  } finally {
-    forgetTorrent(torrent);
-  }
+test("a swarm already let go is not let go twice", () => {
+  const torrent = torrentWith(4);
+  leaveSwarm(torrent);
+  assert.equal(leaveSwarm(torrent), 0);
 });
 
-test("the swarm is rejoined when a reader comes back", () => {
+test("the reader that comes back takes the swarm with it", () => {
   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);
-
-    pool.fileUsageByTorrent.set(torrent, new Map([[0, 1]]));
-    pool.followTheReaders(torrent);
-    assert.equal(torrent.paused, false, "the next reader was left with a torrent that fetches nothing");
-  } finally {
-    forgetTorrent(torrent);
-  }
+  leaveSwarm(torrent);
+
+  assert.equal(rejoinSwarm(torrent), true);
+  assert.equal(torrent.paused, false, "the next reader was left with a torrent that fetches nothing");
+  assert.equal(rejoinSwarm(torrent), false, "a torrent already in its swarm was resumed again");
 });
 
-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.
+test("a torrent whose metadata has not arrived is wanted, whatever is stated", () => {
+  // THE FIELD FAILURE OF 2026-09-11, as a question rather than as a mechanism.
+  // A torrent being added has no list of files, so nothing can name a byte of
+  // it — and it is being fetched precisely because somebody asked for it.
   const torrent = torrentWith(103);
-  const pool = poolWith(torrent);
+  torrent.files = [];
+  assert.equal(isWanted(torrent), true);
+});
+
+test("a torrent with files and nothing stated for them is wanted by nobody", () => {
+  const torrent = torrentWith(4);
   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");
+    assert.equal(isWanted(torrent), false);
   } finally {
     forgetTorrent(torrent);
   }
 });
 
-test("once it has been read, leaving is allowed again", () => {
+test("anything stated makes it wanted, and the last withdrawal ends that", () => {
   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");
+    // The ends of a file being opened, which is the first thing said about a
+    // torrent anybody has picked and the reason it stays in its swarm through
+    // the seconds when nothing else can say anything about it.
+    stateFileEdges(torrent, 0, Urgency.TAIL);
+    assert.equal(isWanted(torrent), true);
+
+    const { register } = demandFor(torrent);
+    register.withdraw("file-edges:0:head");
+    assert.equal(isWanted(torrent), true, "one end of it is still wanted");
+    register.withdraw("file-edges:0:tail");
+    assert.equal(isWanted(torrent), false);
   } finally {
     forgetTorrent(torrent);
   }
 });
+
+test("a torrent that has been destroyed is wanted by nobody", () => {
+  const torrent = torrentWith(1);
+  torrent.destroyed = true;
+  assert.equal(isWanted(torrent), false);
+});
+
+test("a torrent something is wanted of keeps its swarm and is off the clock", () => {
+  assert.deepEqual(
+    swarmDecisionFor({ wanted: true, everWanted: true }),
+    { swarm: "take", onTheClock: false }
+  );
+  assert.deepEqual(
+    swarmDecisionFor({ wanted: true, everWanted: false }),
+    { swarm: "take", onTheClock: false }
+  );
+});
+
+test("a swarm is let go on a DEPARTURE, never on a beginning", () => {
+  // The whole of the 2.83.1 failure in one line: a torrent that has never been
+  // wanted is one being opened — its metadata has just landed, the file list is
+  // on its way to the person choosing, and nothing has had a chance to state
+  // anything about it yet. Taking its swarm away there destroyed 741
+  // connections it needed a minute later.
+  assert.deepEqual(
+    swarmDecisionFor({ wanted: false, everWanted: false }),
+    { swarm: "leave alone", onTheClock: true }
+  );
+  assert.deepEqual(
+    swarmDecisionFor({ wanted: false, everWanted: true }),
+    { swarm: "let go", onTheClock: true }
+  );
+});
+
+test("whatever happens to the swarm, an unwanted torrent is on the idle clock", () => {
+  // Including the one nobody has ever wanted: a file list fetched and never
+  // played used to be held for the life of the process, because the only thing
+  // that started the clock was a reader letting go.
+  for (const everWanted of [true, false]) {
+    assert.equal(swarmDecisionFor({ wanted: false, everWanted }).onTheClock, true);
+  }
+});