@torrent-tv/proxy 2.89.7 → 2.89.9

package/test/dead-torrent-handle.test.js

@@ -1,52 +1,52 @@
-/**
- * @file A torrent that was destroyed must not be handed to a reader.
- *
- * The worker remembers each source as a promise, and only ever forgot one when
- * the ADD failed. But the pool destroys a torrent that has gone unread for a
- * quarter of an hour, and under disk pressure — clearing its own map, not this
- * one. The promise then went on resolving to a corpse: a destroyed torrent
- * keeps its object and loses its files.
- *
- * What that did to a viewer, measured 2026-08-06 on two sessions in a row: the
- * plan answered from cache in 23 ms, the session was created from cache in
- * 2 ms, nothing waited for metadata because everything believed the torrent was
- * known, and ffmpeg's first read died 130 ms in with `File 0 not found`. Every
- * request for the playlist then answered 500 until the viewer gave up.
- *
- * The rule under test is the whole fix: a handle that cannot be read from is
- * not returned, it is replaced.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { isUsableTorrentHandle } from "../services/torrent/worker/handle-state.js";
-
-test("a live torrent is usable", () => {
-  assert.equal(isUsableTorrentHandle({ destroyed: false, files: [{ name: "a.mkv" }] }), true);
-});
-
-test("a destroyed torrent is not, even while it still lists files", () => {
-  assert.equal(
-    isUsableTorrentHandle({ destroyed: true, files: [{ name: "a.mkv" }] }),
-    false,
-    "WebTorrent's own flag is the earliest signal that a handle is finished"
-  );
-});
-
-test("a torrent with no files is not — that is what the reader actually hits", () => {
-  assert.equal(
-    isUsableTorrentHandle({ destroyed: false, files: [] }),
-    false,
-    "an empty file list is what produced `File 0 not found` in the field"
-  );
-  assert.equal(
-    isUsableTorrentHandle({ destroyed: false }),
-    false,
-    "and a handle with no file list at all is the same case"
-  );
-});
-
-test("nothing at all is not usable", () => {
-  assert.equal(isUsableTorrentHandle(null), false);
-  assert.equal(isUsableTorrentHandle(undefined), false);
-});
+/**
+ * @file A torrent that was destroyed must not be handed to a reader.
+ *
+ * The worker remembers each source as a promise, and only ever forgot one when
+ * the ADD failed. But the pool destroys a torrent that has gone unread for a
+ * quarter of an hour, and under disk pressure — clearing its own map, not this
+ * one. The promise then went on resolving to a corpse: a destroyed torrent
+ * keeps its object and loses its files.
+ *
+ * What that did to a viewer, measured 2026-08-06 on two sessions in a row: the
+ * plan answered from cache in 23 ms, the session was created from cache in
+ * 2 ms, nothing waited for metadata because everything believed the torrent was
+ * known, and ffmpeg's first read died 130 ms in with `File 0 not found`. Every
+ * request for the playlist then answered 500 until the viewer gave up.
+ *
+ * The rule under test is the whole fix: a handle that cannot be read from is
+ * not returned, it is replaced.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { isUsableTorrentHandle } from "../services/torrent/worker/handle-state.js";
+
+test("a live torrent is usable", () => {
+  assert.equal(isUsableTorrentHandle({ destroyed: false, files: [{ name: "a.mkv" }] }), true);
+});
+
+test("a destroyed torrent is not, even while it still lists files", () => {
+  assert.equal(
+    isUsableTorrentHandle({ destroyed: true, files: [{ name: "a.mkv" }] }),
+    false,
+    "WebTorrent's own flag is the earliest signal that a handle is finished"
+  );
+});
+
+test("a torrent with no files is not — that is what the reader actually hits", () => {
+  assert.equal(
+    isUsableTorrentHandle({ destroyed: false, files: [] }),
+    false,
+    "an empty file list is what produced `File 0 not found` in the field"
+  );
+  assert.equal(
+    isUsableTorrentHandle({ destroyed: false }),
+    false,
+    "and a handle with no file list at all is the same case"
+  );
+});
+
+test("nothing at all is not usable", () => {
+  assert.equal(isUsableTorrentHandle(null), false);
+  assert.equal(isUsableTorrentHandle(undefined), false);
+});

package/test/declared-rates.test.js

@@ -1,116 +1,116 @@
-/**
- * @file What the master playlist declares a variant carries.
- *
- * Measured, and the measurement was available all along: it used to be
- * `height * height * 3.2`, justified by a comment saying no measurement existed
- * before encoding starts. Field 2026-09-08: 3.73 Mbit/s declared for a file
- * carrying 18.4, and the browser sizes its cushion in BYTES from that figure —
- * 120 s asked bought 26 s of film, and the deepest it ever held was 17.1 s.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { declaredRates } from "../services/encode/output/rates.js";
-import { bitrateFor } from "../services/encode/output/playlists.js";
-
-// The field file: 2 806 246 976 bytes over 20:18, cut into 291 pieces.
-const FIELD = { fileLength: 2_806_246_976, durationSeconds: 1218.73 };
-
-test("the average is the file's own length over its duration", () => {
-  const { averageBitsPerSecond } = declaredRates(FIELD);
-
-  // 18.4 Mbit/s, against the 3.73 that was declared.
-  assert.ok(
-    Math.abs(averageBitsPerSecond / 1_000_000 - 18.42) < 0.01,
-    `got ${averageBitsPerSecond}`
-  );
-});
-
-test("nothing measured is stated as nothing, not as a guess", () => {
-  assert.deepEqual(
-    declaredRates({ fileLength: 0, durationSeconds: 0 }),
-    { averageBitsPerSecond: 0, peakOverAverage: 1 }
-  );
-  assert.deepEqual(
-    declaredRates({ fileLength: 100, durationSeconds: 0 }),
-    { averageBitsPerSecond: 0, peakOverAverage: 1 }
-  );
-});
-
-test("the peak comes from the biggest piece made and the span it covers", () => {
-  // The field peak: 38.4 MB over 4.2 s is 73 Mbit/s, four times the average.
-  const boundaries = Array.from({ length: 292 }, (_, index) => index * 4.2);
-  const { averageBitsPerSecond, peakOverAverage } = declaredRates({
-    ...FIELD,
-    largest: { index: 2, size: 40_288_299 },
-    boundaries
-  });
-
-  const peak = averageBitsPerSecond * peakOverAverage;
-  assert.ok(Math.abs(peak / 1_000_000 - 76.7) < 0.5, `got ${peak / 1_000_000}Mbit/s`);
-});
-
-test("no piece made yet means the peak is not yet measured, so it equals the average", () => {
-  // A ratio invented meanwhile is exactly the fabrication this replaced.
-  assert.equal(declaredRates(FIELD).peakOverAverage, 1);
-  assert.equal(
-    declaredRates({ ...FIELD, largest: { index: -1, size: 0 }, boundaries: [0, 4] }).peakOverAverage,
-    1
-  );
-});
-
-test("the peak is never below the average", () => {
-  // A short session whose only piece happens to be a small one must not lower
-  // the figure the player sizes its cushion from.
-  const boundaries = Array.from({ length: 292 }, (_, index) => index * 4.2);
-  assert.equal(
-    declaredRates({ ...FIELD, largest: { index: 5, size: 1000 }, boundaries }).peakOverAverage,
-    1
-  );
-});
-
-test("a smaller picture is declared at the pixel share of the source's rate", () => {
-  const measured = 18_420_000;
-
-  assert.equal(
-    bitrateFor({ averageBitsPerSecond: measured, height: 1080, sourceHeight: 1080 }),
-    Math.round(measured),
-    "the source's own height carries the source's bits"
-  );
-  assert.equal(
-    bitrateFor({ averageBitsPerSecond: measured, height: 2160, sourceHeight: 1080 }),
-    Math.round(measured),
-    "and a height above it carries no more — there is nothing to upscale from"
-  );
-  assert.equal(
-    bitrateFor({ averageBitsPerSecond: measured, height: 540, sourceHeight: 1080 }),
-    Math.round(measured / 4),
-    "half the height is a quarter of the pixels"
-  );
-});
-
-test("a capped height is declared at its cap, which is exact", () => {
-  assert.equal(
-    bitrateFor({ averageBitsPerSecond: 18_420_000, height: 720, sourceHeight: 1080, capKbps: 2500 }),
-    2_500_000,
-    "what we impose is known, not estimated"
-  );
-  assert.equal(
-    bitrateFor({ averageBitsPerSecond: 1_000_000, height: 1080, sourceHeight: 1080, capKbps: 99_000 }),
-    1_000_000,
-    "and a cap above what the source carries takes nothing away from it"
-  );
-});
-
-test("the floor is a floor on what may be declared, not a belief about content", () => {
-  assert.equal(
-    bitrateFor({ averageBitsPerSecond: 0, height: 1080, sourceHeight: 1080 }),
-    400_000,
-    "a file whose rate is not known yet"
-  );
-  assert.equal(
-    bitrateFor({ averageBitsPerSecond: 18_420_000, height: 4, sourceHeight: 1080 }),
-    400_000,
-    "and a variant so small the arithmetic would go under it"
-  );
-});
+/**
+ * @file What the master playlist declares a variant carries.
+ *
+ * Measured, and the measurement was available all along: it used to be
+ * `height * height * 3.2`, justified by a comment saying no measurement existed
+ * before encoding starts. Field 2026-09-08: 3.73 Mbit/s declared for a file
+ * carrying 18.4, and the browser sizes its cushion in BYTES from that figure —
+ * 120 s asked bought 26 s of film, and the deepest it ever held was 17.1 s.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { declaredRates } from "../services/encode/output/rates.js";
+import { bitrateFor } from "../services/encode/output/playlists.js";
+
+// The field file: 2 806 246 976 bytes over 20:18, cut into 291 pieces.
+const FIELD = { fileLength: 2_806_246_976, durationSeconds: 1218.73 };
+
+test("the average is the file's own length over its duration", () => {
+  const { averageBitsPerSecond } = declaredRates(FIELD);
+
+  // 18.4 Mbit/s, against the 3.73 that was declared.
+  assert.ok(
+    Math.abs(averageBitsPerSecond / 1_000_000 - 18.42) < 0.01,
+    `got ${averageBitsPerSecond}`
+  );
+});
+
+test("nothing measured is stated as nothing, not as a guess", () => {
+  assert.deepEqual(
+    declaredRates({ fileLength: 0, durationSeconds: 0 }),
+    { averageBitsPerSecond: 0, peakOverAverage: 1 }
+  );
+  assert.deepEqual(
+    declaredRates({ fileLength: 100, durationSeconds: 0 }),
+    { averageBitsPerSecond: 0, peakOverAverage: 1 }
+  );
+});
+
+test("the peak comes from the biggest piece made and the span it covers", () => {
+  // The field peak: 38.4 MB over 4.2 s is 73 Mbit/s, four times the average.
+  const boundaries = Array.from({ length: 292 }, (_, index) => index * 4.2);
+  const { averageBitsPerSecond, peakOverAverage } = declaredRates({
+    ...FIELD,
+    largest: { index: 2, size: 40_288_299 },
+    boundaries
+  });
+
+  const peak = averageBitsPerSecond * peakOverAverage;
+  assert.ok(Math.abs(peak / 1_000_000 - 76.7) < 0.5, `got ${peak / 1_000_000}Mbit/s`);
+});
+
+test("no piece made yet means the peak is not yet measured, so it equals the average", () => {
+  // A ratio invented meanwhile is exactly the fabrication this replaced.
+  assert.equal(declaredRates(FIELD).peakOverAverage, 1);
+  assert.equal(
+    declaredRates({ ...FIELD, largest: { index: -1, size: 0 }, boundaries: [0, 4] }).peakOverAverage,
+    1
+  );
+});
+
+test("the peak is never below the average", () => {
+  // A short session whose only piece happens to be a small one must not lower
+  // the figure the player sizes its cushion from.
+  const boundaries = Array.from({ length: 292 }, (_, index) => index * 4.2);
+  assert.equal(
+    declaredRates({ ...FIELD, largest: { index: 5, size: 1000 }, boundaries }).peakOverAverage,
+    1
+  );
+});
+
+test("a smaller picture is declared at the pixel share of the source's rate", () => {
+  const measured = 18_420_000;
+
+  assert.equal(
+    bitrateFor({ averageBitsPerSecond: measured, height: 1080, sourceHeight: 1080 }),
+    Math.round(measured),
+    "the source's own height carries the source's bits"
+  );
+  assert.equal(
+    bitrateFor({ averageBitsPerSecond: measured, height: 2160, sourceHeight: 1080 }),
+    Math.round(measured),
+    "and a height above it carries no more — there is nothing to upscale from"
+  );
+  assert.equal(
+    bitrateFor({ averageBitsPerSecond: measured, height: 540, sourceHeight: 1080 }),
+    Math.round(measured / 4),
+    "half the height is a quarter of the pixels"
+  );
+});
+
+test("a capped height is declared at its cap, which is exact", () => {
+  assert.equal(
+    bitrateFor({ averageBitsPerSecond: 18_420_000, height: 720, sourceHeight: 1080, capKbps: 2500 }),
+    2_500_000,
+    "what we impose is known, not estimated"
+  );
+  assert.equal(
+    bitrateFor({ averageBitsPerSecond: 1_000_000, height: 1080, sourceHeight: 1080, capKbps: 99_000 }),
+    1_000_000,
+    "and a cap above what the source carries takes nothing away from it"
+  );
+});
+
+test("the floor is a floor on what may be declared, not a belief about content", () => {
+  assert.equal(
+    bitrateFor({ averageBitsPerSecond: 0, height: 1080, sourceHeight: 1080 }),
+    400_000,
+    "a file whose rate is not known yet"
+  );
+  assert.equal(
+    bitrateFor({ averageBitsPerSecond: 18_420_000, height: 4, sourceHeight: 1080 }),
+    400_000,
+    "and a variant so small the arithmetic would go under it"
+  );
+});

package/test/declared-tracks.test.js

@@ -1,43 +1,43 @@
-/**
- * @file What the proxy promises the browser must be answerable.
- *
- * The session manager asks the planner's media-info cache which tracks the
- * output will carry. That cache never held the codecs — it holds dimensions,
- * duration, fps, start time and an HDR flag — so the read produced `undefined`
- * for both and the declaration came out `{video: false, audio: false}` for
- * EVERY session since the check existed. Measured 2026-08-11 in the field.
- *
- * Nothing caught it: the writer and the reader each looked correct alone, and
- * no test ever compared the shape of what is stored with the shape of what is
- * read. That comparison is this file's whole job.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-
-const planner = readFileSync(new URL("../services/media/playback-planner.js", import.meta.url), "utf8");
-const sessions = readFileSync(new URL("../services/encode/Renditions.js", import.meta.url), "utf8");
-
-test("every field the declaration reads is a field the cache stores", () => {
-  // What `declaredTracks` reads off the cached media info.
-  const read = [...sessions.matchAll(/probed\?\.([A-Za-z]+)/g)].map((match) => match[1]);
-  assert.ok(read.length > 0, "the declaration must read something, or it declares nothing");
-
-  const stored = planner.slice(planner.indexOf("mediaInfoCache.set("));
-  for (const field of new Set(read)) {
-    assert.ok(
-      stored.includes(`${field}:`),
-      `the declaration reads "${field}" and the media-info cache never stores it — ` +
-      "the read yields undefined and the promise silently becomes false"
-    );
-  }
-});
-
-test("an empty container track list remains pending for late sidecar metadata", () => {
-  assert.match(
-    planner,
-    /complete: Array\.isArray\(tracks\) && tracks\.length > 0/,
-    "ContainerOrchestrator leaves empty track reads uncached while the header is unavailable"
-  );
-});
+/**
+ * @file What the proxy promises the browser must be answerable.
+ *
+ * The session manager asks the planner's media-info cache which tracks the
+ * output will carry. That cache never held the codecs — it holds dimensions,
+ * duration, fps, start time and an HDR flag — so the read produced `undefined`
+ * for both and the declaration came out `{video: false, audio: false}` for
+ * EVERY session since the check existed. Measured 2026-08-11 in the field.
+ *
+ * Nothing caught it: the writer and the reader each looked correct alone, and
+ * no test ever compared the shape of what is stored with the shape of what is
+ * read. That comparison is this file's whole job.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+
+const planner = readFileSync(new URL("../services/media/playback-planner.js", import.meta.url), "utf8");
+const sessions = readFileSync(new URL("../services/encode/Renditions.js", import.meta.url), "utf8");
+
+test("every field the declaration reads is a field the cache stores", () => {
+  // What `declaredTracks` reads off the cached media info.
+  const read = [...sessions.matchAll(/probed\?\.([A-Za-z]+)/g)].map((match) => match[1]);
+  assert.ok(read.length > 0, "the declaration must read something, or it declares nothing");
+
+  const stored = planner.slice(planner.indexOf("mediaInfoCache.set("));
+  for (const field of new Set(read)) {
+    assert.ok(
+      stored.includes(`${field}:`),
+      `the declaration reads "${field}" and the media-info cache never stores it — ` +
+      "the read yields undefined and the promise silently becomes false"
+    );
+  }
+});
+
+test("an empty container track list remains pending for late sidecar metadata", () => {
+  assert.match(
+    planner,
+    /complete: Array\.isArray\(tracks\) && tracks\.length > 0/,
+    "ContainerOrchestrator leaves empty track reads uncached while the header is unavailable"
+  );
+});