@torrent-tv/proxy 2.79.0 → 2.80.1

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

@@ -0,0 +1,156 @@
+/**
+ * @file What the download is told when the priority map changes.
+ *
+ * The map states seconds of film against a number. This is the one place those
+ * seconds become bytes, and the one place the map's own scale — as many bands
+ * as the film needs — is fitted onto the five levels the register has. Both
+ * were written on 2026-09-05 to replace the windows the reads themselves used
+ * to declare: fifteen reads on one file were fifteen windows on a piece store
+ * holding sixteen pieces, and half of all evictions then took a piece a reader
+ * had said it wanted.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { TorrentPool } from "../services/torrent-pool.js";
+import { demandFor, forgetTorrent } from "../services/download/registry.js";
+import { Urgency } from "../services/demand/index.js";
+import { mapForViewer } from "../services/priority/PriorityMap.js";
+
+/** A torrent that is nothing but one file of a known length. */
+function torrentOf({ length = 1_000_000, offset = 0 } = {}) {
+  return {
+    infoHash: `hash-${Math.random().toString(36).slice(2)}`,
+    pieceLength: 1024,
+    files: [{ offset, length, name: "film.mkv" }],
+    _selections: { _items: [] },
+    _select() {},
+    _deselect() {},
+    critical() {}
+  };
+}
+
+/** The pool's method under test, called without building a pool. */
+const applyPriorityMap = TorrentPool.prototype.applyPriorityMap;
+
+test("seconds of film become bytes of the file", () => {
+  const torrent = torrentOf({ length: 1000 });
+  try {
+    applyPriorityMap.call(null, torrent, 0, [
+      { from: 0, to: 100, priority: 5 },
+      { from: 100, to: 200, priority: 3 }
+    ], 200);
+
+    const { register } = demandFor(torrent);
+    const stated = register.windows().filter((one) => String(one.claimant).startsWith("priority-map:"));
+    assert.equal(stated.length, 2);
+    const first = stated.find((one) => one.byteStart === 0);
+    assert.equal(first.byteEnd, 499, "half the film is half the file");
+    const second = stated.find((one) => one.byteStart === 500);
+    assert.equal(second.byteEnd, 999, "the last byte of the file, not one past it");
+  } finally {
+    forgetTorrent(torrent);
+  }
+});
+
+test("a zone is stated at the level it means, not at the level of its position", () => {
+  const torrent = torrentOf();
+  try {
+    // A viewer 300 s into a 3000 s film: one band behind them that nobody is
+    // approaching, then bands of decreasing urgency ahead.
+    const zones = mapForViewer({
+      atSeconds: 300,
+      durationSeconds: 3000,
+      allowanceSeconds: 10
+    });
+    assert.ok(zones.length > 5, "the map should be finer than the register's levels");
+
+    applyPriorityMap.call(null, torrent, 0, zones, 3000);
+    const { register } = demandFor(torrent);
+    const stated = register.windows().filter((one) => String(one.claimant).startsWith("priority-map:"));
+
+    const near = stated.filter((one) => one.urgency === Urgency.NEAR);
+    assert.equal(near.length, 1, "exactly one band is where the viewer is");
+    assert.equal(near[0].byteStart, Math.floor((300 / 3000) * 1_000_000));
+
+    const behind = stated.filter((one) => one.urgency === Urgency.BEHIND);
+    assert.equal(behind.length, 1, "what nobody is approaching is the one thing wanted last");
+    assert.equal(behind[0].byteStart, 0, "and it is the stretch behind the viewer");
+
+    assert.ok(
+      stated.some((one) => one.urgency === Urgency.AHEAD),
+      "the lead being built was stated at no level of its own"
+    );
+    assert.ok(
+      stated.every((one) => one.urgency !== Urgency.BLOCKED),
+      "the map claimed BLOCKED, which only a reader stopped on those bytes may say"
+    );
+  } finally {
+    forgetTorrent(torrent);
+  }
+});
+
+test("a viewer who has stopped the picture makes the whole film wanted last", () => {
+  const torrent = torrentOf();
+  try {
+    const zones = mapForViewer({
+      atSeconds: 300,
+      durationSeconds: 3000,
+      allowanceSeconds: 10,
+      playing: false
+    });
+    applyPriorityMap.call(null, torrent, 0, zones, 3000);
+
+    const { register } = demandFor(torrent);
+    const stated = register.windows().filter((one) => String(one.claimant).startsWith("priority-map:"));
+    assert.equal(stated.length, 1, "a viewer going nowhere makes one band of the whole film");
+    // Wanted last ABSOLUTELY, not relative to this film's own map. The two
+    // speculative levels are withheld across every torrent at once while
+    // anything urgent is missing anywhere, so this has to lose to a film
+    // somebody is actually watching — and judged against itself alone it would
+    // be the most urgent thing there is.
+    assert.equal(stated[0].urgency, Urgency.BEHIND);
+  } finally {
+    forgetTorrent(torrent);
+  }
+});
+
+test("a map with fewer bands than the last one leaves nothing stated behind", () => {
+  const torrent = torrentOf();
+  try {
+    applyPriorityMap.call(null, torrent, 0, [
+      { from: 0, to: 100, priority: 5 },
+      { from: 100, to: 200, priority: 4 },
+      { from: 200, to: 300, priority: 3 }
+    ], 300);
+    const { register } = demandFor(torrent);
+    assert.equal(
+      register.windows().filter((one) => String(one.claimant).startsWith("priority-map:")).length,
+      3
+    );
+
+    applyPriorityMap.call(null, torrent, 0, [{ from: 0, to: 300, priority: 5 }], 300);
+    assert.equal(
+      register.windows().filter((one) => String(one.claimant).startsWith("priority-map:")).length,
+      1,
+      "bands the map no longer has went on being asked for"
+    );
+  } finally {
+    forgetTorrent(torrent);
+  }
+});
+
+test("a file of unknown length or duration is not guessed at", () => {
+  const torrent = torrentOf();
+  try {
+    applyPriorityMap.call(null, torrent, 0, [{ from: 0, to: 100, priority: 5 }], 0);
+    applyPriorityMap.call(null, torrent, 7, [{ from: 0, to: 100, priority: 5 }], 300);
+    const { register } = demandFor(torrent);
+    assert.equal(
+      register.windows().filter((one) => String(one.claimant).startsWith("priority-map:")).length,
+      0
+    );
+  } finally {
+    forgetTorrent(torrent);
+  }
+});

package/test/priority-map.test.js

@@ -10,77 +10,6 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { mapForViewer, mergeMaps, inWorkingOrder } from "../services/priority/PriorityMap.js";
 
-test("a viewer's own position is the most urgent thing there is", () => {
-  const map = mapForViewer({
-    atSeconds: 100,
-    durationSeconds: 1000,
-    allowanceSeconds: 8,
-    encodeSpeedX: 2
-  });
-
-  assert.equal(map[0].from, 100);
-  assert.equal(map[0].to, 108, "above realtime, only the measured allowance");
-  for (const zone of map.slice(1)) {
-    assert.ok(zone.priority < map[0].priority);
-  }
-});
-
-test("a machine that cannot keep up needs more encoders, not a longer first zone", () => {
-  // An encoder starting where the viewer stands stays ahead of them for
-  // `held x s / (1 - s)`, so the SLOWER the machine the shorter that is — and
-  // the film is held by more encoders rather than by one working further.
-  const slow = mapForViewer({
-    atSeconds: 0,
-    durationSeconds: 1000,
-    allowanceSeconds: 10,
-    encodeSpeedX: 0.25
-  });
-  const quicker = mapForViewer({
-    atSeconds: 0,
-    durationSeconds: 1000,
-    allowanceSeconds: 10,
-    encodeSpeedX: 0.5
-  });
-
-  assert.ok(
-    slow[0].to - slow[0].from < quicker[0].to - quicker[0].from,
-    "the slower machine holds the viewer for less"
-  );
-  assert.ok(slow.length > quicker.length, "so more encoders are needed to hold the film");
-});
-
-test("the first zone is exactly what one encoder can hold", () => {
-  // `held x s / (1 - s)`: ten seconds held at half speed is ten seconds held,
-  // and the encoder is caught exactly there. A longer first zone would stall
-  // the viewer inside it; a shorter one would start the next encoder nearer,
-  // where its own bound is tighter.
-  const map = mapForViewer({
-    atSeconds: 0,
-    durationSeconds: 100,
-    allowanceSeconds: 10,
-    encodeSpeedX: 0.5
-  });
-
-  assert.equal(map[0].to, 10);
-  assert.equal(map[1].to, 30, "the next holds three times as long, because they arrive later");
-  assert.equal(map[2].to, 70);
-});
-
-test("a viewer holding nothing is told the whole of it is urgent", () => {
-  // With nothing held, no partition holds them: the first encoder stays ahead
-  // for zero seconds. Slicing the film into equal slivers would pretend
-  // otherwise.
-  const map = mapForViewer({
-    atSeconds: 0,
-    durationSeconds: 1000,
-    allowanceSeconds: 0,
-    encodeSpeedX: 0.25
-  });
-
-  assert.equal(map.length, 1);
-  assert.equal(map[0].to, 1000);
-});
-
 test("the rest of the track is still wanted, and wanted last", () => {
   const map = mapForViewer({ atSeconds: 0, durationSeconds: 1000, allowanceSeconds: 4, encodeSpeedX: 2 });
 
@@ -93,12 +22,6 @@ test("the rest of the track is still wanted, and wanted last", () => {
   }
 });
 
-test("nothing is measured yet: the middle zone is left out rather than invented", () => {
-  const map = mapForViewer({ atSeconds: 0, durationSeconds: 100, allowanceSeconds: 4, encodeSpeedX: 0 });
-
-  assert.equal(map.length, 2, "what must be ready, and the rest");
-});
-
 test("two viewers merge to the highest priority per second, with no overlaps", () => {
   const first = mapForViewer({ atSeconds: 0, durationSeconds: 1000, allowanceSeconds: 8, encodeSpeedX: 2 });
   const second = mapForViewer({ atSeconds: 500, durationSeconds: 1000, allowanceSeconds: 8, encodeSpeedX: 2 });
@@ -137,3 +60,53 @@ test("within one priority the earliest film goes first — that is where somebod
 
   assert.deepEqual(order.map((zone) => zone.from), [0, 100, 900]);
 });
+
+test("the nearer a viewer is to a second, the higher its number", () => {
+  // The number is a reading of how far they still have to travel, and nothing
+  // else. That is what makes two viewers comparable at all.
+  const map = mapForViewer({ atSeconds: 300, durationSeconds: 3000, allowanceSeconds: 10 });
+  const ahead = map.filter((zone) => zone.from >= 300);
+
+  assert.equal(ahead[0].from, 300, "it starts where they are");
+  assert.equal(ahead[0].to, 310, "and the first band is the measured allowance");
+  for (let index = 1; index < ahead.length; index += 1) {
+    assert.ok(ahead[index].priority < ahead[index - 1].priority, "further off is less urgent");
+  }
+});
+
+test("the bands widen, so any film is described by a handful of them", () => {
+  // Near the viewer the difference between now and ten seconds away decides
+  // what is made first; twenty minutes out it changes nothing.
+  const map = mapForViewer({ atSeconds: 0, durationSeconds: 3000, allowanceSeconds: 10 });
+
+  assert.ok(map.length <= 12, `a fifty-minute film in ${map.length} bands`);
+  assert.equal(map[0].to - map[0].from, 10);
+  assert.equal(map[1].to - map[1].from, 20);
+  assert.equal(map[2].to - map[2].from, 40);
+});
+
+test("what is behind a viewer is wanted, and wanted last", () => {
+  const map = mapForViewer({ atSeconds: 300, durationSeconds: 3000, allowanceSeconds: 10 });
+  const behind = map.find((zone) => zone.from === 0);
+
+  assert.ok(behind, "it is still in the map");
+  assert.equal(behind.to, 300);
+  assert.ok(
+    map.filter((zone) => zone.from >= 300).every((zone) => zone.priority > behind.priority),
+    "and everything anybody is approaching outranks it"
+  );
+});
+
+test("a viewer who has stopped the picture is going nowhere", () => {
+  // Nothing is nearer to them than anything else, so nothing in the film is
+  // wanted sooner than the rest — and the work goes to whoever is watching.
+  const map = mapForViewer({
+    atSeconds: 300,
+    durationSeconds: 3000,
+    allowanceSeconds: 10,
+    playing: false
+  });
+
+  assert.equal(map.length, 1);
+  assert.deepEqual({ from: map[0].from, to: map[0].to }, { from: 0, to: 3000 });
+});

package/test/read-window.test.js

@@ -8,9 +8,17 @@
  * seeks. Nothing after that could outrank it: measured on a 4.7 GB film, a seek
  * to 89.1% waited 93 s while the swarm fetched 2.47 GB in file order.
  *
- * Now a read holds a moving window and returns it when it ends. These tests pin
- * the three properties that matter: the claim is bounded, it is given back, and
- * several readers add up instead of overwriting each other.
+ * Now a read claims only the piece it is STOPPED on, and gives it back when it
+ * ends. What should be downloaded ahead of a viewer is the priority map's
+ * answer, stated once for the whole file by the side that knows where the
+ * viewers are; a read is consumption, not a forecast. Fifteen reads on one file
+ * used to declare fifteen windows on a piece store holding sixteen pieces, and
+ * half of all evictions then took a piece a reader had declared (field
+ * 2026-09-05).
+ *
+ * These tests pin what is left: a read that is not stopped claims nothing, a
+ * read that is stopped claims the pieces it is waiting for and nothing beyond
+ * them, and every claim is given back.
  */
 
 import test from "node:test";
@@ -119,12 +127,13 @@ test("the window is bounded and clamped to the end of the read", () => {
   );
 });
 
-test("an open-ended read does not claim the whole file at once", async () => {
-  // 8000 pieces of 1 KB — far more than the 32 MB window, so a read to the end
-  // of the file is exactly the ffmpeg case.
+test("a read that is not stopped claims nothing", async () => {
+  // 8000 pieces of 1 KB, every one of them present, and the read asks as ffmpeg
+  // does: to the last byte of the file. Nothing is missing, so this read is
+  // waiting for nothing, so it wants nothing of the swarm — what lies ahead of
+  // it belongs to the priority map.
   const { torrent, store, directory } = await recordingTorrent({ pieceCount: 8000 });
   try {
-    // Read only the first two pieces, but ask as ffmpeg does: to the last byte.
     const iterator = readFragments({
       torrent,
       fileIndex: 0,
@@ -136,15 +145,11 @@ test("an open-ended read does not claim the whole file at once", async () => {
     const first = await iterator.next();
     first.value.release();
 
-    const selects = torrent.calls.filter((entry) => entry.call === "select");
-    assert.ok(selects.length >= 1, "the reader claimed nothing");
-    const claimed = selects[0].to - selects[0].from + 1;
-    assert.equal(
-      claimed,
-      WINDOW_PIECES,
-      `the reader claimed ${claimed} pieces of the file instead of its window`
+    assert.deepEqual(
+      torrent.held,
+      [],
+      "the read declared a window of its own, which is the forecast that has to come from the map"
     );
-    assert.equal(selects[0].stream, true, "the claim must be a stream selection, so it can be counted");
 
     await iterator.return();
   } finally {
@@ -187,35 +192,47 @@ test("an abandoned read leaves nothing selected", async () => {
   }
 });
 
-test("two readers add up, and one leaving takes only its own", async () => {
-  const { torrent, store, directory } = await recordingTorrent({ pieceCount: 8000 });
+test("two stopped readers add up, and one leaving takes only its own", async () => {
+  // Nothing has arrived yet, so both readers are stopped on their first piece
+  // and each states it. Two claims, each withdrawn on its own.
+  let arrived = false;
+  const { torrent, store, directory } = await recordingTorrent({
+    pieceCount: 8000,
+    present: () => arrived
+  });
   try {
     const head = readFragments({
       torrent, fileIndex: 0, start: 0, end: 8000 * PIECE - 1,
-      cancellation: { isCancelled: () => false }
+      cancellation: { isCancelled: () => false },
+      windowBytes: WINDOW_PIECES * PIECE
     });
     const tail = readFragments({
       torrent, fileIndex: 0, start: 4000 * PIECE, end: 8000 * PIECE - 1,
-      cancellation: { isCancelled: () => false }
+      cancellation: { isCancelled: () => false },
+      windowBytes: WINDOW_PIECES * PIECE
     });
-    (await head.next()).value.release();
-    (await tail.next()).value.release();
+    const headPending = head.next();
+    const tailPending = tail.next();
+    await new Promise((resolve) => setImmediate(resolve));
 
-    // Not a count: each reader states several bands by level, and two readers
-    // wanting the same pieces are one instruction. What matters is that both
-    // are represented and that leaving removes only what leaving should.
     const pieceOf = (range) => Number(range.split("-")[0]);
     const held = [...torrent.held];
-    assert.ok(held.some((range) => pieceOf(range) < 4000), "the head reader holds nothing");
-    assert.ok(held.some((range) => pieceOf(range) >= 4000), "the tail reader holds nothing");
+    assert.ok(held.some((range) => pieceOf(range) < 4000), "the head reader claimed nothing");
+    assert.ok(held.some((range) => pieceOf(range) >= 4000), "the tail reader claimed nothing");
+
+    // Let both through to a yield, so ending them runs their `finally` at once.
+    arrived = true;
+    torrent.emit("verified", 0);
+    torrent.emit("verified", 4000);
+    (await headPending).value.release();
+    (await tailPending).value.release();
 
     await tail.return();
     const after = [...torrent.held];
     assert.ok(
-      after.some((range) => pieceOf(range) < 4000),
-      "the head reader's window went with the tail reader"
+      after.every((range) => pieceOf(range) < 4000),
+      "the tail reader left its claim behind"
     );
-    assert.ok(after.length < held.length, "the tail reader took nothing away when it left");
 
     await head.return();
     assert.deepEqual(torrent.held, [], "the last reader left something behind");

package/test/usrsctp-state.test.js

@@ -62,7 +62,7 @@ async function waitFor(check) {
   }
 }
 
-test("gdb is invoked attached to this process with the bundled script", async () => {
+test("the deadline is counted outside the process gdb stops", async () => {
   const { spawnProcess, calls } = makeSpawn("state=8 rwnd=95890\n");
   const lines = [];
   const reader = createUsrsctpStateReader({
@@ -74,7 +74,23 @@ test("gdb is invoked attached to this process with the bundled script", async ()
   assert.equal(started, true);
   await waitFor(() => lines.length > 0);
   assert.equal(calls.length, 1);
-  assert.deepEqual(calls[0].args, ["-q", "-batch", "-p", "4242", "-x", SCTPSTATE_SCRIPT_PATH]);
+  // `timeout` is a separate process, so it keeps counting while gdb holds every
+  // thread of this one. A `setTimeout` here cannot fire — measured in the field
+  // on 2026-09-05, where gdb held the proxy for four minutes and the guard set
+  // for fifteen seconds never ran.
+  assert.equal(calls[0].command, "timeout");
+  assert.deepEqual(calls[0].args, [
+    "-s",
+    "KILL",
+    "15",
+    "gdb",
+    "-q",
+    "-batch",
+    "-p",
+    "4242",
+    "-x",
+    SCTPSTATE_SCRIPT_PATH
+  ]);
   assert.match(lines[0], /state=8 rwnd=95890/);
   assert.match(lines[0], /test wedge/);
 });

package/test/read-bands.test.js

@@ -1,140 +0,0 @@
-/**
- * @file Claiming what a reader wants in four bands instead of one.
- *
- * Until now a reader claimed one band at one urgency, and WebTorrent's own
- * whole-file selection sat under it at priority 0 — so "what the viewer reaches
- * in seconds" and "the rest of the film" were indistinguishable to the picker.
- * The bands separate them, and their widths come from what has been measured
- * about this file on this swarm rather than from numbers chosen here.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { bandWidthsFrom, bandsFrom, sameBands } from "../services/torrent-worker/piece-reader.js";
-import { Urgency } from "../services/demand/Urgency.js";
-
-const PIECE = 8 * 1024 * 1024;
-
-test("the urgent band is the one being read, and the lead bands come behind it in order", () => {
-  const bands = bandsFrom({
-    urgent: { from: 100, to: 103 },
-    pieceIndex: 100,
-    firstPiece: 0,
-    lastPiece: 1000,
-    widths: { near: 5, far: 20 }
-  });
-
-  assert.deepEqual(
-    bands,
-    [
-      { from: 100, to: 103, urgency: Urgency.NEAR },
-      { from: 104, to: 108, urgency: Urgency.AHEAD },
-      { from: 109, to: 128, urgency: Urgency.AHEAD }
-    ],
-    "no gap, no overlap, and each band strictly less urgent than the one in front"
-  );
-});
-
-test("no band is speculative while the reader is still walking the file", () => {
-  const bands = bandsFrom({
-    urgent: { from: 0, to: 1 },
-    pieceIndex: 0,
-    firstPiece: 0,
-    lastPiece: 100,
-    widths: { near: 2, far: 2 }
-  });
-
-  assert.ok(
-    bands.every((band) => band.urgency <= Urgency.AHEAD),
-    "a band at 0 would be indistinguishable from the background fill of the whole torrent"
-  );
-});
-
-test("what was never downloaded behind the viewer is not asked for until the lead reaches the end", () => {
-  const stillFilling = bandsFrom({
-    urgent: { from: 50, to: 52 },
-    pieceIndex: 50,
-    firstPiece: 0,
-    lastPiece: 1000,
-    widths: { near: 4, far: 8 }
-  });
-  assert.equal(
-    stillFilling.length,
-    3,
-    "the film ahead is not covered yet, so the past must not compete with it"
-  );
-
-  const covered = bandsFrom({
-    urgent: { from: 50, to: 52 },
-    pieceIndex: 50,
-    firstPiece: 0,
-    lastPiece: 60,
-    widths: { near: 4, far: 8 }
-  });
-  assert.deepEqual(
-    covered[covered.length - 1],
-    { from: 0, to: 49, urgency: Urgency.BEHIND },
-    "once there is nothing left ahead, the gap behind the viewer is worth filling"
-  );
-});
-
-test("a swarm with no surplus produces no far band, because there is nothing to get ahead with", () => {
-  const widths = bandWidthsFrom({
-    worstWaitSec: 2,
-    medianIntervalSec: 10,
-    downloadBytesPerSec: 1_000_000,
-    consumeBytesPerSec: 1_000_000,
-    pieceLength: PIECE,
-    basePieces: 4
-  });
-
-  assert.equal(widths.far, 0, "download rate equals consumption, so no lead can be built");
-  assert.equal(widths.measured, true);
-});
-
-test("the near band covers the worst interruption this reader has actually met", () => {
-  // 4 s of a film eaten at 2 MB/s is 8 MB, which is one piece here.
-  const widths = bandWidthsFrom({
-    worstWaitSec: 4,
-    medianIntervalSec: 30,
-    downloadBytesPerSec: 3_000_000,
-    consumeBytesPerSec: 2_000_000,
-    pieceLength: PIECE,
-    basePieces: 4
-  });
-
-  assert.equal(widths.near, 1, "worst wait × consumption, in pieces");
-  // A surplus of 1 MB/s held for 30 s is 30 MB, which is four pieces here.
-  assert.equal(widths.far, 4, "surplus × the interval it usually runs for, in pieces");
-});
-
-test("with nothing measured yet both lead bands fall back to the reader's own window", () => {
-  const widths = bandWidthsFrom({
-    worstWaitSec: null,
-    medianIntervalSec: null,
-    downloadBytesPerSec: 5_000_000,
-    consumeBytesPerSec: 0,
-    pieceLength: PIECE,
-    basePieces: 6
-  });
-
-  assert.deepEqual(widths, { near: 6, far: 6, measured: false });
-});
-
-test("an unchanged claim is recognised, so it is not released and re-made on every read", () => {
-  const bands = [
-    { from: 1, to: 2, urgency: Urgency.NEAR },
-    { from: 3, to: 9, urgency: Urgency.AHEAD }
-  ];
-
-  assert.equal(sameBands(bands, [...bands.map((band) => ({ ...band }))]), true);
-  assert.equal(sameBands(bands, [{ from: 1, to: 2, urgency: Urgency.NEAR }]), false);
-  assert.equal(
-    sameBands(bands, [
-      { from: 1, to: 2, urgency: Urgency.NEAR },
-      { from: 3, to: 9, urgency: Urgency.BEHIND }
-    ]),
-    false,
-    "the same range at another urgency is a different claim"
-  );
-});