@torrent-tv/proxy 2.89.1 → 2.89.2

package/test/stale-request-after-seek.test.js

@@ -1,158 +1,158 @@
-/**
- * @file A segment request steers nothing.
- *
- * Field 2026-08-17: the viewer seeked to 2083.4 s, both runs restarted at
- * segment #373, and a request for #371 — issued before the seek and reissued by
- * the player a second later — moved the encoder to #370. The viewer was at
- * #374 and waited for the encoder to come back to them.
- *
- * That was answered first by a guard: a request behind what the viewer had
- * REPORTED was refused, while the same traffic still moved the encoder when
- * nothing had been reported. The guard is gone with the thing it guarded. A
- * request for a file is not a statement about where anybody is, and nothing
- * about it belongs in the decision of where encoders go — that is read from the
- * priority map, which is built from where the viewers are and from nothing else.
- *
- * So the rule pinned here is now the whole rule, and it has no exception: a
- * request moves neither the encoder nor the viewer, whether or not the viewer
- * has said anything.
- */
-
-import assert from "node:assert/strict";
-import { SourceFile } from "../services/media/SourceFile.js";
-import { Timeline } from "../services/encode/output/Timeline.js";
-import test from "node:test";
-import { mkdtemp, rm } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-
-import { wireOutputs } from "../services/server/wire-outputs.js";
-import { startRunOn } from "./helpers/encode-run.js";
-import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-
-const SEGMENT_SECONDS = 4;
-const RUN_STARTS_AT = 373;
-const BEHIND_INDEX = 371;
-const SESSION_ID = "2222222233334444";
-
-/**
- * A live session whose run begins at #373 and whose directory is empty, so any
- * segment request is a request for something not yet produced.
- *
- * @returns {Promise<{ manager: object, session: object, dirPath: string }>}
- */
-async function sessionWithRunAt373() {
-  const dirPath = await mkdtemp(path.join(os.tmpdir(), "stale-request-"));
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  const session = {
-    id: SESSION_ID,
-    dirPath,
-    timeline: new Timeline({
-      boundaries: Array.from({ length: 901 }, (_, index) => index * SEGMENT_SECONDS),
-      cutGrid: "uniform"
-    }),
-    state: "ready",
-    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.mkv" }),
-    get inputFile() { return this.file; },
-    get audioFile() { return this.file; },
-    segmentFormat: fmp4Format,
-    segmentCount: 900,
-    startedAt: Date.now(),
-    lastAccessedAt: Date.now(),
-    runs: new Set(),
-    consumers: new Set(),
-    viewers: new Map(),
-    progress: { processedSeconds: RUN_STARTS_AT * SEGMENT_SECONDS },
-    useSyntheticPlaylist: true,
-    playlistText: "#EXTM3U\n",
-    lastError: "",
-    waitEpoch: 0
-  };
-  manager.outputs.set(SESSION_ID, session);
-  startRunOn(session, { from: RUN_STARTS_AT, usesExplicitCuts: true, speedX: 2 });
-  return { manager, session, dirPath };
-}
-
-/**
- * @param {object} manager
- * @param {object} session
- * @param {string} dirPath
- */
-async function tidy(manager, session, dirPath) {
-  if (session.seekSettleTimer) {
-    clearTimeout(session.seekSettleTimer);
-    session.seekSettleTimer = null;
-  }
-  manager.outputs.clear();
-  manager.stop?.();
-  await rm(dirPath, { recursive: true, force: true });
-}
-
-test("a request behind where the viewer said they are does not move the encoder", async (t) => {
-  const { manager, session, dirPath } = await sessionWithRunAt373();
-  t.after(async () => {
-    await tidy(manager, session, dirPath);
-  });
-
-  // The viewer stated their position: 2083.4 s, which is segment #520 here.
-  manager.viewerRequests.requestSeek(SESSION_ID, 2083.4, "viewer-1");
-
-  await manager.serving.getFileStream(
-    SESSION_ID,
-    fmp4Format.segmentFileName(BEHIND_INDEX)
-  );
-
-  // The field log's line was `seek settle → restart at segment #370`. Nothing
-  // aims an encoder from here at all now, so there is no destination for a
-  // stale request to become.
-  assert.equal(
-    session.seekTarget ?? null,
-    null,
-    "a request behind the viewer must not become the encoder's destination"
-  );
-  assert.equal(
-    session.seekSettleTimer ?? null,
-    null,
-    "and it must not arm a restart"
-  );
-});
-
-test("the same traffic moves nothing when the viewer has said nothing either", async (t) => {
-  const { manager, session, dirPath } = await sessionWithRunAt373();
-  t.after(async () => {
-    await tidy(manager, session, dirPath);
-  });
-
-  // THE CONTROL, INVERTED. It used to be that without a reported seek this very
-  // traffic DID move the encoder — the guard applied only to a viewer who had
-  // spoken. That exception is the thing that was removed: a request is evidence
-  // about what a player is reading, never about where a person is, and an
-  // encoder placed from it is placed from a number the player picked.
-  await manager.serving.getFileStream(
-    SESSION_ID,
-    fmp4Format.segmentFileName(BEHIND_INDEX)
-  );
-
-  assert.equal(session.seekTarget ?? null, null);
-  assert.equal(session.seekSettleTimer ?? null, null);
-});
-
-test("a request cannot move the viewer's position backwards", async (t) => {
-  const { manager, session, dirPath } = await sessionWithRunAt373();
-  t.after(async () => {
-    await tidy(manager, session, dirPath);
-  });
-
-  manager.viewerRequests.requestSeek(SESSION_ID, 2083.4, "viewer-1");
-  await manager.serving.getFileStream(SESSION_ID, fmp4Format.segmentFileName(BEHIND_INDEX));
-
-  assert.ok(
-    Math.abs((manager.viewers.get("viewer-1")?.positionSeconds() ?? -1) - 2083.4) < 1,
-    "a stale request must not rewrite what the viewer said about themselves"
-  );
-});
+/**
+ * @file A segment request steers nothing.
+ *
+ * Field 2026-08-17: the viewer seeked to 2083.4 s, both runs restarted at
+ * segment #373, and a request for #371 — issued before the seek and reissued by
+ * the player a second later — moved the encoder to #370. The viewer was at
+ * #374 and waited for the encoder to come back to them.
+ *
+ * That was answered first by a guard: a request behind what the viewer had
+ * REPORTED was refused, while the same traffic still moved the encoder when
+ * nothing had been reported. The guard is gone with the thing it guarded. A
+ * request for a file is not a statement about where anybody is, and nothing
+ * about it belongs in the decision of where encoders go — that is read from the
+ * priority map, which is built from where the viewers are and from nothing else.
+ *
+ * So the rule pinned here is now the whole rule, and it has no exception: a
+ * request moves neither the encoder nor the viewer, whether or not the viewer
+ * has said anything.
+ */
+
+import assert from "node:assert/strict";
+import { SourceFile } from "../services/media/SourceFile.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
+import test from "node:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { wireOutputs } from "../services/server/wire-outputs.js";
+import { startRunOn } from "./helpers/encode-run.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
+
+const SEGMENT_SECONDS = 4;
+const RUN_STARTS_AT = 373;
+const BEHIND_INDEX = 371;
+const SESSION_ID = "2222222233334444";
+
+/**
+ * A live session whose run begins at #373 and whose directory is empty, so any
+ * segment request is a request for something not yet produced.
+ *
+ * @returns {Promise<{ manager: object, session: object, dirPath: string }>}
+ */
+async function sessionWithRunAt373() {
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "stale-request-"));
+  const manager = wireOutputs({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  const session = {
+    id: SESSION_ID,
+    dirPath,
+    timeline: new Timeline({
+      boundaries: Array.from({ length: 901 }, (_, index) => index * SEGMENT_SECONDS),
+      cutGrid: "uniform"
+    }),
+    state: "ready",
+    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.mkv" }),
+    get inputFile() { return this.file; },
+    get audioFile() { return this.file; },
+    segmentFormat: fmp4Format,
+    segmentCount: 900,
+    startedAt: Date.now(),
+    lastAccessedAt: Date.now(),
+    runs: new Set(),
+    consumers: new Set(),
+    viewers: new Map(),
+    progress: { processedSeconds: RUN_STARTS_AT * SEGMENT_SECONDS },
+    useSyntheticPlaylist: true,
+    playlistText: "#EXTM3U\n",
+    lastError: "",
+    waitEpoch: 0
+  };
+  manager.outputs.set(SESSION_ID, session);
+  startRunOn(session, { from: RUN_STARTS_AT, usesExplicitCuts: true, speedX: 2 });
+  return { manager, session, dirPath };
+}
+
+/**
+ * @param {object} manager
+ * @param {object} session
+ * @param {string} dirPath
+ */
+async function tidy(manager, session, dirPath) {
+  if (session.seekSettleTimer) {
+    clearTimeout(session.seekSettleTimer);
+    session.seekSettleTimer = null;
+  }
+  manager.outputs.clear();
+  manager.stop?.();
+  await rm(dirPath, { recursive: true, force: true });
+}
+
+test("a request behind where the viewer said they are does not move the encoder", async (t) => {
+  const { manager, session, dirPath } = await sessionWithRunAt373();
+  t.after(async () => {
+    await tidy(manager, session, dirPath);
+  });
+
+  // The viewer stated their position: 2083.4 s, which is segment #520 here.
+  manager.viewerRequests.requestSeek(SESSION_ID, 2083.4, "viewer-1");
+
+  await manager.serving.getFileStream(
+    SESSION_ID,
+    fmp4Format.segmentFileName(BEHIND_INDEX)
+  );
+
+  // The field log's line was `seek settle → restart at segment #370`. Nothing
+  // aims an encoder from here at all now, so there is no destination for a
+  // stale request to become.
+  assert.equal(
+    session.seekTarget ?? null,
+    null,
+    "a request behind the viewer must not become the encoder's destination"
+  );
+  assert.equal(
+    session.seekSettleTimer ?? null,
+    null,
+    "and it must not arm a restart"
+  );
+});
+
+test("the same traffic moves nothing when the viewer has said nothing either", async (t) => {
+  const { manager, session, dirPath } = await sessionWithRunAt373();
+  t.after(async () => {
+    await tidy(manager, session, dirPath);
+  });
+
+  // THE CONTROL, INVERTED. It used to be that without a reported seek this very
+  // traffic DID move the encoder — the guard applied only to a viewer who had
+  // spoken. That exception is the thing that was removed: a request is evidence
+  // about what a player is reading, never about where a person is, and an
+  // encoder placed from it is placed from a number the player picked.
+  await manager.serving.getFileStream(
+    SESSION_ID,
+    fmp4Format.segmentFileName(BEHIND_INDEX)
+  );
+
+  assert.equal(session.seekTarget ?? null, null);
+  assert.equal(session.seekSettleTimer ?? null, null);
+});
+
+test("a request cannot move the viewer's position backwards", async (t) => {
+  const { manager, session, dirPath } = await sessionWithRunAt373();
+  t.after(async () => {
+    await tidy(manager, session, dirPath);
+  });
+
+  manager.viewerRequests.requestSeek(SESSION_ID, 2083.4, "viewer-1");
+  await manager.serving.getFileStream(SESSION_ID, fmp4Format.segmentFileName(BEHIND_INDEX));
+
+  assert.ok(
+    Math.abs((manager.viewers.get("viewer-1")?.positionSeconds() ?? -1) - 2083.4) < 1,
+    "a stale request must not rewrite what the viewer said about themselves"
+  );
+});

package/test/startup-readings.test.js

@@ -1,124 +1,124 @@
-/**
- * @file What this host must have measured before the first viewer arrives.
- *
- * The quality offer, the number of encoders and every decision about moving one
- * are arithmetic over four figures: how fast this host encodes, how fast it
- * decodes, what a second job costs it, and what starting and stopping an
- * encoder cost. A figure nobody measured is reported as zero, and zero does not
- * read as "unknown" — it reads as "free" or "instant", and the arithmetic then
- * answers confidently and wrongly.
- *
- * Two gaps this pins, both found 2026-09-10:
- *
- * 1. three of the four ran only when the chosen encoder was SOFTWARE, and two
- *    of those three are not about the encoder at all — a host with a GPU
- *    decodes in software just the same, and what a second job costs is a
- *    property of the machine. A GPU host measured none of them;
- * 2. starting and stopping were learned only from runs that had already ENDED,
- *    so at a cold open both were zero and moving an encoder was free. Field
- *    2026-09-08: an encoder moved between two adjacent numbers every half
- *    second and produced nothing.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
-import { NvencEncoder } from "../services/encode/NvencEncoder.js";
-import { QsvEncoder } from "../services/encode/QsvEncoder.js";
-import { VaapiEncoder } from "../services/encode/VaapiEncoder.js";
-import { V4l2m2mEncoder } from "../services/encode/V4l2m2mEncoder.js";
-import { RunCosts } from "../services/encode/run-costs.js";
-
-const HERE = path.dirname(fileURLToPath(import.meta.url));
-
-test("every encoder kind can say how to measure itself", () => {
-  const kinds = [
-    new SoftwareEncoder(),
-    new NvencEncoder(),
-    new QsvEncoder(),
-    new VaapiEncoder("/dev/dri/renderD128"),
-    new V4l2m2mEncoder()
-  ];
-  for (const encoder of kinds) {
-    const args = encoder.benchmarkArgs(null);
-    assert.ok(Array.isArray(args) && args.length >= 2, `${encoder.name} says nothing`);
-    assert.ok(args.includes("-c:v"), `${encoder.name} does not name a codec`);
-    assert.ok(
-      args.some((arg) => String(arg).includes(encoder.name)),
-      `${encoder.name} does not name itself`
-    );
-  }
-});
-
-test("a kind with a ladder is measured at every rung of it", () => {
-  for (const encoder of [new SoftwareEncoder(), new NvencEncoder(), new QsvEncoder()]) {
-    const ladder = encoder.speedLadder;
-    assert.ok(ladder.values.length > 1, `${encoder.name} declares no ladder to walk`);
-    const rungs = ladder.values.map((rung) => encoder.benchmarkArgs(rung).join(" "));
-    assert.equal(new Set(rungs).size, ladder.values.length, `${encoder.name} gives the same arguments for different rungs`);
-  }
-});
-
-test("nothing about the machine is asked only of a software encoder", () => {
-  // Decoding and contention are properties of the host. Asked only where the
-  // encoder was software, a host with a GPU had neither, and the quality offer
-  // could not price a re-encode nor a second process.
-  const server = readFileSync(path.join(HERE, "..", "server.js"), "utf8");
-  for (const call of ["benchmarkDecodeCost", "benchmarkContention"]) {
-    const at = server.indexOf(call);
-    assert.ok(at > 0, `${call} is not called at startup at all`);
-    const before = server.slice(Math.max(0, at - 200), at);
-    assert.equal(
-      before.includes('kind === "software"'),
-      false,
-      `${call} is still gated on the encoder being software`
-    );
-  }
-});
-
-test("the calibration is given the encoder that will actually run, and software beside it", () => {
-  const server = readFileSync(path.join(HERE, "..", "server.js"), "utf8");
-  assert.match(
-    server,
-    /calibrateEncoder\(\{[^}]*encoder: videoEncoder/,
-    "the calibration is not told which encoder to measure"
-  );
-  assert.match(
-    server,
-    /calibrateEncoder\(\{[^}]*encoder: softwareDescriptor\(\)/,
-    "software, which a failing device falls back to, is not calibrated"
-  );
-});
-
-test("a start and a stop are measured before any viewer, and reach the plan", () => {
-  const server = readFileSync(path.join(HERE, "..", "server.js"), "utf8");
-  assert.match(server, /await measureStartAndStop\(/, "nothing measures a start at startup");
-  assert.match(server, /\n    startStopCost,/, "the reading never reaches the wiring of the encoding");
-
-  const manager = readFileSync(path.join(HERE, "..", "services", "server", "wire-outputs.js"), "utf8");
-  assert.match(
-    manager,
-    /noteStartupCosts\(startStopCost\)/,
-    "the reading never reaches the encoding orchestrator"
-  );
-});
-
-test("with a startup reading, a cold plan is not told that starting is free", () => {
-  const costs = new RunCosts();
-  assert.equal(costs.seconds().firstByteWaitSec, 0, "nothing measured yet is nothing");
-
-  costs.noteStartup({ firstByteWaitSec: 0.68, killCostSec: 0.02 });
-  const cold = costs.seconds();
-  assert.equal(cold.firstByteWaitSec, 0.68, "the startup reading is not used");
-  assert.equal(cold.killCostSec, 0.02);
-
-  // A real run replaces it: the startup figure is where the plan starts from,
-  // not where it stays.
-  costs.note({ firstOutputMs: 4000, dyingMs: 300 });
-  const warm = costs.seconds();
-  assert.equal(warm.firstByteWaitSec, 4);
-  assert.equal(warm.killCostSec, 0.3);
-});
+/**
+ * @file What this host must have measured before the first viewer arrives.
+ *
+ * The quality offer, the number of encoders and every decision about moving one
+ * are arithmetic over four figures: how fast this host encodes, how fast it
+ * decodes, what a second job costs it, and what starting and stopping an
+ * encoder cost. A figure nobody measured is reported as zero, and zero does not
+ * read as "unknown" — it reads as "free" or "instant", and the arithmetic then
+ * answers confidently and wrongly.
+ *
+ * Two gaps this pins, both found 2026-09-10:
+ *
+ * 1. three of the four ran only when the chosen encoder was SOFTWARE, and two
+ *    of those three are not about the encoder at all — a host with a GPU
+ *    decodes in software just the same, and what a second job costs is a
+ *    property of the machine. A GPU host measured none of them;
+ * 2. starting and stopping were learned only from runs that had already ENDED,
+ *    so at a cold open both were zero and moving an encoder was free. Field
+ *    2026-09-08: an encoder moved between two adjacent numbers every half
+ *    second and produced nothing.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
+import { NvencEncoder } from "../services/encode/NvencEncoder.js";
+import { QsvEncoder } from "../services/encode/QsvEncoder.js";
+import { VaapiEncoder } from "../services/encode/VaapiEncoder.js";
+import { V4l2m2mEncoder } from "../services/encode/V4l2m2mEncoder.js";
+import { RunCosts } from "../services/encode/run-costs.js";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+
+test("every encoder kind can say how to measure itself", () => {
+  const kinds = [
+    new SoftwareEncoder(),
+    new NvencEncoder(),
+    new QsvEncoder(),
+    new VaapiEncoder("/dev/dri/renderD128"),
+    new V4l2m2mEncoder()
+  ];
+  for (const encoder of kinds) {
+    const args = encoder.benchmarkArgs(null);
+    assert.ok(Array.isArray(args) && args.length >= 2, `${encoder.name} says nothing`);
+    assert.ok(args.includes("-c:v"), `${encoder.name} does not name a codec`);
+    assert.ok(
+      args.some((arg) => String(arg).includes(encoder.name)),
+      `${encoder.name} does not name itself`
+    );
+  }
+});
+
+test("a kind with a ladder is measured at every rung of it", () => {
+  for (const encoder of [new SoftwareEncoder(), new NvencEncoder(), new QsvEncoder()]) {
+    const ladder = encoder.speedLadder;
+    assert.ok(ladder.values.length > 1, `${encoder.name} declares no ladder to walk`);
+    const rungs = ladder.values.map((rung) => encoder.benchmarkArgs(rung).join(" "));
+    assert.equal(new Set(rungs).size, ladder.values.length, `${encoder.name} gives the same arguments for different rungs`);
+  }
+});
+
+test("nothing about the machine is asked only of a software encoder", () => {
+  // Decoding and contention are properties of the host. Asked only where the
+  // encoder was software, a host with a GPU had neither, and the quality offer
+  // could not price a re-encode nor a second process.
+  const server = readFileSync(path.join(HERE, "..", "server.js"), "utf8");
+  for (const call of ["benchmarkDecodeCost", "benchmarkContention"]) {
+    const at = server.indexOf(call);
+    assert.ok(at > 0, `${call} is not called at startup at all`);
+    const before = server.slice(Math.max(0, at - 200), at);
+    assert.equal(
+      before.includes('kind === "software"'),
+      false,
+      `${call} is still gated on the encoder being software`
+    );
+  }
+});
+
+test("the calibration is given the encoder that will actually run, and software beside it", () => {
+  const server = readFileSync(path.join(HERE, "..", "server.js"), "utf8");
+  assert.match(
+    server,
+    /calibrateEncoder\(\{[^}]*encoder: videoEncoder/,
+    "the calibration is not told which encoder to measure"
+  );
+  assert.match(
+    server,
+    /calibrateEncoder\(\{[^}]*encoder: softwareDescriptor\(\)/,
+    "software, which a failing device falls back to, is not calibrated"
+  );
+});
+
+test("a start and a stop are measured before any viewer, and reach the plan", () => {
+  const server = readFileSync(path.join(HERE, "..", "server.js"), "utf8");
+  assert.match(server, /await measureStartAndStop\(/, "nothing measures a start at startup");
+  assert.match(server, /\n    startStopCost,/, "the reading never reaches the wiring of the encoding");
+
+  const manager = readFileSync(path.join(HERE, "..", "services", "server", "wire-outputs.js"), "utf8");
+  assert.match(
+    manager,
+    /noteStartupCosts\(startStopCost\)/,
+    "the reading never reaches the encoding orchestrator"
+  );
+});
+
+test("with a startup reading, a cold plan is not told that starting is free", () => {
+  const costs = new RunCosts();
+  assert.equal(costs.seconds().firstByteWaitSec, 0, "nothing measured yet is nothing");
+
+  costs.noteStartup({ firstByteWaitSec: 0.68, killCostSec: 0.02 });
+  const cold = costs.seconds();
+  assert.equal(cold.firstByteWaitSec, 0.68, "the startup reading is not used");
+  assert.equal(cold.killCostSec, 0.02);
+
+  // A real run replaces it: the startup figure is where the plan starts from,
+  // not where it stays.
+  costs.note({ firstOutputMs: 4000, dyingMs: 300 });
+  const warm = costs.seconds();
+  assert.equal(warm.firstByteWaitSec, 4);
+  assert.equal(warm.killCostSec, 0.3);
+});