@torrent-tv/proxy 2.87.8 → 2.87.9

package/test/encode-run.test.js

@@ -1,161 +1,161 @@
-/**
- * @file One encoder's lifetime: the stretch it was given, where it got to, and
- * whether its ending was the normal one.
- *
- * The process is injected, so none of this needs ffmpeg. What is checked is the
- * accounting the user asked for on 2026-09-04: exactly one ending is normal,
- * every other one says why, and none of them goes unrecorded.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { EventEmitter } from "node:events";
-import { EncodeRun } from "../services/encode/EncodeRun.js";
-import { ENCODE_EXIT } from "../services/encode/encode-exit.js";
-import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
-
-/**
- * A process that does nothing until the test says what became of it.
- */
-class FakeProcess extends EventEmitter {
-  constructor() {
-    super();
-    this.pid = 4242;
-    this.signals = [];
-  }
-
-  kill(signal) {
-    this.signals.push(signal);
-  }
-
-  exitWith(code, signal = null) {
-    this.emit("exit", code, signal);
-  }
-}
-
-/**
- * @param {Partial<{from:number,to:number}>} [span]
- */
-function makeRun(span = {}) {
-  const lines = [];
-  const ends = [];
-  const process_ = new FakeProcess();
-  const run = new EncodeRun({
-    address: "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/enc/libx264/854x480@24/veryfast/none/vbv=-",
-    encoder: new SoftwareEncoder(),
-    from: span.from ?? 10,
-    to: span.to ?? 14,
-    buildArgs: () => ["-i", "in", "out"],
-    spawn: () => process_,
-    logger: {
-      info: (line) => lines.push(["info", line]),
-      warn: (line) => lines.push(["warn", line])
-    },
-    now: () => 1000,
-    onEnded: (ended) => ends.push(ended),
-    because: "nobody is making #10 and a viewer is waiting for it"
-  });
-  return { run, process: process_, lines, ends };
-}
-
-test("a start says why it is starting and with what", () => {
-  // The argument list alone cannot say whether this was a first open, a seek, a
-  // quality step or a move off covered material — and with several runs at once
-  // that is the only way to tell one start from another.
-  const { lines } = makeRun();
-  const [level, line] = lines[0];
-  assert.equal(level, "info");
-  // A run is named by what it produces: the stretch it was given, on the output
-  // it makes segments of. No other live run of that output can hold it.
-  assert.match(line, /encode-run #10\.\.#14 of torrent:abc:/);
-  assert.match(line, /nobody is making #10/);
-  assert.match(line, /ffmpeg -i in out/);
-});
-
-test("its head is the next number it will make, and moves as it makes them", () => {
-  const { run } = makeRun();
-  assert.equal(run.head, 10);
-  run.noteProduced(10);
-  run.noteProduced(11);
-  assert.equal(run.head, 12);
-  assert.equal(run.reached, 11);
-});
-
-test("reaching the end of its stretch and exiting is the one normal ending", () => {
-  const { run, process, ends, lines } = makeRun({ from: 10, to: 12 });
-  for (const index of [10, 11, 12]) {
-    run.noteProduced(index);
-  }
-  process.exitWith(0, null);
-  assert.equal(ends.length, 1);
-  assert.equal(ends[0].ending, ENCODE_EXIT.COMPLETE);
-  assert.equal(ends[0].normal, true);
-  assert.equal(lines.at(-1)[0], "info", "a normal ending is not a warning");
-});
-
-test("exiting cleanly short of its stretch is abnormal and says where it stopped", () => {
-  // ffmpeg exits zero both at the end of a file and when its input stops
-  // producing bytes; over a torrent the two look identical to it.
-  const { run, process, ends } = makeRun({ from: 10, to: 14 });
-  run.noteProduced(10);
-  run.noteProduced(11);
-  process.exitWith(0, null);
-  assert.equal(ends[0].ending, ENCODE_EXIT.SHORT);
-  assert.equal(ends[0].normal, false);
-  assert.equal(ends[0].reached, 11);
-  assert.match(ends[0].because, /#11 of #14/);
-});
-
-test("a non-zero exit is a failure carrying its code", () => {
-  const { process, ends, lines } = makeRun();
-  process.exitWith(255, null);
-  assert.equal(ends[0].ending, ENCODE_EXIT.FAILED);
-  assert.equal(ends[0].code, 255);
-  assert.equal(lines.at(-1)[0], "warn");
-});
-
-test("our own kill is abnormal too, and carries the reason we gave", () => {
-  // Hiding it among the normal endings would make a count of abnormal endings
-  // useless, which is the whole point of counting them.
-  const { run, process, ends } = makeRun();
-  run.stop("moved past 20 segments that are already made");
-  assert.deepEqual(process.signals, ["SIGTERM"]);
-  process.exitWith(null, "SIGTERM");
-  assert.equal(ends[0].ending, ENCODE_EXIT.STOPPED);
-  assert.equal(ends[0].normal, false);
-  assert.match(ends[0].because, /already made/);
-});
-
-test("an ending reports the stretch, how far it got and how long it lived", () => {
-  const { run, process, ends } = makeRun({ from: 10, to: 14 });
-  run.noteProduced(10);
-  process.exitWith(1, null);
-  const ended = ends[0];
-  assert.equal(ended.from, 10);
-  assert.equal(ended.to, 14);
-  assert.equal(ended.reached, 10);
-  assert.equal(ended.livedMs, 0, "the clock is injected, so this is exact");
-  assert.equal(ended.address.includes("854x480"), true);
-});
-
-test("a process that could not be started ends like any other failure", () => {
-  const { process, ends } = makeRun();
-  process.emit("error", new Error("ENOENT"));
-  assert.equal(ends[0].ending, ENCODE_EXIT.FAILED);
-  assert.match(ends[0].because, /ENOENT/);
-});
-
-test("only a measured speed is kept", () => {
-  const { run } = makeRun();
-  assert.equal(run.speedX, 0, "nothing measured yet");
-  run.noteSpeed(0);
-  assert.equal(run.speedX, 0);
-  run.noteSpeed(2.5);
-  assert.equal(run.speedX, 2.5);
-});
-
-test("a segment number behind its own start is not its to claim", () => {
-  const { run } = makeRun({ from: 10, to: 14 });
-  run.noteProduced(4);
-  assert.deepEqual(run.produced, []);
-});
+/**
+ * @file One encoder's lifetime: the stretch it was given, where it got to, and
+ * whether its ending was the normal one.
+ *
+ * The process is injected, so none of this needs ffmpeg. What is checked is the
+ * accounting the user asked for on 2026-09-04: exactly one ending is normal,
+ * every other one says why, and none of them goes unrecorded.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { EncodeRun } from "../services/encode/EncodeRun.js";
+import { ENCODE_EXIT } from "../services/encode/encode-exit.js";
+import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
+
+/**
+ * A process that does nothing until the test says what became of it.
+ */
+class FakeProcess extends EventEmitter {
+  constructor() {
+    super();
+    this.pid = 4242;
+    this.signals = [];
+  }
+
+  kill(signal) {
+    this.signals.push(signal);
+  }
+
+  exitWith(code, signal = null) {
+    this.emit("exit", code, signal);
+  }
+}
+
+/**
+ * @param {Partial<{from:number,to:number}>} [span]
+ */
+function makeRun(span = {}) {
+  const lines = [];
+  const ends = [];
+  const process_ = new FakeProcess();
+  const run = new EncodeRun({
+    address: "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/enc/libx264/854x480@24/veryfast/none/vbv=-",
+    encoder: new SoftwareEncoder(),
+    from: span.from ?? 10,
+    to: span.to ?? 14,
+    buildArgs: () => ["-i", "in", "out"],
+    spawn: () => process_,
+    logger: {
+      info: (line) => lines.push(["info", line]),
+      warn: (line) => lines.push(["warn", line])
+    },
+    now: () => 1000,
+    onEnded: (ended) => ends.push(ended),
+    because: "nobody is making #10 and a viewer is waiting for it"
+  });
+  return { run, process: process_, lines, ends };
+}
+
+test("a start says why it is starting and with what", () => {
+  // The argument list alone cannot say whether this was a first open, a seek, a
+  // quality step or a move off covered material — and with several runs at once
+  // that is the only way to tell one start from another.
+  const { lines } = makeRun();
+  const [level, line] = lines[0];
+  assert.equal(level, "info");
+  // A run is named by what it produces: the stretch it was given, on the output
+  // it makes segments of. No other live run of that output can hold it.
+  assert.match(line, /encode-run #10\.\.#14 of torrent:abc:/);
+  assert.match(line, /nobody is making #10/);
+  assert.match(line, /ffmpeg -i in out/);
+});
+
+test("its head is the next number it will make, and moves as it makes them", () => {
+  const { run } = makeRun();
+  assert.equal(run.head, 10);
+  run.noteProduced(10);
+  run.noteProduced(11);
+  assert.equal(run.head, 12);
+  assert.equal(run.reached, 11);
+});
+
+test("reaching the end of its stretch and exiting is the one normal ending", () => {
+  const { run, process, ends, lines } = makeRun({ from: 10, to: 12 });
+  for (const index of [10, 11, 12]) {
+    run.noteProduced(index);
+  }
+  process.exitWith(0, null);
+  assert.equal(ends.length, 1);
+  assert.equal(ends[0].ending, ENCODE_EXIT.COMPLETE);
+  assert.equal(ends[0].normal, true);
+  assert.equal(lines.at(-1)[0], "info", "a normal ending is not a warning");
+});
+
+test("exiting cleanly short of its stretch is abnormal and says where it stopped", () => {
+  // ffmpeg exits zero both at the end of a file and when its input stops
+  // producing bytes; over a torrent the two look identical to it.
+  const { run, process, ends } = makeRun({ from: 10, to: 14 });
+  run.noteProduced(10);
+  run.noteProduced(11);
+  process.exitWith(0, null);
+  assert.equal(ends[0].ending, ENCODE_EXIT.SHORT);
+  assert.equal(ends[0].normal, false);
+  assert.equal(ends[0].reached, 11);
+  assert.match(ends[0].because, /#11 of #14/);
+});
+
+test("a non-zero exit is a failure carrying its code", () => {
+  const { process, ends, lines } = makeRun();
+  process.exitWith(255, null);
+  assert.equal(ends[0].ending, ENCODE_EXIT.FAILED);
+  assert.equal(ends[0].code, 255);
+  assert.equal(lines.at(-1)[0], "warn");
+});
+
+test("our own kill is abnormal too, and carries the reason we gave", () => {
+  // Hiding it among the normal endings would make a count of abnormal endings
+  // useless, which is the whole point of counting them.
+  const { run, process, ends } = makeRun();
+  run.stop("moved past 20 segments that are already made");
+  assert.deepEqual(process.signals, ["SIGTERM"]);
+  process.exitWith(null, "SIGTERM");
+  assert.equal(ends[0].ending, ENCODE_EXIT.STOPPED);
+  assert.equal(ends[0].normal, false);
+  assert.match(ends[0].because, /already made/);
+});
+
+test("an ending reports the stretch, how far it got and how long it lived", () => {
+  const { run, process, ends } = makeRun({ from: 10, to: 14 });
+  run.noteProduced(10);
+  process.exitWith(1, null);
+  const ended = ends[0];
+  assert.equal(ended.from, 10);
+  assert.equal(ended.to, 14);
+  assert.equal(ended.reached, 10);
+  assert.equal(ended.livedMs, 0, "the clock is injected, so this is exact");
+  assert.equal(ended.address.includes("854x480"), true);
+});
+
+test("a process that could not be started ends like any other failure", () => {
+  const { process, ends } = makeRun();
+  process.emit("error", new Error("ENOENT"));
+  assert.equal(ends[0].ending, ENCODE_EXIT.FAILED);
+  assert.match(ends[0].because, /ENOENT/);
+});
+
+test("only a measured speed is kept", () => {
+  const { run } = makeRun();
+  assert.equal(run.speedX, 0, "nothing measured yet");
+  run.noteSpeed(0);
+  assert.equal(run.speedX, 0);
+  run.noteSpeed(2.5);
+  assert.equal(run.speedX, 2.5);
+});
+
+test("a segment number behind its own start is not its to claim", () => {
+  const { run } = makeRun({ from: 10, to: 14 });
+  run.noteProduced(4);
+  assert.deepEqual(run.produced, []);
+});

package/test/encode-slope.test.js

@@ -1,46 +1,46 @@
-/**
- * @file The slope that turns ffmpeg's progress reports into a preset's speed.
- *
- * Written against the faults a review found in it on 2026-08-15, each of which
- * would have opened the quality ladder rather than closing it: a window of no
- * width at all, and a position ffmpeg reports as the smallest signed 64-bit
- * integer when it has none yet.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { slopeOf } from "../services/encode/hwaccel.js";
-
-const at = (wallSec, outSec) => ({ wallSec, outSec });
-
-test("a steady run measures its own speed", () => {
-  assert.equal(slopeOf([at(1, 10), at(2, 14)]), 4);
-});
-
-test("a window of no width is refused, however tempting the numbers", () => {
-  // Two reports a millisecond apart: 0.042 s of video over 0.001 s of clock is
-  // 42x, on a host that may be doing 3x.
-  assert.equal(slopeOf([at(1.0, 10), at(1.001, 10.042)], 0.2), null);
-});
-
-test("a run that produced nothing between two reports says nothing", () => {
-  assert.equal(slopeOf([at(1, 10), at(3, 10)]), null);
-});
-
-test("one report is not a measurement", () => {
-  assert.equal(slopeOf([at(1, 10)]), null);
-  assert.equal(slopeOf([]), null);
-});
-
-test("an impossible speed is a fault, not a fast machine", () => {
-  // Nothing encodes 640x360 five thousand times realtime; a reading that says
-  // so is a measurement fault, and letting it through raises the bar every
-  // ladder decision is taken from.
-  assert.equal(slopeOf([at(1, 0), at(2, 5000)]), null);
-});
-
-test("the narrowest allowed window is honoured", () => {
-  assert.equal(slopeOf([at(1.0, 10), at(1.3, 11)], 0.5), null);
-  assert.ok(slopeOf([at(1.0, 10), at(1.6, 12)], 0.5) > 0);
-});
+/**
+ * @file The slope that turns ffmpeg's progress reports into a preset's speed.
+ *
+ * Written against the faults a review found in it on 2026-08-15, each of which
+ * would have opened the quality ladder rather than closing it: a window of no
+ * width at all, and a position ffmpeg reports as the smallest signed 64-bit
+ * integer when it has none yet.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { slopeOf } from "../services/encode/hwaccel.js";
+
+const at = (wallSec, outSec) => ({ wallSec, outSec });
+
+test("a steady run measures its own speed", () => {
+  assert.equal(slopeOf([at(1, 10), at(2, 14)]), 4);
+});
+
+test("a window of no width is refused, however tempting the numbers", () => {
+  // Two reports a millisecond apart: 0.042 s of video over 0.001 s of clock is
+  // 42x, on a host that may be doing 3x.
+  assert.equal(slopeOf([at(1.0, 10), at(1.001, 10.042)], 0.2), null);
+});
+
+test("a run that produced nothing between two reports says nothing", () => {
+  assert.equal(slopeOf([at(1, 10), at(3, 10)]), null);
+});
+
+test("one report is not a measurement", () => {
+  assert.equal(slopeOf([at(1, 10)]), null);
+  assert.equal(slopeOf([]), null);
+});
+
+test("an impossible speed is a fault, not a fast machine", () => {
+  // Nothing encodes 640x360 five thousand times realtime; a reading that says
+  // so is a measurement fault, and letting it through raises the bar every
+  // ladder decision is taken from.
+  assert.equal(slopeOf([at(1, 0), at(2, 5000)]), null);
+});
+
+test("the narrowest allowed window is honoured", () => {
+  assert.equal(slopeOf([at(1.0, 10), at(1.3, 11)], 0.5), null);
+  assert.ok(slopeOf([at(1.0, 10), at(1.6, 12)], 0.5) > 0);
+});

package/test/encoded-output.test.js

@@ -1,39 +1,39 @@
-/**
- * @file An output holds what is born with it, and not what is produced.
- *
- * Decided with the user 2026-09-16: which pieces are made is the segment
- * store's, and which encoders run is the encoding orchestrator's. A second
- * holder of either is how the stale second owner stopped playback outright.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { EncodedOutput } from "../services/encode/output/EncodedOutput.js";
-import { outputSpec } from "./helpers/output-spec.js";
-
-function made() {
-  return new EncodedOutput({
-    id: "aaaaaaaabbbbcccc",
-    spec: outputSpec({ transcodeVideo: true, width: 1280, height: 720 }),
-    file: { key: "source-1:0" },
-    keyframes: null,
-    timeline: null,
-    segmentFormat: null,
-    output: null,
-    useSyntheticPlaylist: true,
-    playlistText: "#EXTM3U\n",
-    variantHeight: 720
-  });
-}
-
-test("its address is its format, read from the spec and kept nowhere else", () => {
-  const output = made();
-  assert.equal(output.outputKey, output.spec.toKey());
-});
-
-test("it keeps no statement of what has been produced or what is running", () => {
-  const output = made();
-  for (const field of ["runs", "runState", "progress", "produced", "ready", "state", "lastError", "failedStartCount"]) {
-    assert.equal(field in output, false, `${field} belongs to the store or the encoding orchestrator`);
-  }
-});
+/**
+ * @file An output holds what is born with it, and not what is produced.
+ *
+ * Decided with the user 2026-09-16: which pieces are made is the segment
+ * store's, and which encoders run is the encoding orchestrator's. A second
+ * holder of either is how the stale second owner stopped playback outright.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EncodedOutput } from "../services/encode/output/EncodedOutput.js";
+import { outputSpec } from "./helpers/output-spec.js";
+
+function made() {
+  return new EncodedOutput({
+    id: "aaaaaaaabbbbcccc",
+    spec: outputSpec({ transcodeVideo: true, width: 1280, height: 720 }),
+    file: { key: "source-1:0" },
+    keyframes: null,
+    timeline: null,
+    segmentFormat: null,
+    output: null,
+    useSyntheticPlaylist: true,
+    playlistText: "#EXTM3U\n",
+    variantHeight: 720
+  });
+}
+
+test("its address is its format, read from the spec and kept nowhere else", () => {
+  const output = made();
+  assert.equal(output.outputKey, output.spec.toKey());
+});
+
+test("it keeps no statement of what has been produced or what is running", () => {
+  const output = made();
+  for (const field of ["runs", "runState", "progress", "produced", "ready", "state", "lastError", "failedStartCount"]) {
+    assert.equal(field in output, false, `${field} belongs to the store or the encoding orchestrator`);
+  }
+});