@torrent-tv/proxy 2.89.7 → 2.89.9

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`);
+  }
+});

package/test/encoder-kinds.test.js

@@ -1,122 +1,122 @@
-/**
- * @file What every encoder kind must state about itself, and the properties of
- * its arguments that a field failure paid for.
- *
- * Deliberately NOT a transcription of the argument lists: a test written by
- * copying the code cannot fail when the code is wrong. What is stated here is
- * what must hold for ANY kind, including one added later, plus the two
- * kind-specific facts that were learned by running the thing on real hardware.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { Encoder } from "../services/encode/Encoder.js";
-import { NvencEncoder } from "../services/encode/NvencEncoder.js";
-import { QsvEncoder } from "../services/encode/QsvEncoder.js";
-import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
-import { V4l2m2mEncoder } from "../services/encode/V4l2m2mEncoder.js";
-import { VaapiEncoder } from "../services/encode/VaapiEncoder.js";
-
-const KINDS = [
-  new SoftwareEncoder(),
-  new VaapiEncoder("/dev/dri/renderD128"),
-  new QsvEncoder("/dev/dri/renderD128"),
-  new NvencEncoder(),
-  new V4l2m2mEncoder()
-];
-
-const BASE = { targetWidth: 1280, targetHeight: 720, segmentDurationSec: 4, fps: 24 };
-
-test("a kind's arguments name the encoder the kind claims to be", () => {
-  // The one thing that must never drift: a class called `h264_nvenc` that puts
-  // `libx264` on the command line would be filed under an address promising
-  // the other one's header.
-  for (const encoder of KINDS) {
-    const args = encoder.buildVideoArgs(BASE);
-    const at = args.indexOf("-c:v");
-    assert.notEqual(at, -1, `${encoder.name} names no video encoder`);
-    assert.equal(args[at + 1], encoder.name, `${encoder.name} builds ${args[at + 1]}`);
-  }
-});
-
-test("an explicit cut list is passed through exactly, by every kind", () => {
-  // This is what makes a re-encoded step splice into a copied picture: it has
-  // to be cut at the source's own keyframe times and nowhere else. A kind that
-  // rounded them, or dropped them for its own even grid, would produce segments
-  // that cannot stand where the copy's would.
-  const times = [0, 4.271, 8.9, 13.04];
-  for (const encoder of KINDS) {
-    const args = encoder.buildVideoArgs({ ...BASE, forcedKeyframeTimes: times });
-    const at = args.indexOf("-force_key_frames");
-    assert.notEqual(at, -1, `${encoder.name} forces no keyframes`);
-    assert.equal(args[at + 1], times.join(","), `${encoder.name} altered the cut list`);
-  }
-});
-
-test("with no cut list, keyframes are still placed on the segment grid", () => {
-  for (const encoder of KINDS) {
-    const args = encoder.buildVideoArgs({ ...BASE, forcedKeyframeTimes: null });
-    const joined = args.join(" ");
-    // Either forced by time, or by a frame-count GOP — both put a keyframe on
-    // every boundary, which is what makes a segment independently decodable.
-    const byTime = joined.includes("-force_key_frames expr:gte(t,n_forced*4)");
-    const byFrameCount = joined.includes(`-g ${4 * 24}`);
-    assert.ok(byTime || byFrameCount, `${encoder.name} places keyframes by neither rule`);
-  }
-});
-
-test("a target box of nothing still produces a usable size", () => {
-  // The session manager passes 0 for "keep the source size"; a kind that let
-  // that through would build `scale=0:0`.
-  for (const encoder of KINDS) {
-    const args = encoder.buildVideoArgs({ ...BASE, targetWidth: 0, targetHeight: 0 });
-    assert.ok(!args.join(" ").includes("=0:"), `${encoder.name} scaled to zero`);
-  }
-});
-
-test("every kind says what its speed setting is, or that it has none", () => {
-  for (const encoder of KINDS) {
-    const ladder = encoder.speedLadder;
-    assert.equal(typeof ladder.note, "string");
-    assert.ok(ladder.note.length > 0, `${encoder.name} explains nothing about its ladder`);
-    assert.ok(Array.isArray(ladder.values));
-    if (ladder.values.length > 0) {
-      assert.ok(ladder.flag.length > 0, `${encoder.name} lists settings but names no option`);
-    }
-  }
-});
-
-test("only libx264 claims a measured ladder", () => {
-  // The four hardware kinds have never been benchmarked across their settings,
-  // and a ladder claiming to be measured is what would let something start
-  // choosing from it.
-  for (const encoder of KINDS) {
-    assert.equal(
-      encoder.speedLadder.measured,
-      encoder.kind === "software",
-      `${encoder.name} misreports whether its ladder was measured`
-    );
-  }
-});
-
-test("a kind that is not software is hardware, and says so", () => {
-  for (const encoder of KINDS) {
-    assert.equal(encoder.isHardware, encoder.kind !== "software");
-  }
-});
-
-test("the encoder on an ARM board always asks for more capture buffers", () => {
-  // The default of four deadlocks on the CM4 — "All capture buffers returned to
-  // userspace" — so this is not a tuning choice but the condition under which
-  // that encoder runs at all.
-  const args = new V4l2m2mEncoder().buildVideoArgs(BASE);
-  const at = args.indexOf("-num_capture_buffers");
-  assert.notEqual(at, -1, "v4l2m2m was given the default buffer count");
-  assert.ok(Number(args[at + 1]) > 4);
-});
-
-test("a kind that does not say how to build its arguments refuses rather than producing none", () => {
-  class Unstated extends Encoder {}
-  const encoder = new Unstated({ name: "h264_unstated", kind: "nvenc" });
-  assert.throws(() => encoder.buildVideoArgs(BASE), /does not say how/);
-});
+/**
+ * @file What every encoder kind must state about itself, and the properties of
+ * its arguments that a field failure paid for.
+ *
+ * Deliberately NOT a transcription of the argument lists: a test written by
+ * copying the code cannot fail when the code is wrong. What is stated here is
+ * what must hold for ANY kind, including one added later, plus the two
+ * kind-specific facts that were learned by running the thing on real hardware.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Encoder } from "../services/encode/Encoder.js";
+import { NvencEncoder } from "../services/encode/NvencEncoder.js";
+import { QsvEncoder } from "../services/encode/QsvEncoder.js";
+import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
+import { V4l2m2mEncoder } from "../services/encode/V4l2m2mEncoder.js";
+import { VaapiEncoder } from "../services/encode/VaapiEncoder.js";
+
+const KINDS = [
+  new SoftwareEncoder(),
+  new VaapiEncoder("/dev/dri/renderD128"),
+  new QsvEncoder("/dev/dri/renderD128"),
+  new NvencEncoder(),
+  new V4l2m2mEncoder()
+];
+
+const BASE = { targetWidth: 1280, targetHeight: 720, segmentDurationSec: 4, fps: 24 };
+
+test("a kind's arguments name the encoder the kind claims to be", () => {
+  // The one thing that must never drift: a class called `h264_nvenc` that puts
+  // `libx264` on the command line would be filed under an address promising
+  // the other one's header.
+  for (const encoder of KINDS) {
+    const args = encoder.buildVideoArgs(BASE);
+    const at = args.indexOf("-c:v");
+    assert.notEqual(at, -1, `${encoder.name} names no video encoder`);
+    assert.equal(args[at + 1], encoder.name, `${encoder.name} builds ${args[at + 1]}`);
+  }
+});
+
+test("an explicit cut list is passed through exactly, by every kind", () => {
+  // This is what makes a re-encoded step splice into a copied picture: it has
+  // to be cut at the source's own keyframe times and nowhere else. A kind that
+  // rounded them, or dropped them for its own even grid, would produce segments
+  // that cannot stand where the copy's would.
+  const times = [0, 4.271, 8.9, 13.04];
+  for (const encoder of KINDS) {
+    const args = encoder.buildVideoArgs({ ...BASE, forcedKeyframeTimes: times });
+    const at = args.indexOf("-force_key_frames");
+    assert.notEqual(at, -1, `${encoder.name} forces no keyframes`);
+    assert.equal(args[at + 1], times.join(","), `${encoder.name} altered the cut list`);
+  }
+});
+
+test("with no cut list, keyframes are still placed on the segment grid", () => {
+  for (const encoder of KINDS) {
+    const args = encoder.buildVideoArgs({ ...BASE, forcedKeyframeTimes: null });
+    const joined = args.join(" ");
+    // Either forced by time, or by a frame-count GOP — both put a keyframe on
+    // every boundary, which is what makes a segment independently decodable.
+    const byTime = joined.includes("-force_key_frames expr:gte(t,n_forced*4)");
+    const byFrameCount = joined.includes(`-g ${4 * 24}`);
+    assert.ok(byTime || byFrameCount, `${encoder.name} places keyframes by neither rule`);
+  }
+});
+
+test("a target box of nothing still produces a usable size", () => {
+  // The session manager passes 0 for "keep the source size"; a kind that let
+  // that through would build `scale=0:0`.
+  for (const encoder of KINDS) {
+    const args = encoder.buildVideoArgs({ ...BASE, targetWidth: 0, targetHeight: 0 });
+    assert.ok(!args.join(" ").includes("=0:"), `${encoder.name} scaled to zero`);
+  }
+});
+
+test("every kind says what its speed setting is, or that it has none", () => {
+  for (const encoder of KINDS) {
+    const ladder = encoder.speedLadder;
+    assert.equal(typeof ladder.note, "string");
+    assert.ok(ladder.note.length > 0, `${encoder.name} explains nothing about its ladder`);
+    assert.ok(Array.isArray(ladder.values));
+    if (ladder.values.length > 0) {
+      assert.ok(ladder.flag.length > 0, `${encoder.name} lists settings but names no option`);
+    }
+  }
+});
+
+test("only libx264 claims a measured ladder", () => {
+  // The four hardware kinds have never been benchmarked across their settings,
+  // and a ladder claiming to be measured is what would let something start
+  // choosing from it.
+  for (const encoder of KINDS) {
+    assert.equal(
+      encoder.speedLadder.measured,
+      encoder.kind === "software",
+      `${encoder.name} misreports whether its ladder was measured`
+    );
+  }
+});
+
+test("a kind that is not software is hardware, and says so", () => {
+  for (const encoder of KINDS) {
+    assert.equal(encoder.isHardware, encoder.kind !== "software");
+  }
+});
+
+test("the encoder on an ARM board always asks for more capture buffers", () => {
+  // The default of four deadlocks on the CM4 — "All capture buffers returned to
+  // userspace" — so this is not a tuning choice but the condition under which
+  // that encoder runs at all.
+  const args = new V4l2m2mEncoder().buildVideoArgs(BASE);
+  const at = args.indexOf("-num_capture_buffers");
+  assert.notEqual(at, -1, "v4l2m2m was given the default buffer count");
+  assert.ok(Number(args[at + 1]) > 4);
+});
+
+test("a kind that does not say how to build its arguments refuses rather than producing none", () => {
+  class Unstated extends Encoder {}
+  const encoder = new Unstated({ name: "h264_unstated", kind: "nvenc" });
+  assert.throws(() => encoder.buildVideoArgs(BASE), /does not say how/);
+});

package/test/encoder-readings.test.js

@@ -1,68 +1,68 @@
-/**
- * @file What two work samples of a running encoder say about its speed.
- *
- * The cases this exists for: a copy whose cumulative speed counts the time it
- * was stopped, and a run whose input waited for the swarm (field 2026-10-01: a
- * copy read 0.21x after waiting 32.93 s and 43.91 s for two pieces). A work
- * sample states the run's own working time, so neither enters the speed.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { RunClock } from "../services/encode/RunClock.js";
-import { speedFromWork } from "../services/encode/encoder-readings.js";
-
-const sample = (at, producedSeconds, workingMs) => ({ at, producedSeconds, workingMs });
-
-test("film made over the run's own work is the speed", () => {
-  assert.equal(speedFromWork(sample(10_000, 100, 5_000), sample(15_000, 140, 10_000)), 8);
-});
-
-test("a stretch with nothing made says nothing", () => {
-  assert.equal(speedFromWork(sample(10_000, 100, 5_000), sample(20_000, 100, 15_000)), null);
-});
-
-test("a run that went backwards says nothing rather than a negative speed", () => {
-  assert.equal(speedFromWork(sample(10_000, 200, 5_000), sample(20_000, 100, 15_000)), null);
-});
-
-test("a missing sample is not an answer", () => {
-  assert.equal(speedFromWork(null, sample(20_000, 100, 1_000)), null);
-  assert.equal(speedFromWork(sample(10_000, 100, 1_000), null), null);
-});
-
-test("waiting for the input and being stopped are not working time", () => {
-  let now = 0;
-  const clock = new RunClock({ now: () => now });
-  now = 2_000;
-  clock.inputWaitBegins();
-  now = 34_930; // the field's 32.93 s wait for one piece
-  clock.inputWaitEnds();
-  now = 36_000;
-  clock.stopped();
-  now = 50_000;
-  clock.continued();
-  now = 51_000;
-  assert.equal(clock.workingMs(), 2_000 + 1_070 + 1_000);
-});
-
-test("two inputs waiting at once, or a wait while stopped, are idle once", () => {
-  let now = 0;
-  const clock = new RunClock({ now: () => now });
-  clock.inputWaitBegins();
-  now = 1_000;
-  clock.inputWaitBegins();
-  clock.stopped();
-  now = 3_000;
-  clock.inputWaitEnds();
-  clock.continued();
-  now = 4_000;
-  clock.inputWaitEnds();
-  now = 5_000;
-  assert.equal(clock.workingMs(), 1_000);
-  // An ongoing wait is idle up to the moment asked.
-  clock.inputWaitBegins();
-  now = 6_000;
-  assert.equal(clock.workingMs(), 1_000);
-});
+/**
+ * @file What two work samples of a running encoder say about its speed.
+ *
+ * The cases this exists for: a copy whose cumulative speed counts the time it
+ * was stopped, and a run whose input waited for the swarm (field 2026-10-01: a
+ * copy read 0.21x after waiting 32.93 s and 43.91 s for two pieces). A work
+ * sample states the run's own working time, so neither enters the speed.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { RunClock } from "../services/encode/RunClock.js";
+import { speedFromWork } from "../services/encode/encoder-readings.js";
+
+const sample = (at, producedSeconds, workingMs) => ({ at, producedSeconds, workingMs });
+
+test("film made over the run's own work is the speed", () => {
+  assert.equal(speedFromWork(sample(10_000, 100, 5_000), sample(15_000, 140, 10_000)), 8);
+});
+
+test("a stretch with nothing made says nothing", () => {
+  assert.equal(speedFromWork(sample(10_000, 100, 5_000), sample(20_000, 100, 15_000)), null);
+});
+
+test("a run that went backwards says nothing rather than a negative speed", () => {
+  assert.equal(speedFromWork(sample(10_000, 200, 5_000), sample(20_000, 100, 15_000)), null);
+});
+
+test("a missing sample is not an answer", () => {
+  assert.equal(speedFromWork(null, sample(20_000, 100, 1_000)), null);
+  assert.equal(speedFromWork(sample(10_000, 100, 1_000), null), null);
+});
+
+test("waiting for the input and being stopped are not working time", () => {
+  let now = 0;
+  const clock = new RunClock({ now: () => now });
+  now = 2_000;
+  clock.inputWaitBegins();
+  now = 34_930; // the field's 32.93 s wait for one piece
+  clock.inputWaitEnds();
+  now = 36_000;
+  clock.stopped();
+  now = 50_000;
+  clock.continued();
+  now = 51_000;
+  assert.equal(clock.workingMs(), 2_000 + 1_070 + 1_000);
+});
+
+test("two inputs waiting at once, or a wait while stopped, are idle once", () => {
+  let now = 0;
+  const clock = new RunClock({ now: () => now });
+  clock.inputWaitBegins();
+  now = 1_000;
+  clock.inputWaitBegins();
+  clock.stopped();
+  now = 3_000;
+  clock.inputWaitEnds();
+  clock.continued();
+  now = 4_000;
+  clock.inputWaitEnds();
+  now = 5_000;
+  assert.equal(clock.workingMs(), 1_000);
+  // An ongoing wait is idle up to the moment asked.
+  clock.inputWaitBegins();
+  now = 6_000;
+  assert.equal(clock.workingMs(), 1_000);
+});