@torrent-tv/proxy 2.87.8 → 2.87.9

package/test/tail-duplication.test.js

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

package/test/the-channel-has-both-ends.test.js

@@ -1,91 +1,91 @@
-/**
- * @file Every call across the thread boundary has something to land on.
- *
- * The boundary is three files that have to agree, and nothing made them:
- * `protocol.js` names the commands, `worker.js` answers them, `client.js` asks,
- * and `pool-adapter.js` is what the main thread calls. A mismatch anywhere in
- * that chain is invisible to every other check in this repository, because a
- * unit test of either end alone passes and the failure needs a real worker.
- *
- * It was not hypothetical. Removing three commands on 2026-09-15 took an
- * unrelated neighbour with them — `client.fillFile`, which the adapter went on
- * calling — and left two adapter methods calling commands that no longer
- * existed. One of those two is the browser's own subtitle request, and it did
- * not even throw where anybody would see it: the orchestrator caught the error
- * and answered an EMPTY document, which is indistinguishable from a file that
- * genuinely holds no cues. That is the exact failure the whole subtitle path is
- * written to avoid, and it would have reached the field.
- *
- * These are structural because the property is: there is no input that makes a
- * call land on a method that is not there.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const WORKER = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../services/torrent/worker");
-
-/**
- * @param {string} name
- * @returns {string}
- */
-function source(name) {
-  return readFileSync(path.join(WORKER, name), "utf8");
-}
-
-/**
- * Names a file defines at the top level of a class: methods, and fields it
- * assigns to itself. Both are callable or readable from outside.
- *
- * @param {string} text
- * @returns {Set<string>}
- */
-function membersOf(text) {
-  const names = new Set();
-  for (const match of text.matchAll(/^\s{2}(?:static\s+)?(?:async\s+)?(?:get\s+|set\s+)?([a-zA-Z#][a-zA-Z0-9]*)\s*[(=]/gm)) {
-    names.add(match[1]);
-  }
-  // Fields a constructor or a method assigns rather than declares.
-  for (const match of text.matchAll(/this\.([a-zA-Z][a-zA-Z0-9]*)\s*=/g)) {
-    names.add(match[1]);
-  }
-  return names;
-}
-
-test("every client method the adapter calls exists", () => {
-  const have = membersOf(source("client.js"));
-  const used = [...source("pool-adapter.js").matchAll(/#client\.([a-zA-Z][a-zA-Z0-9]*)/g)].map((m) => m[1]);
-
-  assert.deepEqual([...new Set(used)].filter((name) => !have.has(name)), []);
-});
-
-test("every command the client sends is answered by the worker", () => {
-  const protocol = source("protocol.js");
-  const answered = new Set([...source("worker.js").matchAll(/case Command\.([A-Z_]+):/g)].map((m) => m[1]));
-  const sent = [...source("client.js").matchAll(/Command\.([A-Z_]+)/g)].map((m) => m[1]);
-
-  const unanswered = [...new Set(sent)].filter((name) => !answered.has(name));
-  assert.deepEqual(unanswered, [], "a command nobody answers waits for a reply that never comes");
-
-  const undeclared = [...new Set(sent)].filter((name) => !protocol.includes(`  ${name}:`));
-  assert.deepEqual(undeclared, [], "and one the protocol does not name is `undefined` on the wire");
-});
-
-test("every event the worker posts is received somewhere on the main thread", () => {
-  // TWO receivers, and they answer different shapes. `channel.js` matches the
-  // replies to a request by its id — a result, an error, a chunk of a body —
-  // while `client.js` has a `case` for each event that belongs to nobody's
-  // request. An event handled by neither is a fact announced into silence.
-  const receiving = `${source("client.js")}
-${source("channel.js")}`;
-  const handled = new Set([
-    ...[...receiving.matchAll(/case Event\.([A-Z_]+):/g)].map((m) => m[1]),
-    ...[...receiving.matchAll(/message\.type === Event\.([A-Z_]+)/g)].map((m) => m[1])
-  ]);
-  const posted = [...source("worker.js").matchAll(/type:\s*Event\.([A-Z_]+)/g)].map((m) => m[1]);
-
-  assert.deepEqual([...new Set(posted)].filter((name) => !handled.has(name)), []);
-});
+/**
+ * @file Every call across the thread boundary has something to land on.
+ *
+ * The boundary is three files that have to agree, and nothing made them:
+ * `protocol.js` names the commands, `worker.js` answers them, `client.js` asks,
+ * and `pool-adapter.js` is what the main thread calls. A mismatch anywhere in
+ * that chain is invisible to every other check in this repository, because a
+ * unit test of either end alone passes and the failure needs a real worker.
+ *
+ * It was not hypothetical. Removing three commands on 2026-09-15 took an
+ * unrelated neighbour with them — `client.fillFile`, which the adapter went on
+ * calling — and left two adapter methods calling commands that no longer
+ * existed. One of those two is the browser's own subtitle request, and it did
+ * not even throw where anybody would see it: the orchestrator caught the error
+ * and answered an EMPTY document, which is indistinguishable from a file that
+ * genuinely holds no cues. That is the exact failure the whole subtitle path is
+ * written to avoid, and it would have reached the field.
+ *
+ * These are structural because the property is: there is no input that makes a
+ * call land on a method that is not there.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const WORKER = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../services/torrent/worker");
+
+/**
+ * @param {string} name
+ * @returns {string}
+ */
+function source(name) {
+  return readFileSync(path.join(WORKER, name), "utf8");
+}
+
+/**
+ * Names a file defines at the top level of a class: methods, and fields it
+ * assigns to itself. Both are callable or readable from outside.
+ *
+ * @param {string} text
+ * @returns {Set<string>}
+ */
+function membersOf(text) {
+  const names = new Set();
+  for (const match of text.matchAll(/^\s{2}(?:static\s+)?(?:async\s+)?(?:get\s+|set\s+)?([a-zA-Z#][a-zA-Z0-9]*)\s*[(=]/gm)) {
+    names.add(match[1]);
+  }
+  // Fields a constructor or a method assigns rather than declares.
+  for (const match of text.matchAll(/this\.([a-zA-Z][a-zA-Z0-9]*)\s*=/g)) {
+    names.add(match[1]);
+  }
+  return names;
+}
+
+test("every client method the adapter calls exists", () => {
+  const have = membersOf(source("client.js"));
+  const used = [...source("pool-adapter.js").matchAll(/#client\.([a-zA-Z][a-zA-Z0-9]*)/g)].map((m) => m[1]);
+
+  assert.deepEqual([...new Set(used)].filter((name) => !have.has(name)), []);
+});
+
+test("every command the client sends is answered by the worker", () => {
+  const protocol = source("protocol.js");
+  const answered = new Set([...source("worker.js").matchAll(/case Command\.([A-Z_]+):/g)].map((m) => m[1]));
+  const sent = [...source("client.js").matchAll(/Command\.([A-Z_]+)/g)].map((m) => m[1]);
+
+  const unanswered = [...new Set(sent)].filter((name) => !answered.has(name));
+  assert.deepEqual(unanswered, [], "a command nobody answers waits for a reply that never comes");
+
+  const undeclared = [...new Set(sent)].filter((name) => !protocol.includes(`  ${name}:`));
+  assert.deepEqual(undeclared, [], "and one the protocol does not name is `undefined` on the wire");
+});
+
+test("every event the worker posts is received somewhere on the main thread", () => {
+  // TWO receivers, and they answer different shapes. `channel.js` matches the
+  // replies to a request by its id — a result, an error, a chunk of a body —
+  // while `client.js` has a `case` for each event that belongs to nobody's
+  // request. An event handled by neither is a fact announced into silence.
+  const receiving = `${source("client.js")}
+${source("channel.js")}`;
+  const handled = new Set([
+    ...[...receiving.matchAll(/case Event\.([A-Z_]+):/g)].map((m) => m[1]),
+    ...[...receiving.matchAll(/message\.type === Event\.([A-Z_]+)/g)].map((m) => m[1])
+  ]);
+  const posted = [...source("worker.js").matchAll(/type:\s*Event\.([A-Z_]+)/g)].map((m) => m[1]);
+
+  assert.deepEqual([...new Set(posted)].filter((name) => !handled.has(name)), []);
+});