@torrent-tv/proxy 2.39.0 → 2.39.1

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.39.1
+
+- **Fix**: The block duplication of 2.39.0 is removed, because measured against what a viewer actually feels it never paid. 2.39.0 was shipped on a measurement of the median wait for a piece; the quantity that matters is the seconds the picture stands still, and measured on that (2026-08-19, a reader paced at the film's own byte rate with an eight-second lead, arms alternated per position) it is neutral at best and costly at worst. On a well-seeded film every arm read 67 MB in 59 s and stopped for at most 2.6 s — nothing to improve. With the download capped just above the film's rate, which is what a home line IS whenever the swarm can fill it, duplication made the picture stop for **28.8 s against 12.8 s** at one position and left the other unchanged: under one shared budget a duplicate spends the very bytes it is trying to go around. The regime where it could pay — several slow peers, each with capacity of its own — could not be reproduced: the thin-swarm candidate turned out to have no live swarm at all (4 peers, 179.5 s of a 209 s run spent stopped). A lever with no measured gain and a measured cost does not stay on by default. Narrowing the read window to the blocked piece was tried in the same experiment and is not shipped for the same reason: it was never better and reached **44.8 s against 12.8 s**. What stays is the measurement that decided it (`research/tail-duplication-2026-08-19.md`) and the `tail …` line from 2.38.1, which is what will say whether a real thin swarm ever behaves differently.
+
 ## 2.39.0
 
 - **New**: When a reader is blocked and nothing can be steered, the blocks it is still waiting on are asked of a second wire as well. WebTorrent reserves each block for exactly one wire, so once `Piece.reserve()` answers -1 the read ends when the holder of the last block delivers it, however fast the rest of the swarm is. The library's own `_hotswap` does exactly the right thing — `piece.cancel(block)` frees the reservation while the first request stays in flight — but only for a wire under 48 KB/s and twice as slow as the asker, and measured on a real swarm the tails a reader waits on sit at 109-886 KB/s. Peers the library rightly calls good, because for bulk downloading they are; the gate is about throughput across a torrent and knows nothing about a reader blocked on one piece now. Speed is not even what is wrong with them: two blocks — 32 KB — on a wire measured at 109 KB/s is 0.3 s of transfer, and that read waited 4.6 s, because the blocks are queued behind that wire's other work. **Measured against itself, same film, same positions, arms alternated, six pairs across two pacing rates: the median wait for a piece fell in all six — 39 %, 48 %, 68 %, 6 %, 50 % and 28 %.** In the one pair where the swarm had spare capacity throughout, the wait fell 7226→5174 ms and the lead the reader kept ended at +2.0 MB instead of +0.3 MB. Cost: one duplicate per candidate wire per attempt, about 3 % extra traffic, and only while a reader is blocked with every block already spoken for. The tail measurement added in 2.38.1 reports what it placed: `duplicated 14 blocks`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.39.0",
+  "version": "2.39.1",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

package/services/torrent-worker/fastest-wires.js

@@ -197,83 +197,3 @@ export function describePieceTail(torrent, pieceIndex) {
   outstanding.sort((left, right) => left.bytesPerSecond - right.bytesPerSecond);
   return { chunks, missing, outstanding };
 }
-
-/**
- * Ask a second wire for blocks the reader is still waiting on.
- *
- * WebTorrent reserves each block for exactly one wire, so once `Piece.reserve()`
- * answers -1 there is no request left to place and the read ends when the
- * holder of the last block delivers it — however fast the rest of the swarm is.
- * The library's own remedy is `_hotswap`, and it does precisely the right
- * thing: `piece.cancel(blockIndex)` frees the reservation while leaving the
- * first wire's request in flight, so a second wire can be asked for the same
- * block and whichever arrives first wins. What it will not do is apply that to
- * these tails. It is gated on speed — the held-up wire must be under 48 KB/s
- * (`3 * BLOCK_LENGTH`) and at least twice as slow as the asker — and measured
- * on a real swarm 2026-08-19, the tails a reader waits on sit at 109, 317 and
- * 870 KB/s. Peers the library rightly considers good, because for bulk
- * downloading they are; the gate is about throughput across a torrent and knows
- * nothing about a reader blocked on one piece now.
- *
- * Speed is not even what is wrong with them: two blocks — 32 KB — on a wire
- * measured at 109 KB/s is 0.3 s of transfer, and that read waited 4.6 s. The
- * blocks are not travelling slowly, they are queued behind that wire's other
- * work, which no average speed can show.
- *
- * The cost is bounded by the same measurement: the tails were 2 to 14 blocks of
- * 512, so 32 to 224 KB against the 8 MiB piece they hold up. At most one
- * duplicate is asked per candidate wire per call, and the caller repeats every
- * half second, so a longer tail is covered across attempts rather than in one
- * burst.
- *
- * Safe against the completion path: a block that arrives twice is dropped by
- * `Piece.set`, which writes only into an empty slot, and a piece already
- * flushed answers `false` from `Piece.init` so the second arrival returns
- * before `flush()` is reached.
- *
- * @param {object} torrent
- * @param {number} pieceIndex
- * @returns {{ duplicated: number, missing: number, wires: number }}
- *   `duplicated` counts requests the library actually placed for a block that
- *   was already outstanding elsewhere.
- */
-export function duplicateTailFor(torrent, pieceIndex) {
-  const piece = torrent?.pieces?.[pieceIndex];
-  const buffer = Array.isArray(piece?._buffer) ? piece._buffer : null;
-  if (!piece || !buffer || typeof piece.cancel !== "function") {
-    return { duplicated: 0, missing: 0, wires: 0 };
-  }
-  const chunks = Number.isFinite(piece._chunks) ? piece._chunks : buffer.length;
-  const missing = [];
-  for (let index = 0; index < chunks; index += 1) {
-    if (!buffer[index]) {
-      missing.push(index);
-    }
-  }
-  const candidates = wiresForPiece(torrent, pieceIndex);
-  if (missing.length === 0 || candidates.length === 0) {
-    return { duplicated: 0, missing: missing.length, wires: candidates.length };
-  }
-
-  let duplicated = 0;
-  // One block per wire: that is what the pipelines can usefully take at once,
-  // and it needs no number of its own.
-  for (let index = 0; index < Math.min(missing.length, candidates.length); index += 1) {
-    // Freeing the reservation is what makes the block askable again; the
-    // request already in flight is deliberately left alone, because the point
-    // is to have two of them.
-    piece.cancel(missing[index]);
-    // `false` is hotswap: the library's own swap must not run on top of this,
-    // or it would free a THIRD wire's block as well.
-    if (torrent._request(candidates[index], pieceIndex, false) === true) {
-      duplicated += 1;
-      continue;
-    }
-    // The wire's pipeline is full. The block stays in the piece's cancellation
-    // stack and will be handed to whoever asks next, which is harmless — it is
-    // already in flight elsewhere — but there is no point asking the remaining
-    // wires, whose pipelines are no emptier.
-    break;
-  }
-  return { duplicated, missing: missing.length, wires: candidates.length };
-}

package/services/torrent-worker/piece-reader.js

@@ -22,12 +22,7 @@
 
 import { findSharedStore } from "../piece-store/shared-piece-store.js";
 import { logger } from "../../utils/logger.js";
-import {
-  askFastestWiresFor,
-  canPlaceRequests,
-  describePieceTail,
-  duplicateTailFor
-} from "./fastest-wires.js";
+import { askFastestWiresFor, canPlaceRequests, describePieceTail } from "./fastest-wires.js";
 import { minimumBufferFrom, requiredSpeedFrom } from "../supply-margin.js";
 
 /** Only waits at least this long are reported; sequential reading stays silent. */
@@ -577,20 +572,11 @@ export async function* readFragments({
       // again every half second and the piece changes under it; the last such
       // reading is kept, so the line describes the most recent failure.
       let tailWhenNothingPlaced = null;
-      // What duplicating the tail placed, summed over the wait. Measured
-      // 2026-08-19 on a real swarm: the blocks a reader waits on are 2-14 of
-      // 512 and sit on wires the library considers fast, so its own hotswap
-      // never fires for them — see `duplicateTailFor`.
-      let duplicated = 0;
       const pushToFastest = () => {
         try {
           const result = askFastestWiresFor(torrent, pieceIndex);
           if (result.asked === 0) {
             tailWhenNothingPlaced = describePieceTail(torrent, pieceIndex);
-            // Nothing could be placed the ordinary way, which means every block
-            // is spoken for. That is exactly when a second copy of the last
-            // blocks is worth asking for.
-            duplicated += duplicateTailFor(torrent, pieceIndex).duplicated;
           }
           pushed = {
             asked: pushed.asked + result.asked,
@@ -696,10 +682,7 @@ export async function* readFragments({
                       (wire.choking ? " (choking)" : ""))
                     .join(" ")
                   : "nobody")
-              : "") +
-            // What we did about the tail, so the next session says by number
-            // whether a second copy of those blocks shortens the wait.
-            (duplicated > 0 ? `; duplicated ${duplicated} blocks` : "")
+              : "")
         );
       }
 

package/test/tail-duplication.test.js

@@ -1,123 +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, 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 }
-  );
-});