@torrent-tv/proxy 2.89.5 → 2.89.7

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

@@ -1,174 +1,174 @@
-/**
- * @file A proxy that needs nothing from a swarm is not in that swarm.
- *
- * 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 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 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 {
-  isWanted,
-  leaveSwarm,
-  rejoinSwarm,
-  stateFileEdges,
-  swarmDecisionFor
-} from "../services/torrent/torrent-pool.js";
-import { demandFor, forgetTorrent } from "../services/torrent/download/registry.js";
-import { Urgency } from "../services/torrent/demand/index.js";
-
-/**
- * A torrent that records what was done to it. Only the surface the rule
- * touches: `paused` is the library's own flag, and the peers are what the pause
- * does not close by itself.
- *
- * @param {number} peerCount
- * @returns {object}
- */
-function torrentWith(peerCount) {
-  const peers = new Map();
-  for (let index = 0; index < peerCount; index += 1) {
-    peers.set(String(index), {
-      wire: { downloaded: 0 },
-      destroy() {
-        peers.delete(String(index));
-      }
-    });
-  }
-  return {
-    infoHash: "f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0",
-    files: [{ length: 1024 }, { length: 2048 }],
-    paused: false,
-    wires: [...peers.values()].map((peer) => peer.wire),
-    _peers: peers,
-    pause() {
-      this.paused = true;
-    },
-    resume() {
-      this.paused = false;
-    }
-  };
-}
-
-test("letting a swarm go pauses the torrent and closes what the pause does not", () => {
-  const torrent = torrentWith(6);
-
-  const closed = leaveSwarm(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 swarm already let go is not let go twice", () => {
-  const torrent = torrentWith(4);
-  leaveSwarm(torrent);
-  assert.equal(leaveSwarm(torrent), 0);
-});
-
-test("the reader that comes back takes the swarm with it", () => {
-  const torrent = torrentWith(3);
-  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 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);
-  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 {
-    assert.equal(isWanted(torrent), false);
-  } finally {
-    forgetTorrent(torrent);
-  }
-});
-
-test("anything stated makes it wanted, and the last withdrawal ends that", () => {
-  const torrent = torrentWith(4);
-  try {
-    // 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);
-  }
-});
+/**
+ * @file A proxy that needs nothing from a swarm is not in that swarm.
+ *
+ * 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 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 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 {
+  isWanted,
+  leaveSwarm,
+  rejoinSwarm,
+  stateFileEdges,
+  swarmDecisionFor
+} from "../services/torrent/torrent-pool.js";
+import { demandFor, forgetTorrent } from "../services/torrent/download/registry.js";
+import { Urgency } from "../services/torrent/demand/index.js";
+
+/**
+ * A torrent that records what was done to it. Only the surface the rule
+ * touches: `paused` is the library's own flag, and the peers are what the pause
+ * does not close by itself.
+ *
+ * @param {number} peerCount
+ * @returns {object}
+ */
+function torrentWith(peerCount) {
+  const peers = new Map();
+  for (let index = 0; index < peerCount; index += 1) {
+    peers.set(String(index), {
+      wire: { downloaded: 0 },
+      destroy() {
+        peers.delete(String(index));
+      }
+    });
+  }
+  return {
+    infoHash: "f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0",
+    files: [{ length: 1024 }, { length: 2048 }],
+    paused: false,
+    wires: [...peers.values()].map((peer) => peer.wire),
+    _peers: peers,
+    pause() {
+      this.paused = true;
+    },
+    resume() {
+      this.paused = false;
+    }
+  };
+}
+
+test("letting a swarm go pauses the torrent and closes what the pause does not", () => {
+  const torrent = torrentWith(6);
+
+  const closed = leaveSwarm(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 swarm already let go is not let go twice", () => {
+  const torrent = torrentWith(4);
+  leaveSwarm(torrent);
+  assert.equal(leaveSwarm(torrent), 0);
+});
+
+test("the reader that comes back takes the swarm with it", () => {
+  const torrent = torrentWith(3);
+  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 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);
+  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 {
+    assert.equal(isWanted(torrent), false);
+  } finally {
+    forgetTorrent(torrent);
+  }
+});
+
+test("anything stated makes it wanted, and the last withdrawal ends that", () => {
+  const torrent = torrentWith(4);
+  try {
+    // 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);
+  }
+});

package/test/swarm-reach.test.js

@@ -1,130 +1,130 @@
-/**
- * @file The line describing a swarm answers the question it is asked.
- *
- * It could not. `routes/api/sources/stats/get.js` printed `peers=N` beside
- * `wires=?`, which reads as two quantities of which one is unknown — while
- * WebTorrent's `numPeers` IS `wires.length` (`lib/torrent.js:254`, the same in
- * 2.8.5 and 3.0.21), so the first was the connection count and the second was a
- * field that has never printed anything, because the torrent lives on a worker
- * thread where that property does not exist.
- *
- * What was missing is the other half: how many peers the client HOLDS but is
- * not connected to, and what the tracker said the swarm has. Measured
- * 2026-08-21 on `JUFD665.mp4`, the tracker answered `seeders=5` at 13:40:30 and
- * the first wire arrived at 13:44:47 — 4 min 17 s in which the stats line
- * repeated unchanged every two seconds while the answer ("offered, not
- * connected") was already in the process.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { bestAnnounce, describeSwarmReach, secondsToFirstPeer } from "../services/torrent/torrent-pool.js";
-
-test("connected and known are separate numbers", () => {
-  const torrent = { wires: [{}, {}], _peersLength: 7, _numQueued: 4 };
-  assert.deepEqual(describeSwarmReach(torrent), {
-    connectedPeers: 2,
-    deliveringPeers: 0,
-    knownPeers: 7,
-    queuedPeers: 4
-  });
-});
-
-test("offered but not connected is distinguishable from nobody offered", () => {
-  // The two shapes the field produced. They need opposite investigations, and
-  // one line has to tell them apart.
-  const offeredNotConnected = describeSwarmReach({ wires: [], _peersLength: 5, _numQueued: 5 });
-  const nobodyOffered = describeSwarmReach({ wires: [], _peersLength: 0, _numQueued: 0 });
-  assert.equal(offeredNotConnected.connectedPeers, 0);
-  assert.equal(nobodyOffered.connectedPeers, 0);
-  assert.notEqual(offeredNotConnected.knownPeers, nobodyOffered.knownPeers);
-});
-
-test("internals that are gone say nothing rather than breaking the poll", () => {
-  // `_peersLength` and `_numQueued` are not WebTorrent's published interface.
-  // The browser polls this every two seconds, so a version that drops them must
-  // cost the field and not the answer.
-  assert.deepEqual(describeSwarmReach({ wires: [{}] }), {
-    connectedPeers: 1,
-    deliveringPeers: 0,
-    knownPeers: null,
-    queuedPeers: null
-  });
-  assert.deepEqual(describeSwarmReach({}), {
-    connectedPeers: 0,
-    deliveringPeers: 0,
-    knownPeers: null,
-    queuedPeers: null
-  });
-  assert.deepEqual(describeSwarmReach(null), {
-    connectedPeers: 0,
-    deliveringPeers: 0,
-    knownPeers: null,
-    queuedPeers: null
-  });
-  const throwing = {
-    wires: [],
-    get _peersLength() {
-      throw new Error("destroyed");
-    }
-  };
-  assert.deepEqual(describeSwarmReach(throwing), {
-    connectedPeers: 0,
-    deliveringPeers: 0,
-    knownPeers: null,
-    queuedPeers: null
-  });
-});
-
-test("the wait for a first peer is a measured quantity", () => {
-  // The field case: added 13:40:30.357, first wire 13:44:47.123.
-  assert.equal(secondsToFirstPeer(1000, 258_766), 257.766);
-  assert.equal(secondsToFirstPeer(1000, 1000), 0);
-});
-
-test("no peer yet is not a duration", () => {
-  assert.equal(secondsToFirstPeer(1000, null), null);
-  assert.equal(secondsToFirstPeer(null, 2000), null);
-  // A clock that went backwards is not a negative wait; it is no reading.
-  assert.equal(secondsToFirstPeer(2000, 1000), null);
-});
-
-test("the best tracker answer wins, not the most recent", () => {
-  // A live tracker says 500, a dead one answers 0 two seconds later. Keeping
-  // the last would print "nobody offered" about a swarm of five hundred, which
-  // inverts the one distinction this figure is carried for.
-  const answers = [
-    { seeders: 500, leechers: 40 },
-    { seeders: 0, leechers: 0 }
-  ];
-  assert.deepEqual(bestAnnounce(answers), { seeders: 500, leechers: 40, trackers: 2 });
-});
-
-test("trackers that answered are counted even when none knew anything", () => {
-  assert.deepEqual(bestAnnounce([{ seeders: null, leechers: null }]), {
-    seeders: null,
-    leechers: null,
-    trackers: 1
-  });
-  // No tracker has answered at all — a different state from "answered, knows
-  // nobody", and the line says so.
-  assert.deepEqual(bestAnnounce([]), { seeders: null, leechers: null, trackers: 0 });
-  assert.deepEqual(bestAnnounce(null), { seeders: null, leechers: null, trackers: 0 });
-});
-
-test("leechers travel with the seeder count they were reported beside", () => {
-  const answers = [
-    { seeders: 2, leechers: 99 },
-    { seeders: 7, leechers: 3 }
-  ];
-  assert.equal(bestAnnounce(answers).leechers, 3);
-  // Including when the winning answer gave no leecher count: carrying the
-  // previous tracker's figure forward would present two trackers' numbers as
-  // one reading.
-  assert.deepEqual(bestAnnounce([{ seeders: 2, leechers: 99 }, { seeders: 7, leechers: null }]), {
-    seeders: 7,
-    leechers: null,
-    trackers: 2
-  });
-});
+/**
+ * @file The line describing a swarm answers the question it is asked.
+ *
+ * It could not. `routes/api/sources/stats/get.js` printed `peers=N` beside
+ * `wires=?`, which reads as two quantities of which one is unknown — while
+ * WebTorrent's `numPeers` IS `wires.length` (`lib/torrent.js:254`, the same in
+ * 2.8.5 and 3.0.21), so the first was the connection count and the second was a
+ * field that has never printed anything, because the torrent lives on a worker
+ * thread where that property does not exist.
+ *
+ * What was missing is the other half: how many peers the client HOLDS but is
+ * not connected to, and what the tracker said the swarm has. Measured
+ * 2026-08-21 on `JUFD665.mp4`, the tracker answered `seeders=5` at 13:40:30 and
+ * the first wire arrived at 13:44:47 — 4 min 17 s in which the stats line
+ * repeated unchanged every two seconds while the answer ("offered, not
+ * connected") was already in the process.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { bestAnnounce, describeSwarmReach, secondsToFirstPeer } from "../services/torrent/torrent-pool.js";
+
+test("connected and known are separate numbers", () => {
+  const torrent = { wires: [{}, {}], _peersLength: 7, _numQueued: 4 };
+  assert.deepEqual(describeSwarmReach(torrent), {
+    connectedPeers: 2,
+    deliveringPeers: 0,
+    knownPeers: 7,
+    queuedPeers: 4
+  });
+});
+
+test("offered but not connected is distinguishable from nobody offered", () => {
+  // The two shapes the field produced. They need opposite investigations, and
+  // one line has to tell them apart.
+  const offeredNotConnected = describeSwarmReach({ wires: [], _peersLength: 5, _numQueued: 5 });
+  const nobodyOffered = describeSwarmReach({ wires: [], _peersLength: 0, _numQueued: 0 });
+  assert.equal(offeredNotConnected.connectedPeers, 0);
+  assert.equal(nobodyOffered.connectedPeers, 0);
+  assert.notEqual(offeredNotConnected.knownPeers, nobodyOffered.knownPeers);
+});
+
+test("internals that are gone say nothing rather than breaking the poll", () => {
+  // `_peersLength` and `_numQueued` are not WebTorrent's published interface.
+  // The browser polls this every two seconds, so a version that drops them must
+  // cost the field and not the answer.
+  assert.deepEqual(describeSwarmReach({ wires: [{}] }), {
+    connectedPeers: 1,
+    deliveringPeers: 0,
+    knownPeers: null,
+    queuedPeers: null
+  });
+  assert.deepEqual(describeSwarmReach({}), {
+    connectedPeers: 0,
+    deliveringPeers: 0,
+    knownPeers: null,
+    queuedPeers: null
+  });
+  assert.deepEqual(describeSwarmReach(null), {
+    connectedPeers: 0,
+    deliveringPeers: 0,
+    knownPeers: null,
+    queuedPeers: null
+  });
+  const throwing = {
+    wires: [],
+    get _peersLength() {
+      throw new Error("destroyed");
+    }
+  };
+  assert.deepEqual(describeSwarmReach(throwing), {
+    connectedPeers: 0,
+    deliveringPeers: 0,
+    knownPeers: null,
+    queuedPeers: null
+  });
+});
+
+test("the wait for a first peer is a measured quantity", () => {
+  // The field case: added 13:40:30.357, first wire 13:44:47.123.
+  assert.equal(secondsToFirstPeer(1000, 258_766), 257.766);
+  assert.equal(secondsToFirstPeer(1000, 1000), 0);
+});
+
+test("no peer yet is not a duration", () => {
+  assert.equal(secondsToFirstPeer(1000, null), null);
+  assert.equal(secondsToFirstPeer(null, 2000), null);
+  // A clock that went backwards is not a negative wait; it is no reading.
+  assert.equal(secondsToFirstPeer(2000, 1000), null);
+});
+
+test("the best tracker answer wins, not the most recent", () => {
+  // A live tracker says 500, a dead one answers 0 two seconds later. Keeping
+  // the last would print "nobody offered" about a swarm of five hundred, which
+  // inverts the one distinction this figure is carried for.
+  const answers = [
+    { seeders: 500, leechers: 40 },
+    { seeders: 0, leechers: 0 }
+  ];
+  assert.deepEqual(bestAnnounce(answers), { seeders: 500, leechers: 40, trackers: 2 });
+});
+
+test("trackers that answered are counted even when none knew anything", () => {
+  assert.deepEqual(bestAnnounce([{ seeders: null, leechers: null }]), {
+    seeders: null,
+    leechers: null,
+    trackers: 1
+  });
+  // No tracker has answered at all — a different state from "answered, knows
+  // nobody", and the line says so.
+  assert.deepEqual(bestAnnounce([]), { seeders: null, leechers: null, trackers: 0 });
+  assert.deepEqual(bestAnnounce(null), { seeders: null, leechers: null, trackers: 0 });
+});
+
+test("leechers travel with the seeder count they were reported beside", () => {
+  const answers = [
+    { seeders: 2, leechers: 99 },
+    { seeders: 7, leechers: 3 }
+  ];
+  assert.equal(bestAnnounce(answers).leechers, 3);
+  // Including when the winning answer gave no leecher count: carrying the
+  // previous tracker's figure forward would present two trackers' numbers as
+  // one reading.
+  assert.deepEqual(bestAnnounce([{ seeders: 2, leechers: 99 }, { seeders: 7, leechers: null }]), {
+    seeders: 7,
+    leechers: null,
+    trackers: 2
+  });
+});