@torrent-tv/proxy 2.87.4 → 2.87.5

package/test/fastest-wires.test.js

@@ -1,143 +1,143 @@
-/**
- * @file Choosing who is asked for the piece a reader is blocked on.
- *
- * The measurement behind it (2026-08-17): a fivefold bandwidth surplus and 47
- * blocking waits in two minutes, on pieces a median of five peers already had.
- * A block belongs to one wire, so the read ends when the SLOWEST holder
- * delivers — which makes "who holds it" the thing worth deciding.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { askFastestWiresFor, canPlaceRequests, wiresForPiece } from "../services/torrent/worker/fastest-wires.js";
-
-/**
- * @param {{ speed: number, has?: boolean, choking?: boolean, destroyed?: boolean }} options
- * @returns {object}
- */
-function wire({ speed, has = true, choking = false, destroyed = false }) {
-  return {
-    destroyed,
-    peerChoking: choking,
-    peerPieces: { get: () => has },
-    downloadSpeed: () => speed
-  };
-}
-
-/**
- * @param {object[]} wires
- * @returns {{ torrent: object, asked: Array<{ speed: number, hotswap: boolean }> }}
- */
-function torrentWith(wires, { refuse = false } = {}) {
-  /** @type {Array<{ speed: number, hotswap: boolean }>} */
-  const asked = [];
-  const torrent = {
-    wires,
-    _request(target, _index, hotswap) {
-      asked.push({ speed: target.downloadSpeed(), hotswap });
-      return !refuse;
-    }
-  };
-  return { torrent, asked };
-}
-
-test("the fastest holders are asked first", () => {
-  const { torrent, asked } = torrentWith([
-    wire({ speed: 100_000 }),
-    wire({ speed: 900_000 }),
-    wire({ speed: 400_000 })
-  ]);
-
-  const result = askFastestWiresFor(torrent, 42);
-
-  assert.deepEqual(
-    asked.map((entry) => entry.speed),
-    [900_000, 400_000, 100_000],
-    "fastest first — the read ends when the slowest holder delivers"
-  );
-  assert.equal(result.asked, 3);
-  assert.equal(result.fastestBytesPerSecond, 900_000);
-});
-
-test("hotswap is always on, because that is the whole point", () => {
-  // The reader is blocked precisely because every block is reserved and one of
-  // them sits with a slow wire. Without hotswap the library answers "nothing to
-  // reserve" and the lever does nothing at all.
-  const { torrent, asked } = torrentWith([wire({ speed: 10 })]);
-  askFastestWiresFor(torrent, 7);
-  assert.deepEqual(asked.map((entry) => entry.hotswap), [true]);
-});
-
-test("a wire that cannot deliver is not asked", () => {
-  const { torrent, asked } = torrentWith([
-    wire({ speed: 900_000, choking: true }),
-    wire({ speed: 800_000, has: false }),
-    wire({ speed: 700_000, destroyed: true }),
-    wire({ speed: 1_000 })
-  ]);
-
-  const result = askFastestWiresFor(torrent, 3);
-
-  assert.equal(asked.length, 1, "a choking, an absent and a dead wire are all unusable");
-  assert.equal(result.considered, 1);
-});
-
-test("a refusal is counted as a refusal", () => {
-  // The library refuses when a wire's pipeline is full or nothing can be
-  // reserved even with hotswap. That is information: the piece is waiting on
-  // the wire, not on the picker.
-  const { torrent } = torrentWith([wire({ speed: 500 }), wire({ speed: 400 })], { refuse: true });
-  const result = askFastestWiresFor(torrent, 11);
-  assert.equal(result.asked, 0);
-  assert.equal(result.considered, 2);
-  // Refused, but not because every block was spoken for — this stub has no
-  // reservations at all. The two reasons are different and only the second is
-  // the one WebTorrent's displacement thresholds decide.
-  assert.equal(result.refusedWhileReserved, 0);
-});
-
-test("a refusal with every block already reserved is counted separately", () => {
-  // The interesting refusal: a fast peer we picked was turned away because
-  // every block belongs to somebody else and displacement did not happen. The
-  // thresholds that decide it are constants in the library — the asker above
-  // 16 KB/s, the holder below 48 KB/s and twice as slow — so a holder at
-  // 50 KB/s is never displaced however long the piece has waited. This number
-  // is what would justify replacing that rule.
-  const { torrent } = torrentWith([wire({ speed: 500 })], { refuse: true });
-  torrent.pieces = [];
-  torrent.pieces[11] = { reserve: () => -1, cancel: () => undefined };
-  const result = askFastestWiresFor(torrent, 11);
-  assert.equal(result.asked, 0);
-  assert.equal(result.refusedWhileReserved, 1);
-});
-
-test("a build without the request entry is reported, not silently skipped", () => {
-  assert.equal(canPlaceRequests({ wires: [] }), false);
-  assert.equal(canPlaceRequests({ wires: [], _request: () => true }), true);
-  const result = askFastestWiresFor({ wires: [wire({ speed: 1 })] }, 1);
-  assert.deepEqual(
-    result,
-    { asked: 0, refusedWhileReserved: 0, attempted: 0, considered: 0, fastestBytesPerSecond: 0 }
-  );
-});
-
-test("a wire that cannot say how fast it is ranks last rather than throwing", () => {
-  const mute = wire({ speed: 0 });
-  mute.downloadSpeed = () => {
-    throw new Error("destroyed");
-  };
-  const ranked = wiresForPiece({ wires: [mute, wire({ speed: 5 })] }, 0);
-  assert.equal(ranked.length, 2);
-  assert.equal(ranked[0].downloadSpeed(), 5);
-});
-
-test("a throw from the library is raised, never swallowed", () => {
-  const torrent = {
-    wires: [wire({ speed: 1 })],
-    _request() {
-      throw new Error("internal");
-    }
-  };
-  assert.throws(() => askFastestWiresFor(torrent, 5), /could not place a request for piece 5/);
-});
+/**
+ * @file Choosing who is asked for the piece a reader is blocked on.
+ *
+ * The measurement behind it (2026-08-17): a fivefold bandwidth surplus and 47
+ * blocking waits in two minutes, on pieces a median of five peers already had.
+ * A block belongs to one wire, so the read ends when the SLOWEST holder
+ * delivers — which makes "who holds it" the thing worth deciding.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { askFastestWiresFor, canPlaceRequests, wiresForPiece } from "../services/torrent/worker/fastest-wires.js";
+
+/**
+ * @param {{ speed: number, has?: boolean, choking?: boolean, destroyed?: boolean }} options
+ * @returns {object}
+ */
+function wire({ speed, has = true, choking = false, destroyed = false }) {
+  return {
+    destroyed,
+    peerChoking: choking,
+    peerPieces: { get: () => has },
+    downloadSpeed: () => speed
+  };
+}
+
+/**
+ * @param {object[]} wires
+ * @returns {{ torrent: object, asked: Array<{ speed: number, hotswap: boolean }> }}
+ */
+function torrentWith(wires, { refuse = false } = {}) {
+  /** @type {Array<{ speed: number, hotswap: boolean }>} */
+  const asked = [];
+  const torrent = {
+    wires,
+    _request(target, _index, hotswap) {
+      asked.push({ speed: target.downloadSpeed(), hotswap });
+      return !refuse;
+    }
+  };
+  return { torrent, asked };
+}
+
+test("the fastest holders are asked first", () => {
+  const { torrent, asked } = torrentWith([
+    wire({ speed: 100_000 }),
+    wire({ speed: 900_000 }),
+    wire({ speed: 400_000 })
+  ]);
+
+  const result = askFastestWiresFor(torrent, 42);
+
+  assert.deepEqual(
+    asked.map((entry) => entry.speed),
+    [900_000, 400_000, 100_000],
+    "fastest first — the read ends when the slowest holder delivers"
+  );
+  assert.equal(result.asked, 3);
+  assert.equal(result.fastestBytesPerSecond, 900_000);
+});
+
+test("hotswap is always on, because that is the whole point", () => {
+  // The reader is blocked precisely because every block is reserved and one of
+  // them sits with a slow wire. Without hotswap the library answers "nothing to
+  // reserve" and the lever does nothing at all.
+  const { torrent, asked } = torrentWith([wire({ speed: 10 })]);
+  askFastestWiresFor(torrent, 7);
+  assert.deepEqual(asked.map((entry) => entry.hotswap), [true]);
+});
+
+test("a wire that cannot deliver is not asked", () => {
+  const { torrent, asked } = torrentWith([
+    wire({ speed: 900_000, choking: true }),
+    wire({ speed: 800_000, has: false }),
+    wire({ speed: 700_000, destroyed: true }),
+    wire({ speed: 1_000 })
+  ]);
+
+  const result = askFastestWiresFor(torrent, 3);
+
+  assert.equal(asked.length, 1, "a choking, an absent and a dead wire are all unusable");
+  assert.equal(result.considered, 1);
+});
+
+test("a refusal is counted as a refusal", () => {
+  // The library refuses when a wire's pipeline is full or nothing can be
+  // reserved even with hotswap. That is information: the piece is waiting on
+  // the wire, not on the picker.
+  const { torrent } = torrentWith([wire({ speed: 500 }), wire({ speed: 400 })], { refuse: true });
+  const result = askFastestWiresFor(torrent, 11);
+  assert.equal(result.asked, 0);
+  assert.equal(result.considered, 2);
+  // Refused, but not because every block was spoken for — this stub has no
+  // reservations at all. The two reasons are different and only the second is
+  // the one WebTorrent's displacement thresholds decide.
+  assert.equal(result.refusedWhileReserved, 0);
+});
+
+test("a refusal with every block already reserved is counted separately", () => {
+  // The interesting refusal: a fast peer we picked was turned away because
+  // every block belongs to somebody else and displacement did not happen. The
+  // thresholds that decide it are constants in the library — the asker above
+  // 16 KB/s, the holder below 48 KB/s and twice as slow — so a holder at
+  // 50 KB/s is never displaced however long the piece has waited. This number
+  // is what would justify replacing that rule.
+  const { torrent } = torrentWith([wire({ speed: 500 })], { refuse: true });
+  torrent.pieces = [];
+  torrent.pieces[11] = { reserve: () => -1, cancel: () => undefined };
+  const result = askFastestWiresFor(torrent, 11);
+  assert.equal(result.asked, 0);
+  assert.equal(result.refusedWhileReserved, 1);
+});
+
+test("a build without the request entry is reported, not silently skipped", () => {
+  assert.equal(canPlaceRequests({ wires: [] }), false);
+  assert.equal(canPlaceRequests({ wires: [], _request: () => true }), true);
+  const result = askFastestWiresFor({ wires: [wire({ speed: 1 })] }, 1);
+  assert.deepEqual(
+    result,
+    { asked: 0, refusedWhileReserved: 0, attempted: 0, considered: 0, fastestBytesPerSecond: 0 }
+  );
+});
+
+test("a wire that cannot say how fast it is ranks last rather than throwing", () => {
+  const mute = wire({ speed: 0 });
+  mute.downloadSpeed = () => {
+    throw new Error("destroyed");
+  };
+  const ranked = wiresForPiece({ wires: [mute, wire({ speed: 5 })] }, 0);
+  assert.equal(ranked.length, 2);
+  assert.equal(ranked[0].downloadSpeed(), 5);
+});
+
+test("a throw from the library is raised, never swallowed", () => {
+  const torrent = {
+    wires: [wire({ speed: 1 })],
+    _request() {
+      throw new Error("internal");
+    }
+  };
+  assert.throws(() => askFastestWiresFor(torrent, 5), /could not place a request for piece 5/);
+});

package/test/ffmpeg-stream-counts.test.js

@@ -1,78 +1,78 @@
-/**
- * @file What the source said it holds, read from ffmpeg's own banner.
- *
- * The reading exists for one failure: every `-map` this proxy builds ends in
- * `?`, so ffmpeg drops a mapping for a stream that is not there and says
- * nothing. Map every stream of a run away that way and the output has nothing
- * in it — `Output file does not contain any stream`, exit 255. Three sessions
- * died that way on 2026-08-26 and the log held only the code.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { parseFfmpegStreamCounts } from "../services/media/ffmpeg-banner.js";
-
-const FIELD_BANNER = `
-Input #0, matroska,webm, from 'http://127.0.0.1:9090/stream?sourceKey=b3f08efc':
-  Duration: 01:32:39.00, start: 0.000000, bitrate: 9354 kb/s
-  Stream #0:0: Video: h264 (High), yuv420p(progressive), 1920x1080, 23.98 fps
-  Stream #0:1(rus): Audio: ac3, 48000 Hz, 5.1, fltp, 640 kb/s
-  Stream #0:2(eng): Audio: aac, 48000 Hz, stereo, fltp, 128 kb/s
-  Stream #0:3(rus): Subtitle: subrip
-  Stream #0:4(eng): Subtitle: hdmv_pgs_subtitle
-`;
-
-test("each stream is counted under the type ffmpeg names it", () => {
-  assert.deepEqual(parseFfmpegStreamCounts(FIELD_BANNER), {
-    video: 1,
-    audio: 2,
-    subtitle: 2,
-    other: 0
-  });
-});
-
-test("a file with no audio is what makes an audio-only run produce nothing", () => {
-  // This is the shape the diagnostic is for: the rendition asks for `0:a:0?`,
-  // the file has no audio at all, the mapping is dropped in silence and the
-  // segment muxer is handed an output with no streams.
-  const counts = parseFfmpegStreamCounts(`
-  Stream #0:0: Video: hevc (Main 10), yuv420p10le, 3840x2160, 23.98 fps
-  `);
-  assert.equal(counts.audio, 0);
-  assert.equal(counts.video, 1);
-});
-
-test("an audio index past the end of the list is OUR fault, and the counts say so", () => {
-  // A viewer picking the third dub on a file carrying one: `0:a:2?` drops, and
-  // the count is what separates that from a source that delivered nothing.
-  const counts = parseFfmpegStreamCounts(FIELD_BANNER);
-  const askedFor = 4;
-  assert.ok(askedFor >= counts.audio, "the request is outside what the file holds");
-});
-
-test("an attached cover image is counted as video, because that is what would be mapped", () => {
-  const counts = parseFfmpegStreamCounts(`
-  Stream #0:0: Audio: mp3, 44100 Hz, stereo, fltp, 320 kb/s
-  Stream #0:1: Video: mjpeg (Baseline), yuvj420p(pc), 600x600 (attached pic)
-  `);
-  assert.equal(counts.video, 1);
-  assert.equal(counts.audio, 1);
-});
-
-test("a banner carrying no stream lines is not the same as a file with no streams", () => {
-  // Null says "not recorded"; zeroes would claim a measurement nobody took.
-  assert.equal(parseFfmpegStreamCounts("Duration: 00:10:00.00, start: 0.000000"), null);
-  assert.equal(parseFfmpegStreamCounts(""), null);
-  assert.equal(parseFfmpegStreamCounts(undefined), null);
-});
-
-test("a stream carrying metadata in brackets is still read", () => {
-  // MP4 writes `Stream #0:1[0x2](eng)`, which the earlier shape of this regex
-  // would have skipped.
-  const counts = parseFfmpegStreamCounts(`
-  Stream #0:0[0x1](und): Video: h264 (avc1), yuv420p, 1280x720, 24 fps
-  Stream #0:1[0x2](eng): Audio: aac (mp4a), 48000 Hz, stereo, fltp
-  `);
-  assert.deepEqual(counts, { video: 1, audio: 1, subtitle: 0, other: 0 });
-});
+/**
+ * @file What the source said it holds, read from ffmpeg's own banner.
+ *
+ * The reading exists for one failure: every `-map` this proxy builds ends in
+ * `?`, so ffmpeg drops a mapping for a stream that is not there and says
+ * nothing. Map every stream of a run away that way and the output has nothing
+ * in it — `Output file does not contain any stream`, exit 255. Three sessions
+ * died that way on 2026-08-26 and the log held only the code.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseFfmpegStreamCounts } from "../services/media/ffmpeg-banner.js";
+
+const FIELD_BANNER = `
+Input #0, matroska,webm, from 'http://127.0.0.1:9090/stream?sourceKey=b3f08efc':
+  Duration: 01:32:39.00, start: 0.000000, bitrate: 9354 kb/s
+  Stream #0:0: Video: h264 (High), yuv420p(progressive), 1920x1080, 23.98 fps
+  Stream #0:1(rus): Audio: ac3, 48000 Hz, 5.1, fltp, 640 kb/s
+  Stream #0:2(eng): Audio: aac, 48000 Hz, stereo, fltp, 128 kb/s
+  Stream #0:3(rus): Subtitle: subrip
+  Stream #0:4(eng): Subtitle: hdmv_pgs_subtitle
+`;
+
+test("each stream is counted under the type ffmpeg names it", () => {
+  assert.deepEqual(parseFfmpegStreamCounts(FIELD_BANNER), {
+    video: 1,
+    audio: 2,
+    subtitle: 2,
+    other: 0
+  });
+});
+
+test("a file with no audio is what makes an audio-only run produce nothing", () => {
+  // This is the shape the diagnostic is for: the rendition asks for `0:a:0?`,
+  // the file has no audio at all, the mapping is dropped in silence and the
+  // segment muxer is handed an output with no streams.
+  const counts = parseFfmpegStreamCounts(`
+  Stream #0:0: Video: hevc (Main 10), yuv420p10le, 3840x2160, 23.98 fps
+  `);
+  assert.equal(counts.audio, 0);
+  assert.equal(counts.video, 1);
+});
+
+test("an audio index past the end of the list is OUR fault, and the counts say so", () => {
+  // A viewer picking the third dub on a file carrying one: `0:a:2?` drops, and
+  // the count is what separates that from a source that delivered nothing.
+  const counts = parseFfmpegStreamCounts(FIELD_BANNER);
+  const askedFor = 4;
+  assert.ok(askedFor >= counts.audio, "the request is outside what the file holds");
+});
+
+test("an attached cover image is counted as video, because that is what would be mapped", () => {
+  const counts = parseFfmpegStreamCounts(`
+  Stream #0:0: Audio: mp3, 44100 Hz, stereo, fltp, 320 kb/s
+  Stream #0:1: Video: mjpeg (Baseline), yuvj420p(pc), 600x600 (attached pic)
+  `);
+  assert.equal(counts.video, 1);
+  assert.equal(counts.audio, 1);
+});
+
+test("a banner carrying no stream lines is not the same as a file with no streams", () => {
+  // Null says "not recorded"; zeroes would claim a measurement nobody took.
+  assert.equal(parseFfmpegStreamCounts("Duration: 00:10:00.00, start: 0.000000"), null);
+  assert.equal(parseFfmpegStreamCounts(""), null);
+  assert.equal(parseFfmpegStreamCounts(undefined), null);
+});
+
+test("a stream carrying metadata in brackets is still read", () => {
+  // MP4 writes `Stream #0:1[0x2](eng)`, which the earlier shape of this regex
+  // would have skipped.
+  const counts = parseFfmpegStreamCounts(`
+  Stream #0:0[0x1](und): Video: h264 (avc1), yuv420p, 1280x720, 24 fps
+  Stream #0:1[0x2](eng): Audio: aac (mp4a), 48000 Hz, stereo, fltp
+  `);
+  assert.deepEqual(counts, { video: 1, audio: 1, subtitle: 0, other: 0 });
+});