@torrent-tv/proxy 2.89.16 → 2.89.18

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

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

package/test/swarm-selection.test.js

@@ -1,220 +0,0 @@
-/**
- * @file The one place that speaks to WebTorrent.
- *
- * Driven against a stub torrent shaped like the vendored 2.8.5: a selection
- * list it can be asked about, a bitfield saying what has arrived, and the
- * private `_select`/`_deselect` the real one exposes.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { DemandRegister } from "../services/torrent/demand/DemandRegister.js";
-import { Urgency } from "../services/torrent/demand/Urgency.js";
-import { SwarmSelection } from "../services/torrent/download/SwarmSelection.js";
-
-const PIECE = 1024;
-
-/**
- * @param {object} [params]
- * @param {number[]} [params.have] - Pieces that have arrived.
- * @param {number} [params.files] - How many files, each ten pieces long.
- * @returns {object}
- */
-function stubTorrent({ have = [], files = 1 } = {}) {
-  const arrived = new Set(have);
-  const items = [];
-  return {
-    pieceLength: PIECE,
-    store: null,
-    files: Array.from({ length: files }, (unused, index) => ({
-      offset: index * 10 * PIECE,
-      length: 10 * PIECE
-    })),
-    bitfield: { get: (index) => arrived.has(index) },
-    _critical: [],
-    _selections: { _items: items },
-    calls: { select: [], deselect: [], critical: [] },
-    _select(from, to, priority, notify, isStream) {
-      this.calls.select.push({ from, to, priority, isStream });
-      items.push({ from, to, priority });
-    },
-    _deselect(from, to) {
-      this.calls.deselect.push({ from, to });
-      const at = items.findIndex((item) => item.from === from && item.to === to);
-      if (at >= 0) {
-        items.splice(at, 1);
-      }
-    },
-    critical(from, to) {
-      this.calls.critical.push({ from, to });
-      for (let index = from; index <= to; index += 1) {
-        this._critical[index] = true;
-      }
-    },
-    /** Pretend the library dropped a satisfied selection, which it does. */
-    forget(from, to) {
-      const at = items.findIndex((item) => item.from === from && item.to === to);
-      if (at >= 0) {
-        items.splice(at, 1);
-      }
-    }
-  };
-}
-
-test("nothing is asked of the swarm until somebody states a need", () => {
-  const torrent = stubTorrent();
-  const selection = new SwarmSelection({ torrent, register: new DemandRegister() });
-
-  assert.deepEqual(selection.reconcile(), { stated: 0, withdrawn: 0 });
-  assert.equal(torrent.calls.select.length, 0);
-});
-
-test("two viewers of one film are two instructions, and both are urgent", () => {
-  const torrent = stubTorrent();
-  const register = new DemandRegister();
-  const selection = new SwarmSelection({ torrent, register });
-
-  // One stopped at the start, one stopped further in. Both pictures are still.
-  register.state({ claimant: "v1", fileIndex: 0, byteStart: 0, byteEnd: PIECE - 1, urgency: Urgency.BLOCKED });
-  register.state({ claimant: "v2", fileIndex: 0, byteStart: 5 * PIECE, byteEnd: 6 * PIECE - 1, urgency: Urgency.BLOCKED });
-  selection.reconcile();
-
-  assert.deepEqual(torrent.calls.select, [
-    { from: 0, to: 0, priority: 1, isStream: true },
-    { from: 5, to: 5, priority: 1, isStream: true }
-  ]);
-  // Both may take a block from a slow peer, and the mark spans both.
-  assert.deepEqual(torrent.calls.critical, [{ from: 0, to: 5 }]);
-});
-
-test("the same pieces wanted by two claimants are one instruction", () => {
-  const torrent = stubTorrent();
-  const register = new DemandRegister();
-  const selection = new SwarmSelection({ torrent, register });
-
-  // Picture and sound of one viewer read the same file and overlap.
-  register.state({ claimant: "video", fileIndex: 0, byteStart: 0, byteEnd: PIECE - 1, urgency: Urgency.NEAR });
-  register.state({ claimant: "audio", fileIndex: 0, byteStart: 0, byteEnd: PIECE - 1, urgency: Urgency.NEAR });
-  const first = selection.reconcile();
-
-  assert.equal(first.stated, 1, "one range, told once");
-  assert.equal(torrent.calls.select.length, 1);
-});
-
-test("the speculative levels are withdrawn whole the moment something urgent is missing", () => {
-  const torrent = stubTorrent({ have: [0] });
-  const register = new DemandRegister();
-  const selection = new SwarmSelection({ torrent, register });
-
-  register.state({ claimant: "video", fileIndex: 0, byteStart: 0, byteEnd: PIECE - 1, urgency: Urgency.NEAR });
-  register.state({ claimant: "fill", fileIndex: 0, byteStart: 5 * PIECE, byteEnd: 9 * PIECE - 1, urgency: Urgency.TAIL });
-  selection.reconcile();
-
-  assert.equal(selection.statedRanges().length, 2, "nothing urgent is missing, so the tail is stated");
-  assert.ok(torrent.calls.select.some((call) => call.priority === 0), "and it is stated as zero");
-
-  // The viewer moves on to a piece that has not arrived.
-  register.state({ claimant: "video", fileIndex: 0, byteStart: PIECE, byteEnd: 2 * PIECE - 1, urgency: Urgency.NEAR });
-  selection.reconcile();
-
-  assert.deepEqual(
-    selection.statedRanges().map((range) => range.priority),
-    [1],
-    "the tail is out of the download set entirely, not lowered — a peer with nothing urgent to give must not be able to fall through to it"
-  );
-  assert.ok(torrent.calls.deselect.length > 0);
-});
-
-test("a selection the library drops once satisfied is stated again", () => {
-  const torrent = stubTorrent();
-  const register = new DemandRegister();
-  const selection = new SwarmSelection({ torrent, register });
-
-  register.state({ claimant: "video", fileIndex: 0, byteStart: 0, byteEnd: PIECE - 1, urgency: Urgency.NEAR });
-  selection.reconcile();
-  assert.equal(torrent.calls.select.length, 1);
-
-  // Nothing changed: no second instruction.
-  selection.reconcile();
-  assert.equal(torrent.calls.select.length, 1);
-
-  // WebTorrent removes a selection once every piece in it has arrived, and says
-  // nothing about having done so. The window is still wanted.
-  torrent.forget(0, 0);
-  selection.reconcile();
-  assert.equal(torrent.calls.select.length, 2, "stated again, because the library had let it go");
-});
-
-test("a claimant that withdraws takes its instruction with it", () => {
-  const torrent = stubTorrent();
-  const register = new DemandRegister();
-  const selection = new SwarmSelection({ torrent, register });
-
-  register.state({ claimant: "video", fileIndex: 0, byteStart: 0, byteEnd: PIECE - 1, urgency: Urgency.BLOCKED });
-  selection.reconcile();
-  register.withdraw("video");
-  const after = selection.reconcile();
-
-  assert.equal(after.withdrawn, 1);
-  assert.equal(selection.statedRanges().length, 0);
-  // And the displacement mark goes with it: WebTorrent never clears it itself,
-  // so a reader walking a film would leave every piece of it marked.
-  assert.equal(torrent._critical.some((marked) => marked === true), false);
-});
-
-test("a window is bounded by its own file, so it cannot claim the next one", () => {
-  const torrent = stubTorrent({ files: 3 });
-  const register = new DemandRegister();
-  const selection = new SwarmSelection({ torrent, register });
-
-  // Asking past the end of file 1. File 1 occupies pieces 10-19.
-  register.state({
-    claimant: "video", fileIndex: 1, byteStart: 0, byteEnd: 100 * PIECE, urgency: Urgency.NEAR
-  });
-  selection.reconcile();
-
-  assert.deepEqual(torrent.calls.select, [{ from: 10, to: 19, priority: 1, isStream: true }]);
-});
-
-test("releasing everything leaves the library holding nothing of ours", () => {
-  const torrent = stubTorrent();
-  const register = new DemandRegister();
-  const selection = new SwarmSelection({ torrent, register });
-
-  register.state({ claimant: "video", fileIndex: 0, byteStart: 0, byteEnd: 3 * PIECE, urgency: Urgency.BLOCKED });
-  selection.reconcile();
-  selection.releaseAll();
-
-  assert.equal(torrent._selections._items.length, 0);
-  assert.equal(selection.statedRanges().length, 0);
-  assert.equal(torrent._critical.some((marked) => marked === true), false);
-});
-
-test("the store is told what will be read soon, from the same stated needs", () => {
-  const torrent = stubTorrent();
-  const protectedBy = new Map();
-  torrent.store = {
-    protectRange: (claimant, from, to) => protectedBy.set(claimant, `${from}-${to}`),
-    releaseProtection: (claimant) => protectedBy.delete(claimant)
-  };
-  const register = new DemandRegister();
-  const selection = new SwarmSelection({ torrent, register, findStore: () => torrent.store });
-
-  register.state({ claimant: "video", fileIndex: 0, byteStart: 0, byteEnd: PIECE - 1, urgency: Urgency.NEAR });
-  register.state({ claimant: "fill", fileIndex: 0, byteStart: 5 * PIECE, byteEnd: 9 * PIECE - 1, urgency: Urgency.TAIL });
-  selection.reconcile();
-
-  // One statement, two views of it. Until 2026-09-02 a reader said the same
-  // thing twice — once to the store for memory, once to the torrent for
-  // download — and a third piece of code read the first to rebuild the second.
-  assert.equal(protectedBy.get("video"), "0-0");
-  // But only the urgent levels: memory holds what will be READ soon, and the
-  // tail is fetched speculatively. Protecting it would push out a piece the
-  // decoder is about to want.
-  assert.equal(protectedBy.has("fill"), false);
-
-  register.withdraw("video");
-  selection.reconcile();
-  assert.equal(protectedBy.size, 0, "a reader that withdrew still held memory");
-});

package/test/tail-duplication.test.js

@@ -1,167 +0,0 @@
-/**
- * @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, 16);
-  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 piece still arriving normally is not duplicated at all", () => {
-  // Forty blocks outstanding is not a tail, it is a piece in transit. Asking
-  // for a second copy of it would spend the shared link on bytes that are
-  // already on their way — which is the whole difference between this and the
-  // 2-14 blocks a blocked reader was measured waiting on.
-  const target = piece(512, 40);
-  const torrent = {
-    pieces: [target],
-    wires: [wire(), wire()],
-    _request: () => true
-  };
-
-  const result = duplicateTailFor(torrent, 0);
-
-  assert.equal(result.duplicated, 0);
-  assert.equal(target.cancelled.length, 0, "and nothing is freed either");
-});
-
-test("a wire whose pipeline is full does not end the attempt", () => {
-  // Pipelines are per wire, so one wire being full says nothing about the next.
-  // This used to stop the whole pass on the first refusal, on the stated
-  // reasoning that the remaining wires were "no emptier" — an assumption about
-  // other peers' queues that nothing measures.
-  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,
-    3,
-    "every wire was offered a block; a freed reservation nobody took is handed to whoever asks next"
-  );
-});
-
-test("a refusal by one wire does not cost the block a faster wire would have taken", () => {
-  const target = piece(512, 3);
-  const placed = [];
-  const torrent = {
-    pieces: [target],
-    wires: [wire({ speed: 900_000 }), wire({ speed: 800_000 })],
-    _request: (wireAsked, index) => {
-      // The first wire is full; the second is not.
-      if (wireAsked === torrent.wires[0]) {
-        return false;
-      }
-      placed.push(index);
-      return true;
-    }
-  };
-
-  const result = duplicateTailFor(torrent, 0);
-
-  assert.equal(result.duplicated, 1);
-  assert.deepEqual(placed, [0], "the second wire was still asked");
-});
-
-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 }
-  );
-});