@torrent-tv/proxy 2.50.0 → 2.52.0

package/test/dht-bootstrap.test.js

@@ -0,0 +1,72 @@
+/**
+ * @file The DHT's entry points are given as addresses, not names.
+ *
+ * Measured 2026-08-21 on the addon host. Two of the three bootstrap nodes the
+ * library ships answer nothing: `router.bittorrent.com` and `router.utorrent.com`
+ * did not reply to a hand-written `ping` at all, while a control datagram to a
+ * DNS server came back in 20 ms. The third, `dht.transmissionbt.com`, is alive —
+ * it answered `find_node` with eight nodes — but on a host with global IPv6 its
+ * name resolves to an IPv6 address first, and the DHT's socket is IPv4, so by
+ * name it was never reached. By name: 0 nodes after 21 s, every run. By address:
+ * 22 nodes in 5 s.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { dhtNodeCount, parseBootstrapEntry, resolveDhtBootstrap } from "../services/torrent-pool.js";
+
+test("a bootstrap entry is split into host and port", () => {
+  assert.deepEqual(parseBootstrapEntry("dht.libtorrent.org:25401"), {
+    host: "dht.libtorrent.org",
+    port: 25401
+  });
+});
+
+test("an entry with no port gets the DHT's own", () => {
+  assert.deepEqual(parseBootstrapEntry("router.bittorrent.com"), {
+    host: "router.bittorrent.com",
+    port: 6881
+  });
+});
+
+test("an unusable entry is dropped rather than breaking the client", () => {
+  // One bad line in the list must cost that node and nothing else — the DHT is
+  // best-effort by nature and a typo here would otherwise take the whole client
+  // down at construction.
+  assert.equal(parseBootstrapEntry(""), null);
+  assert.equal(parseBootstrapEntry("   "), null);
+  assert.equal(parseBootstrapEntry("host:0"), null);
+  assert.equal(parseBootstrapEntry("host:70000"), null);
+  assert.equal(parseBootstrapEntry("host:not-a-port"), null);
+  assert.equal(parseBootstrapEntry(":6881"), null);
+  assert.equal(parseBootstrapEntry(null), null);
+  assert.equal(parseBootstrapEntry(42), null);
+});
+
+test("the routing table's size is readable, and its absence is not an error", () => {
+  assert.equal(dhtNodeCount({ dht: { nodes: { toArray: () => [1, 2, 3] } } }), 3);
+  assert.equal(dhtNodeCount({ dht: { nodes: { toArray: () => [] } } }), 0);
+  // A client built without a DHT, or one whose internals moved: the difference
+  // between "no DHT" and "an empty DHT" is the whole point of the report, so
+  // the first must not be printed as the second.
+  assert.equal(dhtNodeCount({}), null);
+  assert.equal(dhtNodeCount({ dht: {} }), null);
+  assert.equal(dhtNodeCount(null), null);
+  assert.equal(dhtNodeCount({ dht: { nodes: { toArray: () => { throw new Error("gone"); } } } }), null);
+});
+
+test("a name that will not resolve inside the cap is dropped, not waited on", async () => {
+  // The whole call is awaited before the torrent client exists, so a resolver
+  // that black-holes must cost the cap and not c-ares' own four tries.
+  const started = Date.now();
+  // `.invalid` is reserved by RFC 2606 and never resolves; the cap is what
+  // bounds the wait when a resolver answers slowly rather than quickly.
+  const resolved = await resolveDhtBootstrap(["nothing.invalid:6881"], 200);
+  assert.deepEqual(resolved, []);
+  assert.ok(Date.now() - started < 2000, "the cap, not the resolver, decided when to give up");
+});
+
+test("an empty list is an answer, not a failure", async () => {
+  assert.deepEqual(await resolveDhtBootstrap([], 200), []);
+});

package/test/run-position-follows-published-grid.test.js

@@ -0,0 +1,87 @@
+/**
+ * @file A run is POSITIONED where the player was told the segment begins.
+ *
+ * The companion of `cuts-follow-published-grid`, and the half that was missing.
+ * 2.45.0 moved the cut list onto the published table and left the position on
+ * the live one — but `-segment_times` are measured from wherever the run really
+ * began, so any distance between the two moves EVERY cut of that run by it. The
+ * live table keeps being corrected, and the corrections run backwards, so each
+ * restart began a little earlier than the grid its cuts were stated on and the
+ * distance accumulated across restarts.
+ *
+ * Field 2026-08-21, `JUFD665.mp4` (MP4, copy path, index read cleanly): after
+ * one seek restart a produced segment held the boundary two places before its
+ * own number — 16.684 s, which is 2.0000 segments — and after the next restart,
+ * four places, 33.5 s. The player's buffer then stopped extending at all,
+ * because every fragment's content landed before the time its playlist entry
+ * named: `bufferEnd` stood still at 4571.1 s through four `frag-far` warnings
+ * until hls.js gave up and jumped the viewer 16.8 s forward.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { HlsSessionManager, describeGridDrift, segmentCutTimesFrom } from "../services/hls-session-manager.js";
+
+/** What the playlist in the player's hands says. */
+const PUBLISHED = [0, 8.342, 16.684, 25.026, 33.368, 41.71];
+/** The same grid after produced segments moved two of its cuts backwards. */
+const CORRECTED = [0, 8.342, 14.682, 25.026, 31.366, 41.71];
+
+/**
+ * @returns {{ manager: HlsSessionManager, session: object }}
+ */
+function sessionWithDriftedGrid() {
+  const manager = new HlsSessionManager({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  const session = {
+    id: "picture",
+    segmentBoundaries: [...CORRECTED],
+    publishedBoundaries: [...PUBLISHED]
+  };
+  return { manager, session };
+}
+
+test("a run starts at the time the player was told, not at the corrected one", () => {
+  const { manager, session } = sessionWithDriftedGrid();
+  assert.equal(manager.runStartTimeFor(session, 2), 16.684);
+  assert.notEqual(manager.runStartTimeFor(session, 2), session.segmentBoundaries[2]);
+});
+
+test("position and cut list come from the same table", () => {
+  const { manager, session } = sessionWithDriftedGrid();
+  const grid = manager.publishedGridFor(session);
+  const start = manager.runStartTimeFor(session, 2);
+  // The cut list is stated as offsets from where the run begins. Adding the
+  // position back must land on the published boundaries exactly — which is the
+  // property that was false while the two came from different tables.
+  const absolute = segmentCutTimesFrom(grid, 2).map((offset) => Number((start + offset).toFixed(3)));
+  assert.deepEqual(absolute, [25.026, 33.368]);
+});
+
+test("a session that published no grid positions on the live one", () => {
+  const { manager } = sessionWithDriftedGrid();
+  const session = { id: "no-playlist", segmentBoundaries: [...CORRECTED], publishedBoundaries: [] };
+  assert.equal(manager.runStartTimeFor(session, 2), CORRECTED[2]);
+});
+
+test("an index beyond the table is clamped rather than returning nothing", () => {
+  const { manager, session } = sessionWithDriftedGrid();
+  assert.equal(manager.runStartTimeFor(session, 9999), PUBLISHED[PUBLISHED.length - 1]);
+  assert.equal(manager.runStartTimeFor(session, -3), PUBLISHED[0]);
+});
+
+test("the drift between the two tables is stated in full", () => {
+  assert.equal(describeGridDrift(PUBLISHED, PUBLISHED), "identical");
+  assert.equal(
+    describeGridDrift(PUBLISHED, CORRECTED),
+    "2 of 6 boundaries apart, worst 2.002s at #2"
+  );
+  assert.equal(describeGridDrift(PUBLISHED, [0, 1]), "a different length (6 against 2)");
+  assert.equal(describeGridDrift(null, CORRECTED), "not comparable");
+  assert.equal(describeGridDrift([], []), "not comparable");
+});

package/test/swarm-reach.test.js

@@ -0,0 +1,125 @@
+/**
+ * @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-pool.js";
+
+test("connected and known are separate numbers", () => {
+  const torrent = { wires: [{}, {}], _peersLength: 7, _numQueued: 4 };
+  assert.deepEqual(describeSwarmReach(torrent), {
+    connectedPeers: 2,
+    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,
+    knownPeers: null,
+    queuedPeers: null
+  });
+  assert.deepEqual(describeSwarmReach({}), {
+    connectedPeers: 0,
+    knownPeers: null,
+    queuedPeers: null
+  });
+  assert.deepEqual(describeSwarmReach(null), {
+    connectedPeers: 0,
+    knownPeers: null,
+    queuedPeers: null
+  });
+  const throwing = {
+    wires: [],
+    get _peersLength() {
+      throw new Error("destroyed");
+    }
+  };
+  assert.deepEqual(describeSwarmReach(throwing), {
+    connectedPeers: 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
+  });
+});

package/test/viewer-position-on-open.test.js

@@ -0,0 +1,53 @@
+/**
+ * @file Opening a file at a position puts the SOUND there too.
+ *
+ * The audio rendition is a session of its own, and where it starts is computed
+ * from where the viewer is. That reading had three sources and only two were
+ * consulted — a position seeked to, and the last segment this session served —
+ * both of which are written by things that have not happened yet at the moment
+ * a file is opened at a position. So the answer was zero.
+ *
+ * Field 2026-08-21, `Minions.and.Monsters.1080p.mkv` reopened from the address
+ * bar at 52:07:
+ *
+ *   18:02:55.124  8ed85605  start=3130s  -ss 3125.25  -an -map 0:v:0 -c:v copy
+ *   18:02:55.632  33b0b046  start=0s     no -ss       -vn -map 0:a:0 -c:a aac
+ *
+ * The picture went to segment #781, the sound to #0. The player asked both for
+ * #782; the picture had it, the sound re-encoded 57.5 s of a 3130 s film in the
+ * 45 s the request lasted and then answered 404 — shown to the viewer as "the
+ * proxy accepted the request but sent no video".
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { resolveViewerPosition } from "../services/hls-session-manager.js";
+
+test("a file opened at a position has its viewer at that position", () => {
+  // Nothing has been seeked and nothing served yet — the state at the instant
+  // the audio rendition is created.
+  assert.equal(resolveViewerPosition({ openedAt: 3130 }), 3130);
+});
+
+test("a seek beats everything else", () => {
+  assert.equal(
+    resolveViewerPosition({ seeked: 900, lastRequestedStart: 400, openedAt: 3130 }),
+    900
+  );
+});
+
+test("what has been served beats where the file was opened", () => {
+  // The opening position is the oldest of the three readings: once a segment
+  // has been served, that is where the reading is.
+  assert.equal(resolveViewerPosition({ lastRequestedStart: 400, openedAt: 3130 }), 400);
+});
+
+test("with nothing to go on the answer is the beginning", () => {
+  assert.equal(resolveViewerPosition({}), 0);
+  assert.equal(resolveViewerPosition({ seeked: 0, lastRequestedStart: 0, openedAt: 0 }), 0);
+  // Values that are not readings must not become one.
+  assert.equal(resolveViewerPosition({ seeked: Number.NaN, openedAt: Number.NaN }), 0);
+  assert.equal(resolveViewerPosition({ seeked: -5, openedAt: -5 }), 0);
+  assert.equal(resolveViewerPosition({ lastRequestedStart: null, openedAt: undefined }), 0);
+});