@torrent-tv/proxy 2.89.6 → 2.89.7

package/test/piece-store-slow-disk.test.js

@@ -1,159 +1,159 @@
-/**
- * @file What the allowance has to bound, and why it is not the resident pieces.
- *
- * The field failure of 2026-09-02, in one sentence: a piece being written out
- * leaves the store's own count the moment the eviction begins, while its memory
- * stays held until the write that reads from it has finished. So every
- * admission turned one resident block into one block held by the disk and took
- * a fresh block for the arrival, and the memory in use went UP by one per
- * admission for as long as the disk was behind.
- *
- * It was behind by a factor of two: 233 evictions started against about 119
- * writes completed in the same minute. The store reported 203 blocks held with
- * THREE pieces resident and 68 MB allowed, and the kernel killed the process at
- * 4.37 GB.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { SharedPieceStore } from "../services/storage/piece-store/shared-piece-store.js";
-
-const PIECE = 1024;
-
-/**
- * Wait for the thing being asserted, not for a length of time.
- *
- * @param {() => boolean} until
- * @param {string} what - Named in the failure, since a timeout otherwise says
- *   only that something did not happen.
- * @param {number} [limit]
- * @returns {Promise<void>}
- */
-async function waitFor(until, what, limit = 10_000) {
-  const deadline = Date.now() + limit;
-  while (!until()) {
-    if (Date.now() > deadline) {
-      throw new Error(`${what} never happened`);
-    }
-    await new Promise((resolve) => { setTimeout(resolve, 5); });
-  }
-}
-
-/**
- * A disk that answers only when the test lets it, so writes can be made slower
- * than arrivals on purpose — which is the whole of the field condition.
- */
-function heldDisk() {
-  const stored = new Set();
-  /** @type {Array<() => void>} */
-  const waiting = [];
-  return {
-    pending: waiting,
-    get size() {
-      return stored.size;
-    },
-    get bytes() {
-      return 0;
-    },
-    get path() {
-      return ".";
-    },
-    get allowanceBytes() {
-      return null;
-    },
-    reviseAllowance() {
-      return null;
-    },
-    stats() {
-      return { pieces: stored.size, bytes: 0, allowanceBytes: null, evictions: 0 };
-    },
-    has: (index) => stored.has(index),
-    forget: (index) => stored.delete(index),
-    write(index) {
-      return new Promise((resolve) => {
-        waiting.push(() => {
-          stored.add(index);
-          resolve();
-        });
-      });
-    },
-    async read(index, target) {
-      target.fill(index % 251);
-      return target.length;
-    },
-    async close() { waiting.length = 0; },
-    async destroy() { stored.clear(); waiting.length = 0; }
-  };
-}
-
-/**
- * @param {SharedPieceStore} store
- * @param {number} index
- * @returns {Promise<void>}
- */
-const put = (store, index) =>
-  new Promise((resolve, reject) => {
-    store.put(index, Buffer.alloc(PIECE, index % 251), (error) => (error ? reject(error) : resolve()));
-  });
-
-test("memory in use never runs past the allowance while the disk is behind", async () => {
-  const directory = await fs.mkdtemp(path.join(os.tmpdir(), "slow-disk-test-"));
-  const disk = heldDisk();
-  const capacity = 4;
-  const store = new SharedPieceStore(PIECE, {
-    length: PIECE * 200,
-    memoryBytes: PIECE * capacity,
-    path: directory,
-    name: "slow-disk",
-    disk
-  });
-  try {
-    // Fill it, then keep pieces coming while every write stays unfinished.
-    for (let index = 0; index < capacity; index += 1) {
-      await put(store, index);
-    }
-    const arrivals = [];
-    for (let index = capacity; index < capacity + 40; index += 1) {
-      arrivals.push(put(store, index).catch(() => undefined));
-    }
-    // Until the state being asserted has been reached: a write is outstanding
-    // and admission has waited for the disk rather than evicting. Waited out as
-    // 200 ms instead, this asserted how far the arrivals had got in that time —
-    // and on a machine slow enough that none of them reached a disk write, both
-    // of those figures are zero and the test fails with nothing wrong.
-    //
-    // The bound below is what the wait must NOT decide, so it is checked after
-    // the state is reached rather than after an interval: the store may never
-    // hold more blocks than it is allowed, however many arrivals are in flight.
-    await waitFor(() => {
-      const now = store.stats();
-      return now.blocksInFlight > 0 && now.waitedForDisk > 0;
-    }, "a held write and an admission that waited for it");
-
-    const held = store.stats();
-    // The check the field failure would fail: a store allowed four pieces held
-    // two hundred and three. Blocks held by a pending write count here, because
-    // they are memory whatever the piece count says.
-    assert.ok(
-      held.blocksInUse <= capacity,
-      `${held.blocksInUse} blocks in use with ${capacity} allowed `
-      + `(${held.blocksInFlight} of them held by writes that have not finished)`
-    );
-    assert.ok(held.blocksInFlight > 0, "the disk was supposed to be holding some");
-    assert.ok(held.waitedForDisk > 0, "admission was supposed to wait for the disk, not evict");
-
-    // Let the disk answer: the blocks come back and everything settles.
-    while (disk.pending.length > 0) {
-      disk.pending.shift()?.();
-      await new Promise((resolve) => setTimeout(resolve, 0));
-    }
-    await Promise.all(arrivals);
-    assert.ok(store.stats().blocksInUse <= capacity + 1, "the pool did not settle");
-  } finally {
-    store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});
+/**
+ * @file What the allowance has to bound, and why it is not the resident pieces.
+ *
+ * The field failure of 2026-09-02, in one sentence: a piece being written out
+ * leaves the store's own count the moment the eviction begins, while its memory
+ * stays held until the write that reads from it has finished. So every
+ * admission turned one resident block into one block held by the disk and took
+ * a fresh block for the arrival, and the memory in use went UP by one per
+ * admission for as long as the disk was behind.
+ *
+ * It was behind by a factor of two: 233 evictions started against about 119
+ * writes completed in the same minute. The store reported 203 blocks held with
+ * THREE pieces resident and 68 MB allowed, and the kernel killed the process at
+ * 4.37 GB.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { SharedPieceStore } from "../services/storage/piece-store/shared-piece-store.js";
+
+const PIECE = 1024;
+
+/**
+ * Wait for the thing being asserted, not for a length of time.
+ *
+ * @param {() => boolean} until
+ * @param {string} what - Named in the failure, since a timeout otherwise says
+ *   only that something did not happen.
+ * @param {number} [limit]
+ * @returns {Promise<void>}
+ */
+async function waitFor(until, what, limit = 10_000) {
+  const deadline = Date.now() + limit;
+  while (!until()) {
+    if (Date.now() > deadline) {
+      throw new Error(`${what} never happened`);
+    }
+    await new Promise((resolve) => { setTimeout(resolve, 5); });
+  }
+}
+
+/**
+ * A disk that answers only when the test lets it, so writes can be made slower
+ * than arrivals on purpose — which is the whole of the field condition.
+ */
+function heldDisk() {
+  const stored = new Set();
+  /** @type {Array<() => void>} */
+  const waiting = [];
+  return {
+    pending: waiting,
+    get size() {
+      return stored.size;
+    },
+    get bytes() {
+      return 0;
+    },
+    get path() {
+      return ".";
+    },
+    get allowanceBytes() {
+      return null;
+    },
+    reviseAllowance() {
+      return null;
+    },
+    stats() {
+      return { pieces: stored.size, bytes: 0, allowanceBytes: null, evictions: 0 };
+    },
+    has: (index) => stored.has(index),
+    forget: (index) => stored.delete(index),
+    write(index) {
+      return new Promise((resolve) => {
+        waiting.push(() => {
+          stored.add(index);
+          resolve();
+        });
+      });
+    },
+    async read(index, target) {
+      target.fill(index % 251);
+      return target.length;
+    },
+    async close() { waiting.length = 0; },
+    async destroy() { stored.clear(); waiting.length = 0; }
+  };
+}
+
+/**
+ * @param {SharedPieceStore} store
+ * @param {number} index
+ * @returns {Promise<void>}
+ */
+const put = (store, index) =>
+  new Promise((resolve, reject) => {
+    store.put(index, Buffer.alloc(PIECE, index % 251), (error) => (error ? reject(error) : resolve()));
+  });
+
+test("memory in use never runs past the allowance while the disk is behind", async () => {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), "slow-disk-test-"));
+  const disk = heldDisk();
+  const capacity = 4;
+  const store = new SharedPieceStore(PIECE, {
+    length: PIECE * 200,
+    memoryBytes: PIECE * capacity,
+    path: directory,
+    name: "slow-disk",
+    disk
+  });
+  try {
+    // Fill it, then keep pieces coming while every write stays unfinished.
+    for (let index = 0; index < capacity; index += 1) {
+      await put(store, index);
+    }
+    const arrivals = [];
+    for (let index = capacity; index < capacity + 40; index += 1) {
+      arrivals.push(put(store, index).catch(() => undefined));
+    }
+    // Until the state being asserted has been reached: a write is outstanding
+    // and admission has waited for the disk rather than evicting. Waited out as
+    // 200 ms instead, this asserted how far the arrivals had got in that time —
+    // and on a machine slow enough that none of them reached a disk write, both
+    // of those figures are zero and the test fails with nothing wrong.
+    //
+    // The bound below is what the wait must NOT decide, so it is checked after
+    // the state is reached rather than after an interval: the store may never
+    // hold more blocks than it is allowed, however many arrivals are in flight.
+    await waitFor(() => {
+      const now = store.stats();
+      return now.blocksInFlight > 0 && now.waitedForDisk > 0;
+    }, "a held write and an admission that waited for it");
+
+    const held = store.stats();
+    // The check the field failure would fail: a store allowed four pieces held
+    // two hundred and three. Blocks held by a pending write count here, because
+    // they are memory whatever the piece count says.
+    assert.ok(
+      held.blocksInUse <= capacity,
+      `${held.blocksInUse} blocks in use with ${capacity} allowed `
+      + `(${held.blocksInFlight} of them held by writes that have not finished)`
+    );
+    assert.ok(held.blocksInFlight > 0, "the disk was supposed to be holding some");
+    assert.ok(held.waitedForDisk > 0, "admission was supposed to wait for the disk, not evict");
+
+    // Let the disk answer: the blocks come back and everything settles.
+    while (disk.pending.length > 0) {
+      disk.pending.shift()?.();
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+    await Promise.all(arrivals);
+    assert.ok(store.stats().blocksInUse <= capacity + 1, "the pool did not settle");
+  } finally {
+    store.destroy(() => undefined);
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});

package/test/piece-tail.test.js

@@ -1,97 +1,97 @@
-/**
- * @file What a blocked piece's tail looks like, before anything is built on it.
- *
- * The steering shipped in 2.29.0 often places nothing — `steered onto 0 of 9
- * asks (8 peers held it)`, measured 2026-08-18 — because every block of the
- * piece is already reserved and the library will not hand out a second request
- * for the same block. Duplicating those blocks is the standard remedy and costs
- * traffic, so the tail is described first: how much is missing, and on which
- * wires it sits.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { describePieceTail } from "../services/torrent/worker/fastest-wires.js";
-
-/** A torrent whose piece has some blocks in hand and some in flight. */
-function torrentWith({ buffer, wires }) {
-  return {
-    pieces: [{ _buffer: buffer, _chunks: buffer.length }],
-    wires
-  };
-}
-
-function wire({ has = true, blocks = 0, speed = 0, choking = false }) {
-  return {
-    peerPieces: { get: () => has },
-    requests: Array.from({ length: blocks }, () => ({ piece: 0 })),
-    downloadSpeed: () => speed,
-    peerChoking: choking
-  };
-}
-
-test("the tail names how much is missing and who is holding it", () => {
-  const tail = describePieceTail(
-    torrentWith({
-      // Four blocks, two already in hand.
-      buffer: [new Uint8Array(1), new Uint8Array(1), null, null],
-      wires: [
-        wire({ blocks: 1, speed: 900_000 }),
-        wire({ blocks: 1, speed: 12_000 }),
-        wire({ has: true, blocks: 0, speed: 5_000_000 })
-      ]
-    }),
-    0
-  );
-
-  assert.equal(tail.missing, 2);
-  assert.equal(tail.chunks, 4);
-  assert.equal(tail.outstanding.length, 2, "only the wires actually holding a block of it");
-  assert.equal(
-    tail.outstanding[0].bytesPerSecond,
-    12_000,
-    "slowest first — that is the wire the read is waiting on"
-  );
-});
-
-test("a piece nobody is fetching reads as entirely missing, held by nobody", () => {
-  const tail = describePieceTail(
-    torrentWith({ buffer: [null, null], wires: [wire({ has: false, blocks: 0 })] }),
-    0
-  );
-
-  assert.equal(tail.outstanding.length, 0);
-  assert.equal(tail.missing, 2, "and the missing count still says the piece is untouched");
-});
-
-test("a piece no block of which has been reserved is described, not skipped", () => {
-  // `torrent-piece` builds its buffer lazily on the first reserve, so a piece
-  // the picker has not reached has none. Reading that as "no tail" hid the
-  // clearest answer there is: the wait is on nobody having been asked.
-  const tail = describePieceTail(
-    { pieces: [{ _buffer: null, _chunks: 512 }], wires: [wire({ has: true, blocks: 0, speed: 900_000 })] },
-    0
-  );
-
-  assert.equal(tail.missing, 512, "every block of it is missing");
-  assert.equal(tail.chunks, 512);
-  assert.equal(tail.outstanding.length, 0, "and not one of them has been asked for");
-});
-
-test("a completed piece is not described at all", () => {
-  // WebTorrent nulls `pieces[index]` once the piece is verified and stored.
-  assert.equal(describePieceTail({ pieces: [null], wires: [] }, 0), null);
-  assert.equal(describePieceTail({ pieces: [], wires: [] }, 0), null);
-});
-
-test("a wire that is choking us is named as such", () => {
-  const tail = describePieceTail(
-    torrentWith({
-      buffer: [null],
-      wires: [wire({ blocks: 1, speed: 100, choking: true })]
-    }),
-    0
-  );
-
-  assert.equal(tail.outstanding[0].choking, true, "a block reserved by a choking wire is going nowhere");
-});
+/**
+ * @file What a blocked piece's tail looks like, before anything is built on it.
+ *
+ * The steering shipped in 2.29.0 often places nothing — `steered onto 0 of 9
+ * asks (8 peers held it)`, measured 2026-08-18 — because every block of the
+ * piece is already reserved and the library will not hand out a second request
+ * for the same block. Duplicating those blocks is the standard remedy and costs
+ * traffic, so the tail is described first: how much is missing, and on which
+ * wires it sits.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { describePieceTail } from "../services/torrent/worker/fastest-wires.js";
+
+/** A torrent whose piece has some blocks in hand and some in flight. */
+function torrentWith({ buffer, wires }) {
+  return {
+    pieces: [{ _buffer: buffer, _chunks: buffer.length }],
+    wires
+  };
+}
+
+function wire({ has = true, blocks = 0, speed = 0, choking = false }) {
+  return {
+    peerPieces: { get: () => has },
+    requests: Array.from({ length: blocks }, () => ({ piece: 0 })),
+    downloadSpeed: () => speed,
+    peerChoking: choking
+  };
+}
+
+test("the tail names how much is missing and who is holding it", () => {
+  const tail = describePieceTail(
+    torrentWith({
+      // Four blocks, two already in hand.
+      buffer: [new Uint8Array(1), new Uint8Array(1), null, null],
+      wires: [
+        wire({ blocks: 1, speed: 900_000 }),
+        wire({ blocks: 1, speed: 12_000 }),
+        wire({ has: true, blocks: 0, speed: 5_000_000 })
+      ]
+    }),
+    0
+  );
+
+  assert.equal(tail.missing, 2);
+  assert.equal(tail.chunks, 4);
+  assert.equal(tail.outstanding.length, 2, "only the wires actually holding a block of it");
+  assert.equal(
+    tail.outstanding[0].bytesPerSecond,
+    12_000,
+    "slowest first — that is the wire the read is waiting on"
+  );
+});
+
+test("a piece nobody is fetching reads as entirely missing, held by nobody", () => {
+  const tail = describePieceTail(
+    torrentWith({ buffer: [null, null], wires: [wire({ has: false, blocks: 0 })] }),
+    0
+  );
+
+  assert.equal(tail.outstanding.length, 0);
+  assert.equal(tail.missing, 2, "and the missing count still says the piece is untouched");
+});
+
+test("a piece no block of which has been reserved is described, not skipped", () => {
+  // `torrent-piece` builds its buffer lazily on the first reserve, so a piece
+  // the picker has not reached has none. Reading that as "no tail" hid the
+  // clearest answer there is: the wait is on nobody having been asked.
+  const tail = describePieceTail(
+    { pieces: [{ _buffer: null, _chunks: 512 }], wires: [wire({ has: true, blocks: 0, speed: 900_000 })] },
+    0
+  );
+
+  assert.equal(tail.missing, 512, "every block of it is missing");
+  assert.equal(tail.chunks, 512);
+  assert.equal(tail.outstanding.length, 0, "and not one of them has been asked for");
+});
+
+test("a completed piece is not described at all", () => {
+  // WebTorrent nulls `pieces[index]` once the piece is verified and stored.
+  assert.equal(describePieceTail({ pieces: [null], wires: [] }, 0), null);
+  assert.equal(describePieceTail({ pieces: [], wires: [] }, 0), null);
+});
+
+test("a wire that is choking us is named as such", () => {
+  const tail = describePieceTail(
+    torrentWith({
+      buffer: [null],
+      wires: [wire({ blocks: 1, speed: 100, choking: true })]
+    }),
+    0
+  );
+
+  assert.equal(tail.outstanding[0].choking, true, "a block reserved by a choking wire is going nowhere");
+});

package/test/plan-host-timings.test.js

@@ -1,68 +1,68 @@
-/**
- * @file The host's own timings must reach the browser for the file that needs
- * them most.
- *
- * The plan carries two figures the browser cannot measure for itself: how long
- * this host takes to create a session, and how long it takes to produce a first
- * segment. Both are medians of sessions that have already finished here, so at
- * the moment a plan is BUILT the very first file opened after a restart has
- * neither — and the plan is cached, so that file kept answering `null` for the
- * life of the process however many sessions ran afterwards. Measured
- * 2026-08-05: a fresh proxy answered `null` for both, then created the session
- * in 6 ms and produced the first segment in 21 479 ms.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createPlaybackPlanner } from "../services/media/playback-planner.js";
-
-/**
- * A planner whose host timings can be changed between calls, over a source that
- * needs no torrent: transcoding disabled short-circuits to a cached direct plan
- * without probing anything.
- */
-function plannerWithTimings() {
-  const timings = { create: null, first: null };
-  const planner = createPlaybackPlanner({
-    ffmpegBin: "ffmpeg",
-    localBaseUrl: "http://127.0.0.1:9090/stream",
-    sourceRegistry: { get: () => ({ sourceType: "magnet", source: "magnet:?xt=urn:btih:0" }) },
-    torrentPool: { getTorrent: async () => ({ files: [{ name: "a.mkv", length: 10 }] }) },
-    transcodeAudioEnabled: false,
-    expectedSessionCreateMs: () => timings.create,
-    expectedFirstSegmentMs: () => timings.first
-  });
-  return { planner, timings };
-}
-
-test("a plan built before the host had measured anything still reports them later", async () => {
-  const { planner, timings } = plannerWithTimings();
-
-  const cold = await planner.getPlan({ sourceKey: "src", fileIndex: 0 });
-  assert.equal(cold.expectedSessionCreateMs, null, "nothing has finished yet, so there is nothing to report");
-  assert.equal(cold.expectedFirstSegmentMs, null);
-
-  // Sessions run; the host now knows what it costs.
-  timings.create = 6;
-  timings.first = 21_479;
-
-  const warm = await planner.getPlan({ sourceKey: "src", fileIndex: 0 });
-  assert.equal(
-    warm.expectedSessionCreateMs,
-    6,
-    "the cached plan withheld the figure the browser needed"
-  );
-  assert.equal(warm.expectedFirstSegmentMs, 21_479);
-});
-
-test("the figures follow the host as they change", async () => {
-  const { planner, timings } = plannerWithTimings();
-  timings.create = 100;
-  timings.first = 800;
-  const first = await planner.getPlan({ sourceKey: "src", fileIndex: 0 });
-  assert.equal(first.expectedFirstSegmentMs, 800);
-
-  timings.first = 7_000; // a re-encode session — an order of magnitude slower
-  const later = await planner.getPlan({ sourceKey: "src", fileIndex: 0 });
-  assert.equal(later.expectedFirstSegmentMs, 7_000, "the plan reported a stale figure");
-});
+/**
+ * @file The host's own timings must reach the browser for the file that needs
+ * them most.
+ *
+ * The plan carries two figures the browser cannot measure for itself: how long
+ * this host takes to create a session, and how long it takes to produce a first
+ * segment. Both are medians of sessions that have already finished here, so at
+ * the moment a plan is BUILT the very first file opened after a restart has
+ * neither — and the plan is cached, so that file kept answering `null` for the
+ * life of the process however many sessions ran afterwards. Measured
+ * 2026-08-05: a fresh proxy answered `null` for both, then created the session
+ * in 6 ms and produced the first segment in 21 479 ms.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createPlaybackPlanner } from "../services/media/playback-planner.js";
+
+/**
+ * A planner whose host timings can be changed between calls, over a source that
+ * needs no torrent: transcoding disabled short-circuits to a cached direct plan
+ * without probing anything.
+ */
+function plannerWithTimings() {
+  const timings = { create: null, first: null };
+  const planner = createPlaybackPlanner({
+    ffmpegBin: "ffmpeg",
+    localBaseUrl: "http://127.0.0.1:9090/stream",
+    sourceRegistry: { get: () => ({ sourceType: "magnet", source: "magnet:?xt=urn:btih:0" }) },
+    torrentPool: { getTorrent: async () => ({ files: [{ name: "a.mkv", length: 10 }] }) },
+    transcodeAudioEnabled: false,
+    expectedSessionCreateMs: () => timings.create,
+    expectedFirstSegmentMs: () => timings.first
+  });
+  return { planner, timings };
+}
+
+test("a plan built before the host had measured anything still reports them later", async () => {
+  const { planner, timings } = plannerWithTimings();
+
+  const cold = await planner.getPlan({ sourceKey: "src", fileIndex: 0 });
+  assert.equal(cold.expectedSessionCreateMs, null, "nothing has finished yet, so there is nothing to report");
+  assert.equal(cold.expectedFirstSegmentMs, null);
+
+  // Sessions run; the host now knows what it costs.
+  timings.create = 6;
+  timings.first = 21_479;
+
+  const warm = await planner.getPlan({ sourceKey: "src", fileIndex: 0 });
+  assert.equal(
+    warm.expectedSessionCreateMs,
+    6,
+    "the cached plan withheld the figure the browser needed"
+  );
+  assert.equal(warm.expectedFirstSegmentMs, 21_479);
+});
+
+test("the figures follow the host as they change", async () => {
+  const { planner, timings } = plannerWithTimings();
+  timings.create = 100;
+  timings.first = 800;
+  const first = await planner.getPlan({ sourceKey: "src", fileIndex: 0 });
+  assert.equal(first.expectedFirstSegmentMs, 800);
+
+  timings.first = 7_000; // a re-encode session — an order of magnitude slower
+  const later = await planner.getPlan({ sourceKey: "src", fileIndex: 0 });
+  assert.equal(later.expectedFirstSegmentMs, 7_000, "the plan reported a stale figure");
+});