@torrent-tv/proxy 2.39.1 → 2.40.0

package/test/read-bands.test.js

@@ -0,0 +1,133 @@
+/**
+ * @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";
+
+const PIECE = 8 * 1024 * 1024;
+
+test("the urgent band keeps the highest priority, 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, priority: 4 },
+      { from: 104, to: 108, priority: 3 },
+      { from: 109, to: 128, priority: 2 }
+    ],
+    "no gap, no overlap, and each band strictly less urgent than the one in front"
+  );
+});
+
+test("no priority is zero, because the library's own whole-file fill sits there", () => {
+  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.priority > 0),
+    "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, priority: 1 },
+    "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, priority: 4 }, { from: 3, to: 9, priority: 3 }];
+
+  assert.equal(sameBands(bands, [...bands.map((band) => ({ ...band }))]), true);
+  assert.equal(sameBands(bands, [{ from: 1, to: 2, priority: 4 }]), false);
+  assert.equal(
+    sameBands(bands, [{ from: 1, to: 2, priority: 4 }, { from: 3, to: 9, priority: 2 }]),
+    false,
+    "the same range at another urgency is a different claim"
+  );
+});

package/test/tail-duplication.test.js

@@ -0,0 +1,123 @@
+/**
+ * @file Asking a second wire for the blocks a reader is still waiting on.
+ *
+ * Measured on a real swarm 2026-08-19: a blocked read's tail is 2-14 blocks of
+ * 512, and it sits on wires at 109-886 KB/s — above the 48 KB/s gate that
+ * WebTorrent's own `_hotswap` requires, so the library never duplicates them.
+ * The mechanism is the library's: free the reservation with `Piece.cancel` and
+ * leave the first request in flight, then ask a second wire through the
+ * library's own request path.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { duplicateTailFor } from "../services/torrent-worker/fastest-wires.js";
+
+/** A piece with `chunks` blocks, of which `missing` at the end are absent. */
+function piece(chunks, missing) {
+  const buffer = new Array(chunks);
+  for (let index = 0; index < chunks - missing; index += 1) {
+    buffer[index] = new Uint8Array(1);
+  }
+  const cancelled = [];
+  return {
+    _buffer: buffer,
+    _chunks: chunks,
+    cancel: (index) => cancelled.push(index),
+    cancelled
+  };
+}
+
+function wire({ speed = 500_000, has = true } = {}) {
+  return {
+    peerPieces: { get: () => has },
+    downloadSpeed: () => speed,
+    peerChoking: false,
+    destroyed: false,
+    requests: []
+  };
+}
+
+test("the missing blocks are freed and asked of a second wire", () => {
+  const target = piece(512, 3);
+  const placed = [];
+  const torrent = {
+    pieces: [target],
+    wires: [wire({ speed: 900_000 }), wire({ speed: 800_000 }), wire({ speed: 700_000 })],
+    _request: (wireAsked, index) => {
+      placed.push({ wireAsked, index });
+      return true;
+    }
+  };
+
+  const result = duplicateTailFor(torrent, 0);
+
+  assert.equal(result.missing, 3, "the tail is what is still absent from the piece");
+  assert.equal(result.duplicated, 3);
+  assert.deepEqual(target.cancelled, [509, 510, 511], "each block's reservation is freed first");
+  assert.equal(placed.length, 3, "and each is then asked of a wire through the library's own path");
+  assert.equal(placed[0].wireAsked, torrent.wires[0], "fastest wire first");
+});
+
+test("at most one duplicate per wire, however long the tail", () => {
+  const target = piece(512, 40);
+  const torrent = {
+    pieces: [target],
+    wires: [wire(), wire()],
+    _request: () => true
+  };
+
+  const result = duplicateTailFor(torrent, 0);
+
+  assert.equal(result.duplicated, 2, "two wires, two duplicates — the rest waits for the next attempt");
+  assert.equal(target.cancelled.length, 2, "and no reservation is freed that nobody was asked for");
+});
+
+test("a wire whose pipeline is full ends the attempt", () => {
+  const target = piece(512, 5);
+  const torrent = {
+    pieces: [target],
+    wires: [wire(), wire(), wire()],
+    // The library refuses when the wire already has as many requests as its
+    // measured speed justifies.
+    _request: () => false
+  };
+
+  const result = duplicateTailFor(torrent, 0);
+
+  assert.equal(result.duplicated, 0);
+  assert.equal(
+    target.cancelled.length,
+    1,
+    "only the block that was actually offered is freed; the rest keep their reservations"
+  );
+});
+
+test("a piece with nothing missing is left alone", () => {
+  const target = piece(4, 0);
+  const torrent = { pieces: [target], wires: [wire()], _request: () => true };
+
+  const result = duplicateTailFor(torrent, 0);
+
+  assert.equal(result.duplicated, 0);
+  assert.equal(result.missing, 0);
+  assert.equal(target.cancelled.length, 0);
+});
+
+test("with no wire holding the piece there is nothing to duplicate onto", () => {
+  const target = piece(8, 2);
+  const torrent = { pieces: [target], wires: [wire({ has: false })], _request: () => true };
+
+  const result = duplicateTailFor(torrent, 0);
+
+  assert.equal(result.wires, 0);
+  assert.equal(result.duplicated, 0);
+  assert.equal(target.cancelled.length, 0, "and no reservation is freed for nobody");
+});
+
+test("a completed piece is not touched", () => {
+  assert.deepEqual(
+    duplicateTailFor({ pieces: [null], wires: [wire()], _request: () => true }, 0),
+    { duplicated: 0, missing: 0, wires: 0 }
+  );
+});