@torrent-tv/proxy 2.89.5 → 2.89.7

package/test/video-facts.test.js

@@ -1,102 +1,102 @@
-/**
- * @file The picture's facts, from the two readings that state them.
- *
- * Audio and subtitles have had this reconciliation since their flags were first
- * read from the file. Video never did: every figure the encode is planned from
- * came from ffmpeg's `-i` banner alone, and the `VideoTrack` the container
- * declares was read and then used for nothing but a line in the log — so a file
- * that states its bit depth or its HDR signalling, against a probe that does
- * not print them, disagreed with nobody watching.
- *
- * What each check pins is WHICH reading answers, and why: the size and the
- * frame rate are what the decoder will produce, so the probe answers; the bit
- * depth and the HDR signalling are the file saying how its samples are to be
- * read, so the container answers.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { Container } from "../services/media/container/Container.js";
-
-const banner = (fields) => ({ width: null, height: null, fps: null, isHdr: false, bitDepth: null, ...fields });
-
-test("with no container reading the probe answers for everything", () => {
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 1920, height: 1080, fps: 23.976, isHdr: true, bitDepth: 10 }),
-    null
-  );
-  assert.equal(facts.width, 1920);
-  assert.equal(facts.height, 1080);
-  assert.equal(facts.fps, 23.976);
-  assert.equal(facts.isHdr, true);
-  assert.equal(facts.bitDepth, 10);
-  assert.deepEqual(facts.disagreements, []);
-});
-
-test("the size and the frame rate are the probe's, because that is what will be decoded", () => {
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 1920, height: 1080, fps: 24 }),
-    { width: 1440, height: 1080, fps: 25, displayWidth: 1920, displayHeight: 1080 }
-  );
-  assert.equal(facts.width, 1920, "the ladder and the scale filter are sized to the decoded frame");
-  assert.equal(facts.height, 1080);
-  assert.equal(facts.fps, 24);
-});
-
-test("the bit depth and the HDR signalling are the file's, because the file states them", () => {
-  // A ten-bit HEVC whose probe printed neither: this is the case that decides
-  // whether tone mapping runs and how the decode cost is priced.
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 3840, height: 2160, fps: 24 }),
-    { width: 3840, height: 2160, bitDepth: 10, isHdr: true }
-  );
-  assert.equal(facts.bitDepth, 10);
-  assert.equal(facts.isHdr, true);
-  assert.deepEqual(facts.disagreements, [], "one side saying nothing is not a disagreement");
-});
-
-test("a field only the probe states is still answered", () => {
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 1280, height: 720, fps: 30, bitDepth: 8 }),
-    { width: null, height: null, fps: null, bitDepth: null }
-  );
-  assert.equal(facts.width, 1280);
-  assert.equal(facts.bitDepth, 8);
-});
-
-test("a real disagreement is reported, with both values and which is which", () => {
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 1920, height: 1080, bitDepth: 8, isHdr: false }),
-    { width: 1280, height: 720, bitDepth: 10, isHdr: true }
-  );
-  assert.equal(facts.disagreements.length, 3);
-  assert.ok(facts.disagreements.some((line) => /width 1280 in the container against 1920 in the probe/.test(line)));
-  assert.ok(facts.disagreements.some((line) => /bit depth 10 in the container against 8 in the probe/.test(line)));
-  // HDR is not among them, and cannot be: see `mergeVideoFacts`.
-  assert.ok(!facts.disagreements.some((line) => /HDR/.test(line)));
-  // And the rule still decides: the probe for the size, the file for the rest.
-  assert.equal(facts.width, 1920);
-  assert.equal(facts.bitDepth, 10);
-  assert.equal(facts.isHdr, true);
-});
-
-test("the display size is the container's alone — the probe has no such field", () => {
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 1440, height: 1080 }),
-    { width: 1440, height: 1080, displayWidth: 1920, displayHeight: 1080 }
-  );
-  assert.equal(facts.displayWidth, 1920);
-  assert.equal(facts.displayHeight, 1080);
-});
-
-test("zero and nonsense are not values", () => {
-  const facts = Container.mergeVideoFacts(
-    banner({ width: 0, height: 0, fps: 0, bitDepth: 0 }),
-    { width: 1920, height: 1080, fps: 24, bitDepth: 8 }
-  );
-  assert.equal(facts.width, 1920, "a probe that printed nothing does not outrank a file that speaks");
-  assert.equal(facts.fps, 24);
-  assert.equal(facts.bitDepth, 8);
-  assert.deepEqual(facts.disagreements, []);
-});
+/**
+ * @file The picture's facts, from the two readings that state them.
+ *
+ * Audio and subtitles have had this reconciliation since their flags were first
+ * read from the file. Video never did: every figure the encode is planned from
+ * came from ffmpeg's `-i` banner alone, and the `VideoTrack` the container
+ * declares was read and then used for nothing but a line in the log — so a file
+ * that states its bit depth or its HDR signalling, against a probe that does
+ * not print them, disagreed with nobody watching.
+ *
+ * What each check pins is WHICH reading answers, and why: the size and the
+ * frame rate are what the decoder will produce, so the probe answers; the bit
+ * depth and the HDR signalling are the file saying how its samples are to be
+ * read, so the container answers.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { Container } from "../services/media/container/Container.js";
+
+const banner = (fields) => ({ width: null, height: null, fps: null, isHdr: false, bitDepth: null, ...fields });
+
+test("with no container reading the probe answers for everything", () => {
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 1920, height: 1080, fps: 23.976, isHdr: true, bitDepth: 10 }),
+    null
+  );
+  assert.equal(facts.width, 1920);
+  assert.equal(facts.height, 1080);
+  assert.equal(facts.fps, 23.976);
+  assert.equal(facts.isHdr, true);
+  assert.equal(facts.bitDepth, 10);
+  assert.deepEqual(facts.disagreements, []);
+});
+
+test("the size and the frame rate are the probe's, because that is what will be decoded", () => {
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 1920, height: 1080, fps: 24 }),
+    { width: 1440, height: 1080, fps: 25, displayWidth: 1920, displayHeight: 1080 }
+  );
+  assert.equal(facts.width, 1920, "the ladder and the scale filter are sized to the decoded frame");
+  assert.equal(facts.height, 1080);
+  assert.equal(facts.fps, 24);
+});
+
+test("the bit depth and the HDR signalling are the file's, because the file states them", () => {
+  // A ten-bit HEVC whose probe printed neither: this is the case that decides
+  // whether tone mapping runs and how the decode cost is priced.
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 3840, height: 2160, fps: 24 }),
+    { width: 3840, height: 2160, bitDepth: 10, isHdr: true }
+  );
+  assert.equal(facts.bitDepth, 10);
+  assert.equal(facts.isHdr, true);
+  assert.deepEqual(facts.disagreements, [], "one side saying nothing is not a disagreement");
+});
+
+test("a field only the probe states is still answered", () => {
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 1280, height: 720, fps: 30, bitDepth: 8 }),
+    { width: null, height: null, fps: null, bitDepth: null }
+  );
+  assert.equal(facts.width, 1280);
+  assert.equal(facts.bitDepth, 8);
+});
+
+test("a real disagreement is reported, with both values and which is which", () => {
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 1920, height: 1080, bitDepth: 8, isHdr: false }),
+    { width: 1280, height: 720, bitDepth: 10, isHdr: true }
+  );
+  assert.equal(facts.disagreements.length, 3);
+  assert.ok(facts.disagreements.some((line) => /width 1280 in the container against 1920 in the probe/.test(line)));
+  assert.ok(facts.disagreements.some((line) => /bit depth 10 in the container against 8 in the probe/.test(line)));
+  // HDR is not among them, and cannot be: see `mergeVideoFacts`.
+  assert.ok(!facts.disagreements.some((line) => /HDR/.test(line)));
+  // And the rule still decides: the probe for the size, the file for the rest.
+  assert.equal(facts.width, 1920);
+  assert.equal(facts.bitDepth, 10);
+  assert.equal(facts.isHdr, true);
+});
+
+test("the display size is the container's alone — the probe has no such field", () => {
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 1440, height: 1080 }),
+    { width: 1440, height: 1080, displayWidth: 1920, displayHeight: 1080 }
+  );
+  assert.equal(facts.displayWidth, 1920);
+  assert.equal(facts.displayHeight, 1080);
+});
+
+test("zero and nonsense are not values", () => {
+  const facts = Container.mergeVideoFacts(
+    banner({ width: 0, height: 0, fps: 0, bitDepth: 0 }),
+    { width: 1920, height: 1080, fps: 24, bitDepth: 8 }
+  );
+  assert.equal(facts.width, 1920, "a probe that printed nothing does not outrank a file that speaks");
+  assert.equal(facts.fps, 24);
+  assert.equal(facts.bitDepth, 8);
+  assert.deepEqual(facts.disagreements, []);
+});

package/test/viewer-assignments.test.js

@@ -1,143 +1,143 @@
-/**
- * @file What a viewer's own assignment to an output must do.
- *
- * The property under all of it: one viewer's link, seek or choice never moves
- * another viewer's output. That is roadmap item 97, and the record it replaces
- * — one entry per (file, height) for everybody — could not express it.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { Assignments } from "../services/viewer/Assignments.js";
-
-const WINDOW_MS = 30_000;
-const make = () => new Assignments({ acceptWindowMs: WINDOW_MS });
-
-test("the acceptance window is given, not invented", () => {
-  assert.throws(() => new Assignments({}), TypeError);
-  assert.throws(() => new Assignments({ acceptWindowMs: -1 }), TypeError);
-});
-
-test("a choice stands until the rule moves it, and a request never moves it", () => {
-  const mine = make();
-
-  mine.choose(720, "out-a");
-  mine.give(mine.generation, 720, 4, "out-a");
-
-  assert.equal(mine.chosenFor(720), "out-a");
-  mine.give(mine.generation, 720, 5, "out-b");
-  assert.equal(mine.chosenFor(720), "out-a", "being given something else does not re-choose");
-  mine.choose(720, "out-b");
-  assert.equal(mine.chosenFor(720), "out-b");
-});
-
-test("two viewers do not share an answer", () => {
-  const thin = make();
-  const thick = make();
-
-  thin.choose(720, "out-540-slow");
-  thick.choose(720, "out-720-full");
-
-  assert.equal(thin.chosenFor(720), "out-540-slow");
-  assert.equal(thick.chosenFor(720), "out-720-full", "the other viewer's link decided nothing here");
-});
-
-test("a repeat of a request is answered by whatever answered it, not decided again", () => {
-  const mine = make();
-  const first = mine.generation;
-
-  mine.give(first, 720, 9, "out-a");
-
-  assert.equal(mine.givenFor(first, 720, 9), "out-a");
-  assert.equal(mine.givenFor(first, 720, 10), "", "a segment nothing answered says so");
-  assert.equal(mine.givenFor(first + 1, 720, 9), "", "and a later generation is not the same question");
-});
-
-test("a request carries its own generation, so a late one is not read against the current", () => {
-  const mine = make();
-  const made = mine.generation;
-
-  mine.statedGeneration(1, 1_000);
-
-  assert.equal(mine.generation, 1);
-  assert.notEqual(mine.generation, made);
-  assert.equal(mine.accepts(made, 1_000 + WINDOW_MS), true, "inside the window it is still answered");
-  assert.equal(mine.accepts(made, 1_000 + WINDOW_MS + 1), false, "past it, a new request is not");
-  assert.equal(mine.accepts(mine.generation, 1_000 + 10 * WINDOW_MS), true, "the current one never runs out");
-});
-
-test("an accepted response keeps its output past its own generation's window", () => {
-  const mine = make();
-  const made = mine.generation;
-  mine.give(made, 720, 3, "out-a");
-  const token = mine.accept("out-a");
-
-  mine.statedGeneration(1, 1_000);
-  mine.choose(720, "out-b");
-
-  const longAfter = 1_000 + 10 * WINDOW_MS;
-  assert.equal(mine.accepts(made, longAfter), false, "no NEW request of that generation is taken");
-  assert.ok(
-    mine.heldKeys(longAfter).has("out-a"),
-    "but the output whose bytes are still going out is held — dropping it is what the second deadline exists to prevent"
-  );
-
-  mine.release(token);
-  assert.equal(mine.heldKeys(longAfter).has("out-a"), false, "and released once the response is done");
-});
-
-test("what was given inside a live generation holds its output, and is forgotten past the window", () => {
-  const mine = make();
-  const made = mine.generation;
-  mine.give(made, 720, 3, "out-a");
-  mine.statedGeneration(1, 1_000);
-
-  assert.ok(mine.heldKeys(1_000 + WINDOW_MS).has("out-a"));
-  assert.equal(
-    mine.heldKeys(1_000 + WINDOW_MS + 1).has("out-a"),
-    false,
-    "past the window nothing stands on it, so it may be let go"
-  );
-  assert.equal(
-    mine.givenFor(made, 720, 3),
-    "",
-    "and the generation is pruned rather than kept for the life of the viewing"
-  );
-});
-
-test("a viewer leaving holds nothing, response in flight included", () => {
-  const mine = make();
-  mine.choose(720, "out-a");
-  mine.accept("out-b");
-  mine.give(mine.generation, 720, 1, "out-c");
-
-  mine.clear();
-
-  assert.equal(mine.heldKeys().size, 0);
-});
-
-test("the page owns the number, so a lower one does not take the viewer back", () => {
-  const mine = make();
-  mine.statedGeneration(4, 1_000);
-
-  assert.equal(mine.statedGeneration(2, 2_000), 4, "a reordered or repeated message changes nothing");
-  assert.equal(mine.statedGeneration(4, 2_000), 4, "and neither does the one already current");
-  assert.equal(mine.generation, 4);
-});
-
-test("a request ahead of what the page has announced is still answered", () => {
-  const mine = make();
-
-  // The page raises its own number before it sends anything, so a segment
-  // request can overtake the seek that announces the new viewing.
-  assert.equal(mine.accepts(1), true, "being behind the page means this side has not heard yet");
-  assert.equal(mine.accepts(7), true);
-});
-
-test("a request that states no generation is answered", () => {
-  const mine = make();
-  mine.statedGeneration(3, 1_000);
-
-  assert.equal(mine.accepts(Number.NaN, 1_000 + 10 * WINDOW_MS), true);
-  assert.equal(mine.accepts(undefined, 1_000 + 10 * WINDOW_MS), true, "a transport with no loader of ours builds no such parameter");
-});
+/**
+ * @file What a viewer's own assignment to an output must do.
+ *
+ * The property under all of it: one viewer's link, seek or choice never moves
+ * another viewer's output. That is roadmap item 97, and the record it replaces
+ * — one entry per (file, height) for everybody — could not express it.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Assignments } from "../services/viewer/Assignments.js";
+
+const WINDOW_MS = 30_000;
+const make = () => new Assignments({ acceptWindowMs: WINDOW_MS });
+
+test("the acceptance window is given, not invented", () => {
+  assert.throws(() => new Assignments({}), TypeError);
+  assert.throws(() => new Assignments({ acceptWindowMs: -1 }), TypeError);
+});
+
+test("a choice stands until the rule moves it, and a request never moves it", () => {
+  const mine = make();
+
+  mine.choose(720, "out-a");
+  mine.give(mine.generation, 720, 4, "out-a");
+
+  assert.equal(mine.chosenFor(720), "out-a");
+  mine.give(mine.generation, 720, 5, "out-b");
+  assert.equal(mine.chosenFor(720), "out-a", "being given something else does not re-choose");
+  mine.choose(720, "out-b");
+  assert.equal(mine.chosenFor(720), "out-b");
+});
+
+test("two viewers do not share an answer", () => {
+  const thin = make();
+  const thick = make();
+
+  thin.choose(720, "out-540-slow");
+  thick.choose(720, "out-720-full");
+
+  assert.equal(thin.chosenFor(720), "out-540-slow");
+  assert.equal(thick.chosenFor(720), "out-720-full", "the other viewer's link decided nothing here");
+});
+
+test("a repeat of a request is answered by whatever answered it, not decided again", () => {
+  const mine = make();
+  const first = mine.generation;
+
+  mine.give(first, 720, 9, "out-a");
+
+  assert.equal(mine.givenFor(first, 720, 9), "out-a");
+  assert.equal(mine.givenFor(first, 720, 10), "", "a segment nothing answered says so");
+  assert.equal(mine.givenFor(first + 1, 720, 9), "", "and a later generation is not the same question");
+});
+
+test("a request carries its own generation, so a late one is not read against the current", () => {
+  const mine = make();
+  const made = mine.generation;
+
+  mine.statedGeneration(1, 1_000);
+
+  assert.equal(mine.generation, 1);
+  assert.notEqual(mine.generation, made);
+  assert.equal(mine.accepts(made, 1_000 + WINDOW_MS), true, "inside the window it is still answered");
+  assert.equal(mine.accepts(made, 1_000 + WINDOW_MS + 1), false, "past it, a new request is not");
+  assert.equal(mine.accepts(mine.generation, 1_000 + 10 * WINDOW_MS), true, "the current one never runs out");
+});
+
+test("an accepted response keeps its output past its own generation's window", () => {
+  const mine = make();
+  const made = mine.generation;
+  mine.give(made, 720, 3, "out-a");
+  const token = mine.accept("out-a");
+
+  mine.statedGeneration(1, 1_000);
+  mine.choose(720, "out-b");
+
+  const longAfter = 1_000 + 10 * WINDOW_MS;
+  assert.equal(mine.accepts(made, longAfter), false, "no NEW request of that generation is taken");
+  assert.ok(
+    mine.heldKeys(longAfter).has("out-a"),
+    "but the output whose bytes are still going out is held — dropping it is what the second deadline exists to prevent"
+  );
+
+  mine.release(token);
+  assert.equal(mine.heldKeys(longAfter).has("out-a"), false, "and released once the response is done");
+});
+
+test("what was given inside a live generation holds its output, and is forgotten past the window", () => {
+  const mine = make();
+  const made = mine.generation;
+  mine.give(made, 720, 3, "out-a");
+  mine.statedGeneration(1, 1_000);
+
+  assert.ok(mine.heldKeys(1_000 + WINDOW_MS).has("out-a"));
+  assert.equal(
+    mine.heldKeys(1_000 + WINDOW_MS + 1).has("out-a"),
+    false,
+    "past the window nothing stands on it, so it may be let go"
+  );
+  assert.equal(
+    mine.givenFor(made, 720, 3),
+    "",
+    "and the generation is pruned rather than kept for the life of the viewing"
+  );
+});
+
+test("a viewer leaving holds nothing, response in flight included", () => {
+  const mine = make();
+  mine.choose(720, "out-a");
+  mine.accept("out-b");
+  mine.give(mine.generation, 720, 1, "out-c");
+
+  mine.clear();
+
+  assert.equal(mine.heldKeys().size, 0);
+});
+
+test("the page owns the number, so a lower one does not take the viewer back", () => {
+  const mine = make();
+  mine.statedGeneration(4, 1_000);
+
+  assert.equal(mine.statedGeneration(2, 2_000), 4, "a reordered or repeated message changes nothing");
+  assert.equal(mine.statedGeneration(4, 2_000), 4, "and neither does the one already current");
+  assert.equal(mine.generation, 4);
+});
+
+test("a request ahead of what the page has announced is still answered", () => {
+  const mine = make();
+
+  // The page raises its own number before it sends anything, so a segment
+  // request can overtake the seek that announces the new viewing.
+  assert.equal(mine.accepts(1), true, "being behind the page means this side has not heard yet");
+  assert.equal(mine.accepts(7), true);
+});
+
+test("a request that states no generation is answered", () => {
+  const mine = make();
+  mine.statedGeneration(3, 1_000);
+
+  assert.equal(mine.accepts(Number.NaN, 1_000 + 10 * WINDOW_MS), true);
+  assert.equal(mine.accepts(undefined, 1_000 + 10 * WINDOW_MS), true, "a transport with no loader of ours builds no such parameter");
+});