@torrent-tv/proxy 2.89.17 → 2.89.18

package/test/delivery-probe.test.js

@@ -1,382 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  allowedGap,
-  probeWedgeIsCertain,
-  readProbeState,
-  PROBE_INTERVAL_MS,
-  UNRELIABLE_LABEL
-} from "../services/transport/delivery-probe.js";
-
-const ORDERED = ["proxy", "proxy-control"];
-const ALL = [...ORDERED, UNRELIABLE_LABEL];
-
-/**
- * @param {Record<string, number>} seen
- * @param {object} [overrides]
- */
-function state(seen, overrides = {}) {
-  const allowed = {};
-  for (const label of overrides.labels ?? ALL) {
-    allowed[label] = 3;
-  }
-  return {
-    seq: 100,
-    seen,
-    labels: ALL,
-    echoes: 5,
-    echoAgeMs: 400,
-    allowed,
-    ...overrides
-  };
-}
-
-test("every channel current reads as flowing", () => {
-  const { verdict } = readProbeState(state({ proxy: 100, "proxy-control": 99, "proxy-fast": 100 }));
-  assert.equal(verdict, "flowing");
-});
-
-test("a lag shorter than the verdict window is still flowing", () => {
-  const behind = 100 - 3;
-  const { verdict } = readProbeState(
-    state({ proxy: behind, "proxy-control": behind, "proxy-fast": 100 })
-  );
-  assert.equal(verdict, "flowing");
-});
-
-test("ordered channels behind while the unordered one keeps up names a stuck stream", () => {
-  const { verdict, detail } = readProbeState(
-    state({ proxy: 40, "proxy-control": 41, "proxy-fast": 100 })
-  );
-  assert.equal(verdict, "stream-stuck");
-  // The numbers that produced the verdict must be in the line beside it.
-  assert.match(detail, /proxy=40\(gap 60 of 3\)/);
-});
-
-test("every channel behind names the association", () => {
-  const { verdict } = readProbeState(
-    state({ proxy: 40, "proxy-control": 41, "proxy-fast": 42 })
-  );
-  assert.equal(verdict, "association-stopped");
-});
-
-test("without the unordered channel the verdict says it cannot compare", () => {
-  const { verdict } = readProbeState(
-    state({ proxy: 40, "proxy-control": 41 }, { labels: ORDERED })
-  );
-  assert.equal(verdict, "ordered-behind-no-comparison");
-});
-
-test("a stale echo means the reverse direction went too", () => {
-  const { verdict } = readProbeState(
-    state({ proxy: 40, "proxy-control": 41, "proxy-fast": 42 }, { echoAgeMs: 30_000 })
-  );
-  assert.equal(verdict, "reverse-direction-gone");
-});
-
-test("before the first echo nothing is claimed", () => {
-  const { verdict } = readProbeState(state({}, { echoes: 0, echoAgeMs: null }));
-  assert.equal(verdict, "no-echo-yet");
-});
-
-test("a channel that has never reported counts as behind, not as unknown", () => {
-  const { verdict, detail } = readProbeState(
-    state({ "proxy-fast": 100 })
-  );
-  assert.equal(verdict, "stream-stuck");
-  assert.match(detail, /proxy=\?\(gap \? of 3\)/);
-});
-
-test("the allowance is the queue's own drain time, not a chosen number", () => {
-  // 8 MB queued at 8 MB/s is one second of draining; probes go twice a second,
-  // so two of them may legitimately be outstanding, plus the one sent after
-  // the peer composed its report, plus the round trip.
-  assert.equal(
-    allowedGap({ queuedBytes: 8 * 1024 * 1024, bytesPerSecond: 8 * 1024 * 1024, rttMs: 0 }),
-    Math.ceil(1000 / PROBE_INTERVAL_MS) + 1
-  );
-  // An empty queue still allows the one probe that is always in flight.
-  assert.equal(allowedGap({ queuedBytes: 0, bytesPerSecond: 8 * 1024 * 1024, rttMs: 0 }), 1);
-  // The round trip counts: the echo has to come back too.
-  assert.ok(
-    allowedGap({ queuedBytes: 0, bytesPerSecond: 1024, rttMs: 2000 }) >
-      allowedGap({ queuedBytes: 0, bytesPerSecond: 1024, rttMs: 0 })
-  );
-});
-
-test("with no rate measured nothing is claimed", () => {
-  assert.equal(allowedGap({ queuedBytes: 1024, bytesPerSecond: 0, rttMs: 10 }), null);
-  const { verdict } = readProbeState(
-    state({ proxy: 40, "proxy-control": 41, "proxy-fast": 42 }, { allowed: {} })
-  );
-  assert.equal(verdict, "no-rate-yet");
-});
-
-test("a burst big enough to explain the lag is not called a stopped association", () => {
-  // The 2026-08-26 false positive: all three channels at gap 7 while 150 Mbps
-  // crossed the association. 64 MB queued at 18 MB/s is three and a half
-  // seconds of draining, which is seven probe intervals.
-  const allowance = allowedGap({
-    queuedBytes: 64 * 1024 * 1024,
-    bytesPerSecond: 18 * 1024 * 1024,
-    rttMs: 16
-  });
-  assert.ok(allowance >= 7);
-  const allowed = Object.fromEntries(ALL.map((label) => [label, allowance]));
-  const { verdict } = readProbeState(
-    state({ proxy: 93, "proxy-control": 93, "proxy-fast": 93 }, { allowed })
-  );
-  assert.equal(verdict, "flowing");
-});
-
-test("the peer's own answering cadence counts toward the allowance", () => {
-  // Field case 2026-08-27: queues empty, 3.4 MB/s crossing, tab hidden so the
-  // browser echoed about once a second. Without the peer's cadence the
-  // allowance is the probe interval and the crossing — two probes — and every
-  // other line read `association-stopped`.
-  const withoutCadence = allowedGap({
-    queuedBytes: 0,
-    bytesPerSecond: 3.4 * 1024 * 1024,
-    rttMs: 9
-  });
-  assert.equal(withoutCadence, 2);
-  const withCadence = allowedGap({
-    queuedBytes: 0,
-    bytesPerSecond: 3.4 * 1024 * 1024,
-    rttMs: 9,
-    echoIntervalMs: 1000
-  });
-  assert.ok(withCadence >= 3, `a second of cadence must allow more than ${withCadence}`);
-  const allowed = Object.fromEntries(ALL.map((label) => [label, withCadence]));
-  const { verdict } = readProbeState(
-    state({ proxy: 98, "proxy-control": 98, "proxy-fast": 98 }, { allowed, echoAgeMs: 977 })
-  );
-  assert.equal(verdict, "flowing");
-});
-
-test("a stale echo is judged against the peer's cadence, not a fixed half second", () => {
-  // The same numbers with the cadence unknown must still be able to say the
-  // reverse direction is gone — the bound rises with the cadence, it does not
-  // disappear.
-  const { verdict } = readProbeState(
-    state({ proxy: 99, "proxy-control": 99, "proxy-fast": 99 }, { echoAgeMs: 60_000, echoStaleMs: 2000 })
-  );
-  assert.equal(verdict, "reverse-direction-gone");
-});
-
-test("bytes still arriving outrank the probe gaps — the cushion fill is not a wedge", () => {
-  // The field shape of 2026-08-28: every queue at 0 B, so the allowance is
-  // small, the probes are far behind because the browser is busy pulling two
-  // minutes of film, and the association is perfectly healthy. Before the peer's
-  // own byte counter was consulted this read as `association-stopped`, four
-  // times in the first two minutes of a session nobody was troubled by.
-  const state = {
-    seq: 88,
-    seen: { proxy: 78, "proxy-control": 78, "proxy-fast": 78 },
-    labels: ["proxy", "proxy-control", "proxy-fast"],
-    echoes: 40,
-    echoAgeMs: 1305,
-    allowed: { proxy: 9, "proxy-control": 9, "proxy-fast": 9 },
-    echoStaleMs: 6000,
-    peerBytesAdvancing: true
-  };
-  const reading = readProbeState(state);
-  assert.equal(reading.verdict, "flowing");
-  assert.match(reading.detail, /peerBytes=advancing/);
-});
-
-test("the same gaps with the peer's counter STILL are the wedge", () => {
-  // One field changes, and it is the one that says whether anything is
-  // arriving. This is the shape of a real freeze: probes behind, and the far
-  // end receiving nothing.
-  const reading = readProbeState({
-    seq: 88,
-    seen: { proxy: 78, "proxy-control": 78, "proxy-fast": 78 },
-    labels: ["proxy", "proxy-control", "proxy-fast"],
-    echoes: 40,
-    echoAgeMs: 1305,
-    allowed: { proxy: 9, "proxy-control": 9, "proxy-fast": 9 },
-    echoStaleMs: 6000,
-    peerBytesAdvancing: false
-  });
-  assert.equal(reading.verdict, "association-stopped");
-  assert.match(reading.detail, /peerBytes=still/);
-});
-
-test("a browser that does not report its bytes is judged as before", () => {
-  // The term says nothing rather than guessing, and the rule falls back.
-  const reading = readProbeState({
-    seq: 88,
-    seen: { proxy: 78, "proxy-control": 78, "proxy-fast": 78 },
-    labels: ["proxy", "proxy-control", "proxy-fast"],
-    echoes: 40,
-    echoAgeMs: 1305,
-    allowed: { proxy: 9, "proxy-control": 9, "proxy-fast": 9 },
-    echoStaleMs: 6000,
-    peerBytesAdvancing: null
-  });
-  assert.equal(reading.verdict, "association-stopped");
-  assert.doesNotMatch(reading.detail, /peerBytes=/);
-});
-
-test("a frozen tab's own event-loop delay counts toward the allowance", () => {
-  // Field case 2026-09-03, session 03f211b8. The viewer paused at 15:24:21 with
-  // 121.5 s buffered; the tab went hidden at 15:24:35 and its event loop fell
-  // behind — loopLag 681 → 1881 → 4297 → 5957 ms. At 15:26:05 the probes read
-  // `gap 12 of 11` and printed `association-stopped`, the ring files were kept
-  // and a 180 s capture was taken; seven seconds later the same connection read
-  // `flowing`. Nothing had stopped: the browser simply could not run the timer
-  // that answers a probe.
-  // The line printed `gap 12 of 11`; the queue was empty and the round trip
-  // 162 ms, so the cadence term is whatever made the allowance 11. The probe
-  // interval, added to the allowance on 2026-10-04, makes the same figures 12.
-  const measured = {
-    queuedBytes: 0,
-    bytesPerSecond: 300,
-    rttMs: 162,
-    echoIntervalMs: 5000
-  };
-  const withoutLag = allowedGap(measured);
-  const withLag = allowedGap({ ...measured, peerLoopLagMs: 1881 });
-  assert.equal(withoutLag, 12, `11 in the field plus the probe interval, not ${withoutLag}`);
-  assert.ok(withLag > 12, `a gap of 12 must fit inside ${withLag}`);
-  const allowed = Object.fromEntries(ALL.map((label) => [label, withLag]));
-  const { verdict, detail } = readProbeState(
-    state(
-      { proxy: 9547, "proxy-control": 9547, "proxy-fast": 9547 },
-      {
-        seq: 9559,
-        allowed,
-        echoAgeMs: 5963,
-        echoStaleMs: 11 * PROBE_INTERVAL_MS + 162 + 5000 + 1881,
-        peerBytesAdvancing: false,
-        peerLoopLagMs: 1881,
-        peerVisibility: "hidden"
-      }
-    )
-  );
-  assert.equal(verdict, "flowing");
-  assert.match(detail, /peerLoopLag=1881ms/);
-  assert.match(detail, /peerTab=hidden/);
-});
-
-test("the peer's lag widens the bound on a stale echo without removing it", () => {
-  // The same term must not make `reverse-direction-gone` unreachable: a peer
-  // that has genuinely gone silent is still silent for far longer than its own
-  // loop delay explains.
-  const { verdict } = readProbeState(
-    state(
-      { proxy: 99, "proxy-control": 99, "proxy-fast": 99 },
-      {
-        echoAgeMs: 120_000,
-        echoStaleMs: 5500 + 162 + 1000 + 4297,
-        peerLoopLagMs: 4297,
-        peerVisibility: "hidden"
-      }
-    )
-  );
-  assert.equal(verdict, "reverse-direction-gone");
-});
-
-test("a peer that reports no loop delay is judged exactly as before", () => {
-  const reading = readProbeState(
-    state({ proxy: 90, "proxy-control": 90, "proxy-fast": 90 }, { peerBytesAdvancing: false })
-  );
-  assert.equal(reading.verdict, "association-stopped");
-  assert.doesNotMatch(reading.detail, /peerLoopLag=/);
-  assert.doesNotMatch(reading.detail, /peerTab=/);
-});
-
-test("a quiet stretch shorter than a legitimate report is not a wedge", () => {
-  // Field 2026-09-11: two captures of 180 s each, triggered at `wedged 1s` and
-  // `wedged 2s`, on a connection with `rtt=5ms`, every queue at 0 B and the
-  // viewer watching. In its first minutes a connection has shown no healthy gap
-  // at all, and the floor under "longer than anything healthy" was a single
-  // probe interval — 500 ms — so any quiet moment beat it.
-  // Both cadences plus the crossing: a probe sent just after the peer composed
-  // a report shows up only in the next one.
-  const legitimateReportMs = 500 + 500 + 12 + 0;
-  assert.equal(
-    probeWedgeIsCertain({ stuckForMs: 1000, longestHealthySeenGapMs: 0, legitimateReportMs }).isCertain,
-    false,
-    "a second of quiet is shorter than one legitimate report and says nothing"
-  );
-  // And what the detector exists for is untouched: a counter frozen for
-  // minutes is far past any report this connection could legitimately owe.
-  assert.equal(
-    probeWedgeIsCertain({ stuckForMs: 60_000, longestHealthySeenGapMs: 0, legitimateReportMs }).isCertain,
-    true
-  );
-  // A peer whose event loop is late is owed that time as well.
-  assert.equal(
-    probeWedgeIsCertain({
-      stuckForMs: 3000,
-      longestHealthySeenGapMs: 0,
-      legitimateReportMs: 500 + 12 + 5000
-    }).isCertain,
-    false,
-    "a peer frozen for five seconds cannot answer sooner than that"
-  );
-});
-
-test("what is behind is judged in time, not in probes", () => {
-  // The same probe goes down every channel including the one carrying the film,
-  // and SCTP schedules per association — so a probe waits behind queued video
-  // exactly as a segment does. Counting outstanding probes therefore measures
-  // the queue, not the association, which is why the count is only printed now.
-  const behind = { proxy: 800, "proxy-control": 800, "proxy-fast": 800 };
-  const mayWait = { proxy: 2000, "proxy-control": 2000, "proxy-fast": 2000 };
-
-  // Far behind in probes, well within the time its own queue is allowed.
-  const healthy = readProbeState(
-    state(
-      { proxy: 40, "proxy-control": 41, "proxy-fast": 42 },
-      { behindMs: behind, allowedWaitMs: mayWait }
-    )
-  );
-  assert.equal(healthy.verdict, "flowing");
-  assert.match(healthy.detail, /800ms of 2000ms/, "both readings belong in the line");
-
-  // The same gaps, the same allowance, and the probe is older than the queue
-  // could account for: that is the association and not the burst.
-  const wedged = readProbeState(
-    state(
-      { proxy: 40, "proxy-control": 41, "proxy-fast": 42 },
-      {
-        behindMs: { proxy: 9000, "proxy-control": 9000, "proxy-fast": 9000 },
-        allowedWaitMs: mayWait
-      }
-    )
-  );
-  assert.equal(wedged.verdict, "association-stopped");
-});
-
-test("with no send time recorded the count still decides", () => {
-  // A probe older than the history kept, or a connection that has just begun:
-  // the reading is absent rather than wrong, and the old comparison stands.
-  const { verdict } = readProbeState(
-    state({ proxy: 40, "proxy-control": 41, "proxy-fast": 42 }, { behindMs: {}, allowedWaitMs: {} })
-  );
-  assert.equal(verdict, "association-stopped");
-});
-
-test("a one-way delay of a probe that arrived says nothing about one that did not", () => {
-  // Field 2026-09-28, 10b53a7e: probe 1464 had taken 9 ms, and for the whole
-  // wedge it stayed the newest the peer had seen. A one-way figure in the
-  // state is not read: the age of that probe decides.
-  const { verdict } = readProbeState(
-    state(
-      { proxy: 1464, "proxy-control": 1464, "proxy-fast": 1464 },
-      {
-        seq: 1526,
-        behindMs: { proxy: 30_600, "proxy-control": 30_600, "proxy-fast": 30_600 },
-        allowedWaitMs: { proxy: 1029, "proxy-control": 1029, "proxy-fast": 1029 },
-        oneWayMs: { proxy: 9, "proxy-control": 9, "proxy-fast": 9 },
-        allowedOneWayMs: { proxy: 13, "proxy-control": 13, "proxy-fast": 13 },
-        peerBytesAdvancing: false
-      }
-    )
-  );
-  assert.equal(verdict, "association-stopped");
-});

package/test/demand-register.test.js

@@ -1,206 +0,0 @@
-/**
- * @file What is wanted, by whom, and how urgently.
- *
- * These are the rules the download layer and the memory store both read, so a
- * defect here is a defect in two places at once. Everything is numbers: no
- * torrent, no library, no piece store.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { DemandRegister } from "../services/torrent/demand/DemandRegister.js";
-import { unionOf, Window } from "../services/torrent/demand/Window.js";
-import {
-  isConditional,
-  mayDisplaceSlowPeer,
-  selectionPriority,
-  Urgency
-} from "../services/torrent/demand/Urgency.js";
-import { nearestFirst, piecesNeededFor, piecesOf, piecesWithin } from "../services/torrent/demand/pieces.js";
-
-const MEGABYTE = 1024 * 1024;
-
-test("a window states bytes and refuses what it cannot mean", () => {
-  const window = new Window({
-    claimant: "video", fileIndex: 0, byteStart: 100, byteEnd: 199, urgency: Urgency.NEAR
-  });
-  assert.equal(window.byteLength, 100, "inclusive at both ends");
-
-  assert.throws(() => new Window({
-    claimant: "", fileIndex: 0, byteStart: 0, byteEnd: 1, urgency: 0
-  }), /claimant/, "a window nobody can release is a leak with a name missing");
-  assert.throws(() => new Window({
-    claimant: "video", fileIndex: 0, byteStart: 200, byteEnd: 100, urgency: 0
-  }), /Byte end/);
-  assert.throws(() => new Window({
-    claimant: "video", fileIndex: -1, byteStart: 0, byteEnd: 1, urgency: 0
-  }), /File index/);
-});
-
-test("windows of different files are never merged", () => {
-  const register = new DemandRegister();
-  register.state({ claimant: "a", fileIndex: 0, byteStart: 0, byteEnd: 99, urgency: Urgency.NEAR });
-  register.state({ claimant: "b", fileIndex: 1, byteStart: 0, byteEnd: 99, urgency: Urgency.NEAR });
-
-  // Byte 50 of file 0 and byte 50 of file 1 are different bytes. Two viewers on
-  // two episodes of one release is the ordinary case, not an edge one.
-  assert.deepEqual(register.union(), [
-    { byteStart: 0, byteEnd: 99 },
-    { byteStart: 0, byteEnd: 99 }
-  ]);
-  assert.deepEqual(register.files(), [0, 1]);
-});
-
-test("the union of overlapping windows is their union, not their sum", () => {
-  // Picture and sound are two readers of one file and their windows overlap by
-  // construction. Adding them would report a demand that is not there.
-  assert.deepEqual(
-    unionOf([
-      { byteStart: 0, byteEnd: 99 },
-      { byteStart: 50, byteEnd: 149 }
-    ]),
-    [{ byteStart: 0, byteEnd: 149 }]
-  );
-  // Touching ranges are one run: 0-99 and 100-199 have nothing between them.
-  assert.deepEqual(
-    unionOf([
-      { byteStart: 100, byteEnd: 199 },
-      { byteStart: 0, byteEnd: 99 }
-    ]),
-    [{ byteStart: 0, byteEnd: 199 }]
-  );
-  assert.deepEqual(
-    unionOf([
-      { byteStart: 0, byteEnd: 99 },
-      { byteStart: 200, byteEnd: 299 }
-    ]),
-    [{ byteStart: 0, byteEnd: 99 }, { byteStart: 200, byteEnd: 299 }],
-    "a gap between them is a gap"
-  );
-});
-
-test("a claimant states one window, and restating replaces it", () => {
-  const register = new DemandRegister();
-  register.state({ claimant: "video", fileIndex: 0, byteStart: 0, byteEnd: 99, urgency: Urgency.NEAR });
-  register.state({ claimant: "video", fileIndex: 0, byteStart: 100, byteEnd: 199, urgency: Urgency.NEAR });
-
-  // A reader walking a film restates its window many times a second. If those
-  // accumulated, the download set would be the whole file within a minute.
-  assert.equal(register.size, 1);
-  assert.deepEqual(register.union(0), [{ byteStart: 100, byteEnd: 199 }]);
-});
-
-test("a withdrawal names its own claimant and nothing else", () => {
-  const register = new DemandRegister();
-  register.state({ claimant: "video", fileIndex: 0, byteStart: 0, byteEnd: 99, urgency: Urgency.NEAR });
-  register.state({ claimant: "audio", fileIndex: 0, byteStart: 0, byteEnd: 99, urgency: Urgency.NEAR });
-
-  assert.equal(register.withdraw("audio"), true);
-  assert.equal(register.withdraw("audio"), false, "a second release withdraws nothing");
-  assert.equal(register.withdraw("nobody"), false, "a stray release matches nothing");
-  assert.equal(register.size, 1, "and video still wants what it wanted");
-});
-
-test("the speculative levels are stated only while nothing urgent is missing", () => {
-  const register = new DemandRegister();
-  register.state({ claimant: "video", fileIndex: 0, byteStart: 0, byteEnd: 99, urgency: Urgency.BLOCKED });
-  register.state({ claimant: "fill", fileIndex: 0, byteStart: 1000, byteEnd: 9999, urgency: Urgency.TAIL });
-  register.state({ claimant: "back", fileIndex: 0, byteStart: 0, byteEnd: 999, urgency: Urgency.BEHIND });
-
-  // Something urgent is missing: the speculative levels are not stated at all.
-  // Withdrawn, not lowered — a withdrawn window is not in the download set, so
-  // a peer with nothing urgent to give cannot fall through to it and spend the
-  // shared link on a piece nobody is waiting for.
-  assert.deepEqual(
-    register.levelsToState((window) => window.urgency !== Urgency.BLOCKED),
-    [Urgency.BLOCKED, Urgency.NEAR, Urgency.AHEAD]
-  );
-
-  // Everything urgent has arrived: they are stated, in order.
-  assert.deepEqual(
-    register.levelsToState(() => true),
-    [Urgency.BLOCKED, Urgency.NEAR, Urgency.AHEAD, Urgency.TAIL, Urgency.BEHIND]
-  );
-
-  // The tail is complete but the gap behind is not: the gap stays stated and
-  // nothing below it exists to withhold.
-  assert.deepEqual(
-    register.levelsToState((window) => window.urgency !== Urgency.BEHIND),
-    [Urgency.BLOCKED, Urgency.NEAR, Urgency.AHEAD, Urgency.TAIL, Urgency.BEHIND]
-  );
-});
-
-test("only the level being waited on may take a block from a slow peer", () => {
-  assert.equal(mayDisplaceSlowPeer(Urgency.BLOCKED), true);
-  for (const urgency of [Urgency.NEAR, Urgency.AHEAD, Urgency.TAIL, Urgency.BEHIND]) {
-    assert.equal(mayDisplaceSlowPeer(urgency), false);
-  }
-});
-
-test("the library is given the only distinction it keeps", () => {
-  // Measured against the vendored 2.8.5: distinct non-zero priorities order the
-  // selection list once and are round-robined afterwards by `shufflePriority`.
-  // Zero is the only value that stays put, always last.
-  assert.equal(selectionPriority(Urgency.BLOCKED), 1);
-  assert.equal(selectionPriority(Urgency.NEAR), 1);
-  assert.equal(selectionPriority(Urgency.AHEAD), 1);
-  assert.equal(selectionPriority(Urgency.TAIL), 0);
-  assert.equal(selectionPriority(Urgency.BEHIND), 0);
-
-  assert.equal(isConditional(Urgency.AHEAD), false);
-  assert.equal(isConditional(Urgency.TAIL), true);
-});
-
-test("bytes become pieces in one place, and a partial piece is a whole piece", () => {
-  const pieceLength = 4 * MEGABYTE;
-  // A file starting one piece into the torrent, wanting its first byte.
-  assert.deepEqual(
-    piecesOf({ fileOffset: pieceLength, byteStart: 0, byteEnd: 0, pieceLength }),
-    { from: 1, to: 1 }
-  );
-  // A range ending one byte into the next piece still needs that whole piece:
-  // the protocol delivers and verifies nothing smaller.
-  assert.deepEqual(
-    piecesOf({ fileOffset: 0, byteStart: 0, byteEnd: pieceLength, pieceLength }),
-    { from: 0, to: 1 }
-  );
-  assert.equal(piecesOf({ fileOffset: 0, byteStart: 10, byteEnd: 5, pieceLength }), null);
-  assert.equal(piecesOf({ fileOffset: 0, byteStart: 0, byteEnd: 1, pieceLength: 0 }), null);
-});
-
-test("a budget buys whole places, and a window needs one more than it measures", () => {
-  const pieceLength = 16 * MEGABYTE;
-  // The failure this rounding hid: 64 MB of allowance is four places, and two
-  // readers asking for 96 MB each want six. Counted in bytes the shortage is
-  // plain; counted in floored pieces it is not.
-  assert.equal(piecesWithin(64 * MEGABYTE, pieceLength), 4);
-  assert.equal(piecesNeededFor(96 * MEGABYTE, pieceLength), 7, "six, plus the one it can straddle");
-  assert.equal(piecesWithin(0, pieceLength), 0);
-  assert.equal(piecesNeededFor(0, pieceLength), 0);
-});
-
-test("the gap behind the playhead is stated nearest first", () => {
-  // WebTorrent walks a selection from its start upwards, so one claim over
-  // everything behind the viewer would be fetched from the beginning of the
-  // file — the end furthest from where a backward seek lands.
-  const ranges = nearestFirst({ byteStart: 0, byteEnd: 999, parts: 4 });
-  assert.equal(ranges.length, 4);
-  assert.equal(ranges[0].byteEnd, 999, "the part nearest the playhead comes first");
-  assert.equal(ranges[ranges.length - 1].byteStart, 0, "and the furthest comes last");
-  for (const range of ranges) {
-    assert.ok(range.byteStart <= range.byteEnd);
-  }
-  assert.deepEqual(nearestFirst({ byteStart: 10, byteEnd: 5, parts: 2 }), []);
-});
-
-test("a byte is as urgent as the most urgent thing that wants it", () => {
-  const register = new DemandRegister();
-  register.state({ claimant: "map:tail", fileIndex: 0, byteStart: 0, byteEnd: 999, urgency: Urgency.TAIL });
-  register.state({ claimant: "map:near", fileIndex: 0, byteStart: 400, byteEnd: 599, urgency: Urgency.NEAR });
-
-  assert.equal(register.urgencyAt(0, 100), Urgency.TAIL);
-  assert.equal(register.urgencyAt(0, 500), Urgency.NEAR, "the overlap took the less urgent of the two");
-  assert.equal(register.urgencyAt(0, 5000), null, "a byte nobody wants reported a level anyway");
-  assert.equal(register.urgencyAt(1, 500), null, "byte 500 of another file is not this byte");
-});

package/test/dht-bootstrap.test.js

@@ -1,72 +0,0 @@
-/**
- * @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/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), []);
-});