@torrent-tv/proxy 2.87.10 → 2.87.12

package/test/upload-hurry.test.js

@@ -1,186 +1,186 @@
-/**
- * @file Uploading generously at the two moments a viewer is waiting.
- *
- * BitTorrent peers serve those who serve them: each re-ranks its takers about
- * every 10 s and opens a few slots to whoever uploaded most, plus one at
- * random. Uploading a token 8-50 KB/s means being picked at random, one slot
- * per cycle. Measured 2026-08-04 on a session with 96 peers already connected:
- * 64 KB/s after 2 s, 1.6 MB/s after 4 s, 4.8 MB/s after 8 s — and the 16 MB the
- * codec probe needs took 8.36 s of the 11.46 s before playback began.
- *
- * The reciprocity boost could not help: it waits for the download to be all but
- * dead (below 200 KB/s) with peers visibly choking us, which a ramp is not. In
- * that session it first moved the limit 13.3 s after the torrent was added, and
- * reached the generous rate at 43.7 s — both after the wait they were meant to
- * shorten.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { decideUploadLimit, torrentsForUploadPolicy } 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 whose metadata has arrived and which nothing is wanted of.
- *
- * The files matter: a torrent with no list of files cannot be stated about at
- * all, and is wanted for that reason alone — it is still being fetched.
- *
- * @param {string} name
- * @returns {object}
- */
-function quiet(name) {
-  return { name, files: [{ offset: 0, length: 1_000, name }] };
-}
-
-/**
- * The same, with something stated for it — which is what "somebody wants this"
- * means now that nothing counts readers.
- *
- * @param {string} name
- * @returns {object}
- */
-function wanted(name) {
-  const torrent = quiet(name);
-  demandFor(torrent).register.state({
-    claimant: "priority-map:0:0",
-    fileIndex: 0,
-    byteStart: 0,
-    byteEnd: 999,
-    urgency: Urgency.NEAR
-  });
-  return torrent;
-}
-
-const NOW = 1_000_000;
-const healthy = (extra = {}) => ({
-  name: "film.mkv",
-  wires: [{ amInterested: true, peerChoking: false }],
-  downloadSpeed: 5 * 1024 * 1024,
-  done: false,
-  ...extra
-});
-
-test("a torrent in a hurry gets the generous rate even while downloading well", () => {
-  const decision = decideUploadLimit([healthy({ hurryUntil: NOW + 10_000 })], { now: NOW });
-  assert.equal(decision.bytesPerSec, 512 * 1024);
-  assert.match(decision.reason, /in a hurry/);
-});
-
-test("the hurry expires on its own", () => {
-  const decision = decideUploadLimit([healthy({ hurryUntil: NOW - 1 })], { now: NOW });
-  assert.equal(decision.bytesPerSec, 50 * 1024, "back to the token upload once the rush is over");
-});
-
-test("a finished torrent is never in a hurry", () => {
-  // Nothing left to download, so there is nothing to buy with the upload — and
-  // seeding is what we deliberately avoid.
-  const decision = decideUploadLimit([healthy({ hurryUntil: NOW + 10_000, done: true })], { now: NOW });
-  assert.equal(decision.bytesPerSec, 50 * 1024);
-});
-
-test("nothing being watched still means near-silence", () => {
-  assert.equal(decideUploadLimit([], { now: NOW }).bytesPerSec, 8 * 1024);
-});
-
-test("the reciprocity boost still works when no hurry is on", () => {
-  const starving = {
-    name: "film.mkv",
-    wires: [
-      { amInterested: true, peerChoking: true },
-      { amInterested: true, peerChoking: true }
-    ],
-    downloadSpeed: 10 * 1024,
-    done: false
-  };
-  const decision = decideUploadLimit([starving], { now: NOW });
-  assert.equal(decision.bytesPerSec, 512 * 1024);
-  assert.match(decision.reason, /earn unchoke/);
-});
-
-test("a torrent nothing is wanted of still reaches the policy while it is in a hurry", () => {
-  // The moment that matters: a torrent has just been added and its head and
-  // tail are being fetched for the codec probe. Nothing is stated for it yet,
-  // and the selection only ever kept torrents something was — which is where
-  // the gap was.
-  const hurrying = quiet("film.mkv");
-  hurrying.hurryUntil = NOW + 20_000;
-  const idle = quiet("other.mkv");
-  const watched = wanted("watched.mkv");
-  try {
-    assert.deepEqual(
-      torrentsForUploadPolicy([hurrying, idle], NOW),
-      [hurrying],
-      "a torrent nothing is stated for yet was ignored"
-    );
-
-    assert.deepEqual(
-      torrentsForUploadPolicy([{ ...hurrying, hurryUntil: NOW - 1 }, idle], NOW),
-      [],
-      "and stops counting once the rush is over"
-    );
-
-    assert.deepEqual(
-      torrentsForUploadPolicy([watched], NOW),
-      [watched],
-      "a torrent somebody wants something of still counts, hurry or not"
-    );
-  } finally {
-    forgetTorrent(hurrying);
-    forgetTorrent(idle);
-    forgetTorrent(watched);
-  }
-});
-
-test("a torrent nobody is reading is not treated as starving", () => {
-  // The encoder is suspended once it is far enough ahead, and while it is
-  // suspended nothing is requested — so the download reads zero without anyone
-  // waiting. Measured before this guard: four cycles of 512 -> 50 KB/s in three
-  // minutes, every one of them reported as `earn unchoke ... down=0KB/s`.
-  const idleButChoked = {
-    name: "film.mkv",
-    isWanted: false,
-    wires: [
-      { amInterested: true, peerChoking: true },
-      { amInterested: true, peerChoking: true }
-    ],
-    downloadSpeed: 0,
-    done: false
-  };
-  assert.equal(decideUploadLimit([idleButChoked], { now: NOW }).bytesPerSec, 50 * 1024);
-
-  const waiting = { ...idleButChoked, isWanted: true };
-  assert.equal(
-    decideUploadLimit([waiting], { now: NOW }).bytesPerSec,
-    512 * 1024,
-    "a reader that IS waiting must still earn unchoke slots"
-  );
-});
-
-test("a torrent short of nothing is not worth uploading for", () => {
-  // Field 2026-09-11: the file being watched was complete, its windows all
-  // present, and the proxy went on offering 512 KB/s to 596 peers for
-  // forty-eight minutes — reading a 4 MB piece off the disk for every 16 KB it
-  // sent. Upload is bought with reciprocity, and reciprocity is only worth
-  // buying while somebody is still short of bytes.
-  const complete = {
-    name: "watched to the end",
-    isWanted: true,
-    hasUnmetDemand: false,
-    done: false,
-    downloadSpeed: 0,
-    wires: [
-      { amInterested: true, peerChoking: true },
-      { amInterested: true, peerChoking: true },
-      { amInterested: true, peerChoking: true }
-    ]
-  };
-  const decided = decideUploadLimit([complete]);
-  assert.equal(decided.bytesPerSec, 8 * 1024, "a complete torrent is given the idle floor");
-  assert.match(decided.reason, /buys nothing/);
-
-  // And a torrent that IS short of something still earns its unchoke.
-  const short = { ...complete, hasUnmetDemand: true };
-  assert.ok(decideUploadLimit([short]).bytesPerSec > 8 * 1024, "a starving torrent still buys reciprocity");
-});
+/**
+ * @file Uploading generously at the two moments a viewer is waiting.
+ *
+ * BitTorrent peers serve those who serve them: each re-ranks its takers about
+ * every 10 s and opens a few slots to whoever uploaded most, plus one at
+ * random. Uploading a token 8-50 KB/s means being picked at random, one slot
+ * per cycle. Measured 2026-08-04 on a session with 96 peers already connected:
+ * 64 KB/s after 2 s, 1.6 MB/s after 4 s, 4.8 MB/s after 8 s — and the 16 MB the
+ * codec probe needs took 8.36 s of the 11.46 s before playback began.
+ *
+ * The reciprocity boost could not help: it waits for the download to be all but
+ * dead (below 200 KB/s) with peers visibly choking us, which a ramp is not. In
+ * that session it first moved the limit 13.3 s after the torrent was added, and
+ * reached the generous rate at 43.7 s — both after the wait they were meant to
+ * shorten.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { decideUploadLimit, torrentsForUploadPolicy } 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 whose metadata has arrived and which nothing is wanted of.
+ *
+ * The files matter: a torrent with no list of files cannot be stated about at
+ * all, and is wanted for that reason alone — it is still being fetched.
+ *
+ * @param {string} name
+ * @returns {object}
+ */
+function quiet(name) {
+  return { name, files: [{ offset: 0, length: 1_000, name }] };
+}
+
+/**
+ * The same, with something stated for it — which is what "somebody wants this"
+ * means now that nothing counts readers.
+ *
+ * @param {string} name
+ * @returns {object}
+ */
+function wanted(name) {
+  const torrent = quiet(name);
+  demandFor(torrent).register.state({
+    claimant: "priority-map:0:0",
+    fileIndex: 0,
+    byteStart: 0,
+    byteEnd: 999,
+    urgency: Urgency.NEAR
+  });
+  return torrent;
+}
+
+const NOW = 1_000_000;
+const healthy = (extra = {}) => ({
+  name: "film.mkv",
+  wires: [{ amInterested: true, peerChoking: false }],
+  downloadSpeed: 5 * 1024 * 1024,
+  done: false,
+  ...extra
+});
+
+test("a torrent in a hurry gets the generous rate even while downloading well", () => {
+  const decision = decideUploadLimit([healthy({ hurryUntil: NOW + 10_000 })], { now: NOW });
+  assert.equal(decision.bytesPerSec, 512 * 1024);
+  assert.match(decision.reason, /in a hurry/);
+});
+
+test("the hurry expires on its own", () => {
+  const decision = decideUploadLimit([healthy({ hurryUntil: NOW - 1 })], { now: NOW });
+  assert.equal(decision.bytesPerSec, 50 * 1024, "back to the token upload once the rush is over");
+});
+
+test("a finished torrent is never in a hurry", () => {
+  // Nothing left to download, so there is nothing to buy with the upload — and
+  // seeding is what we deliberately avoid.
+  const decision = decideUploadLimit([healthy({ hurryUntil: NOW + 10_000, done: true })], { now: NOW });
+  assert.equal(decision.bytesPerSec, 50 * 1024);
+});
+
+test("nothing being watched still means near-silence", () => {
+  assert.equal(decideUploadLimit([], { now: NOW }).bytesPerSec, 8 * 1024);
+});
+
+test("the reciprocity boost still works when no hurry is on", () => {
+  const starving = {
+    name: "film.mkv",
+    wires: [
+      { amInterested: true, peerChoking: true },
+      { amInterested: true, peerChoking: true }
+    ],
+    downloadSpeed: 10 * 1024,
+    done: false
+  };
+  const decision = decideUploadLimit([starving], { now: NOW });
+  assert.equal(decision.bytesPerSec, 512 * 1024);
+  assert.match(decision.reason, /earn unchoke/);
+});
+
+test("a torrent nothing is wanted of still reaches the policy while it is in a hurry", () => {
+  // The moment that matters: a torrent has just been added and its head and
+  // tail are being fetched for the codec probe. Nothing is stated for it yet,
+  // and the selection only ever kept torrents something was — which is where
+  // the gap was.
+  const hurrying = quiet("film.mkv");
+  hurrying.hurryUntil = NOW + 20_000;
+  const idle = quiet("other.mkv");
+  const watched = wanted("watched.mkv");
+  try {
+    assert.deepEqual(
+      torrentsForUploadPolicy([hurrying, idle], NOW),
+      [hurrying],
+      "a torrent nothing is stated for yet was ignored"
+    );
+
+    assert.deepEqual(
+      torrentsForUploadPolicy([{ ...hurrying, hurryUntil: NOW - 1 }, idle], NOW),
+      [],
+      "and stops counting once the rush is over"
+    );
+
+    assert.deepEqual(
+      torrentsForUploadPolicy([watched], NOW),
+      [watched],
+      "a torrent somebody wants something of still counts, hurry or not"
+    );
+  } finally {
+    forgetTorrent(hurrying);
+    forgetTorrent(idle);
+    forgetTorrent(watched);
+  }
+});
+
+test("a torrent nobody is reading is not treated as starving", () => {
+  // The encoder is suspended once it is far enough ahead, and while it is
+  // suspended nothing is requested — so the download reads zero without anyone
+  // waiting. Measured before this guard: four cycles of 512 -> 50 KB/s in three
+  // minutes, every one of them reported as `earn unchoke ... down=0KB/s`.
+  const idleButChoked = {
+    name: "film.mkv",
+    isWanted: false,
+    wires: [
+      { amInterested: true, peerChoking: true },
+      { amInterested: true, peerChoking: true }
+    ],
+    downloadSpeed: 0,
+    done: false
+  };
+  assert.equal(decideUploadLimit([idleButChoked], { now: NOW }).bytesPerSec, 50 * 1024);
+
+  const waiting = { ...idleButChoked, isWanted: true };
+  assert.equal(
+    decideUploadLimit([waiting], { now: NOW }).bytesPerSec,
+    512 * 1024,
+    "a reader that IS waiting must still earn unchoke slots"
+  );
+});
+
+test("a torrent short of nothing is not worth uploading for", () => {
+  // Field 2026-09-11: the file being watched was complete, its windows all
+  // present, and the proxy went on offering 512 KB/s to 596 peers for
+  // forty-eight minutes — reading a 4 MB piece off the disk for every 16 KB it
+  // sent. Upload is bought with reciprocity, and reciprocity is only worth
+  // buying while somebody is still short of bytes.
+  const complete = {
+    name: "watched to the end",
+    isWanted: true,
+    hasUnmetDemand: false,
+    done: false,
+    downloadSpeed: 0,
+    wires: [
+      { amInterested: true, peerChoking: true },
+      { amInterested: true, peerChoking: true },
+      { amInterested: true, peerChoking: true }
+    ]
+  };
+  const decided = decideUploadLimit([complete]);
+  assert.equal(decided.bytesPerSec, 8 * 1024, "a complete torrent is given the idle floor");
+  assert.match(decided.reason, /buys nothing/);
+
+  // And a torrent that IS short of something still earns its unchoke.
+  const short = { ...complete, hasUnmetDemand: true };
+  assert.ok(decideUploadLimit([short]).bytesPerSec > 8 * 1024, "a starving torrent still buys reciprocity");
+});

package/test/usrsctp-state.test.js

@@ -1,131 +1,131 @@
-/**
- * @file The usrsctp state reader's gating and command construction.
- *
- * Roadmap item 11: reads usrsctp's live association state via gdb the moment
- * a wedge is declared. Everything here is the part that decides WHEN and WITH
- * WHAT ARGUMENTS — the spawning itself is thin glue around these, the same
- * shape as the packet witness (test/packet-witness.test.js).
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { EventEmitter } from "node:events";
-
-import { createUsrsctpStateReader, SCTPSTATE_SCRIPT_PATH } from "../services/transport/usrsctp-state.js";
-
-class FakeChild extends EventEmitter {
-  constructor(command, args) {
-    super();
-    this.command = command;
-    this.args = args;
-    this.stdout = new EventEmitter();
-    this.stderr = new EventEmitter();
-  }
-
-  kill() {
-    // Not exercised by these tests — every fake run finishes on its own.
-    return true;
-  }
-}
-
-/**
- * @param {string} output - What the fake gdb writes to stdout before closing.
- * @returns {{ spawnProcess: Function, calls: Array<{ command: string, args: string[] }> }}
- */
-function makeSpawn(output) {
-  const calls = [];
-  const spawnProcess = (command, args) => {
-    calls.push({ command, args });
-    const child = new FakeChild(command, args);
-    setImmediate(() => {
-      if (output) {
-        child.stdout.emit("data", Buffer.from(output));
-      }
-      child.emit("close", 0);
-    });
-    return child;
-  };
-  return { spawnProcess, calls };
-}
-
-/** Wait until `check` holds, rather than for a chosen interval. */
-async function waitFor(check) {
-  const deadline = Date.now() + 5_000;
-  for (;;) {
-    if (check()) {
-      return;
-    }
-    if (Date.now() > deadline) {
-      throw new Error("timed out waiting for the reading to be logged");
-    }
-    await new Promise((resolve) => setTimeout(resolve, 5));
-  }
-}
-
-test("the deadline is counted outside the process gdb stops", async () => {
-  const { spawnProcess, calls } = makeSpawn("state=8 rwnd=95890\n");
-  const lines = [];
-  const reader = createUsrsctpStateReader({
-    log: (message) => lines.push(message),
-    spawnProcess,
-    pid: 4242
-  });
-  const started = reader.maybeRead("test wedge");
-  assert.equal(started, true);
-  await waitFor(() => lines.length > 0);
-  assert.equal(calls.length, 1);
-  // `timeout` is a separate process, so it keeps counting while gdb holds every
-  // thread of this one. A `setTimeout` here cannot fire — measured in the field
-  // on 2026-09-05, where gdb held the proxy for four minutes and the guard set
-  // for fifteen seconds never ran.
-  assert.equal(calls[0].command, "timeout");
-  assert.deepEqual(calls[0].args, [
-    "-s",
-    "KILL",
-    "15",
-    "gdb",
-    "-q",
-    "-batch",
-    "-p",
-    "4242",
-    "-x",
-    SCTPSTATE_SCRIPT_PATH
-  ]);
-  assert.match(lines[0], /state=8 rwnd=95890/);
-  assert.match(lines[0], /test wedge/);
-});
-
-test("no output is reported as no reading, not silence", async () => {
-  const { spawnProcess } = makeSpawn("");
-  const lines = [];
-  const reader = createUsrsctpStateReader({ log: (message) => lines.push(message), spawnProcess, pid: 1 });
-  reader.maybeRead("empty case");
-  await waitFor(() => lines.length > 0);
-  assert.match(lines[0], /no reading/);
-});
-
-test("a second read is refused within the cooldown, like the packet witness", async () => {
-  const { spawnProcess, calls } = makeSpawn("state=8\n");
-  const lines = [];
-  const reader = createUsrsctpStateReader({
-    log: (message) => lines.push(message),
-    spawnProcess,
-    pid: 1,
-    cooldownMs: 60_000
-  });
-  assert.equal(reader.maybeRead("first"), true);
-  await waitFor(() => lines.length > 0);
-  assert.equal(reader.maybeRead("second, too soon"), false);
-  assert.equal(calls.length, 1);
-});
-
-test("a missing gdb is reported, not thrown", async () => {
-  const lines = [];
-  const spawnProcess = () => {
-    throw new Error("spawn gdb ENOENT");
-  };
-  const reader = createUsrsctpStateReader({ log: (message) => lines.push(message), spawnProcess, pid: 1 });
-  reader.maybeRead("no gdb on this host");
-  await waitFor(() => lines.length > 0);
-  assert.match(lines[0], /could not start gdb/);
-});
+/**
+ * @file The usrsctp state reader's gating and command construction.
+ *
+ * Roadmap item 11: reads usrsctp's live association state via gdb the moment
+ * a wedge is declared. Everything here is the part that decides WHEN and WITH
+ * WHAT ARGUMENTS — the spawning itself is thin glue around these, the same
+ * shape as the packet witness (test/packet-witness.test.js).
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+
+import { createUsrsctpStateReader, SCTPSTATE_SCRIPT_PATH } from "../services/transport/usrsctp-state.js";
+
+class FakeChild extends EventEmitter {
+  constructor(command, args) {
+    super();
+    this.command = command;
+    this.args = args;
+    this.stdout = new EventEmitter();
+    this.stderr = new EventEmitter();
+  }
+
+  kill() {
+    // Not exercised by these tests — every fake run finishes on its own.
+    return true;
+  }
+}
+
+/**
+ * @param {string} output - What the fake gdb writes to stdout before closing.
+ * @returns {{ spawnProcess: Function, calls: Array<{ command: string, args: string[] }> }}
+ */
+function makeSpawn(output) {
+  const calls = [];
+  const spawnProcess = (command, args) => {
+    calls.push({ command, args });
+    const child = new FakeChild(command, args);
+    setImmediate(() => {
+      if (output) {
+        child.stdout.emit("data", Buffer.from(output));
+      }
+      child.emit("close", 0);
+    });
+    return child;
+  };
+  return { spawnProcess, calls };
+}
+
+/** Wait until `check` holds, rather than for a chosen interval. */
+async function waitFor(check) {
+  const deadline = Date.now() + 5_000;
+  for (;;) {
+    if (check()) {
+      return;
+    }
+    if (Date.now() > deadline) {
+      throw new Error("timed out waiting for the reading to be logged");
+    }
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+}
+
+test("the deadline is counted outside the process gdb stops", async () => {
+  const { spawnProcess, calls } = makeSpawn("state=8 rwnd=95890\n");
+  const lines = [];
+  const reader = createUsrsctpStateReader({
+    log: (message) => lines.push(message),
+    spawnProcess,
+    pid: 4242
+  });
+  const started = reader.maybeRead("test wedge");
+  assert.equal(started, true);
+  await waitFor(() => lines.length > 0);
+  assert.equal(calls.length, 1);
+  // `timeout` is a separate process, so it keeps counting while gdb holds every
+  // thread of this one. A `setTimeout` here cannot fire — measured in the field
+  // on 2026-09-05, where gdb held the proxy for four minutes and the guard set
+  // for fifteen seconds never ran.
+  assert.equal(calls[0].command, "timeout");
+  assert.deepEqual(calls[0].args, [
+    "-s",
+    "KILL",
+    "15",
+    "gdb",
+    "-q",
+    "-batch",
+    "-p",
+    "4242",
+    "-x",
+    SCTPSTATE_SCRIPT_PATH
+  ]);
+  assert.match(lines[0], /state=8 rwnd=95890/);
+  assert.match(lines[0], /test wedge/);
+});
+
+test("no output is reported as no reading, not silence", async () => {
+  const { spawnProcess } = makeSpawn("");
+  const lines = [];
+  const reader = createUsrsctpStateReader({ log: (message) => lines.push(message), spawnProcess, pid: 1 });
+  reader.maybeRead("empty case");
+  await waitFor(() => lines.length > 0);
+  assert.match(lines[0], /no reading/);
+});
+
+test("a second read is refused within the cooldown, like the packet witness", async () => {
+  const { spawnProcess, calls } = makeSpawn("state=8\n");
+  const lines = [];
+  const reader = createUsrsctpStateReader({
+    log: (message) => lines.push(message),
+    spawnProcess,
+    pid: 1,
+    cooldownMs: 60_000
+  });
+  assert.equal(reader.maybeRead("first"), true);
+  await waitFor(() => lines.length > 0);
+  assert.equal(reader.maybeRead("second, too soon"), false);
+  assert.equal(calls.length, 1);
+});
+
+test("a missing gdb is reported, not thrown", async () => {
+  const lines = [];
+  const spawnProcess = () => {
+    throw new Error("spawn gdb ENOENT");
+  };
+  const reader = createUsrsctpStateReader({ log: (message) => lines.push(message), spawnProcess, pid: 1 });
+  reader.maybeRead("no gdb on this host");
+  await waitFor(() => lines.length > 0);
+  assert.match(lines[0], /could not start gdb/);
+});