@torrent-tv/proxy 2.80.9 → 2.80.11

package/test/held-request-width.test.js

@@ -1,154 +1,155 @@
-/**
- * @file How far ahead of the viewer a held segment request may sit.
- *
- * A request is released when the viewer has moved away from it. "Moved away"
- * used to mean more than `MAX_LOOKAHEAD_SEGMENTS` — eight segments, which
- * happened to match a browser holding thirty seconds and would refuse three
- * quarters of the requests of one holding the whole cushion. The width is the
- * encoder's own look-ahead now, which is the same figure the browser sizes its
- * buffer from. Roadmap item 4, step 2.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { Timeline } from "../services/output/Timeline.js";
-import { mkdtemp, rm } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { HlsSessionManager } from "../services/hls-session-manager.js";
-import { fmp4Format } from "../services/segment-formats/fmp4.js";
-
-const SESSION_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
-const SEGMENT_SECONDS = 4;
-
-/**
- * @returns {Promise<{ manager: HlsSessionManager, dirPath: string }>}
- */
-async function managerWithSession() {
-  const dirPath = await mkdtemp(path.join(os.tmpdir(), "held-request-"));
-  const manager = new HlsSessionManager({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  manager.sessionsById.set(SESSION_ID, {
-    id: SESSION_ID,
-    dirPath,
-    // Where this file is cut, held by the file. A fixture that stated it
-    // on the session was describing what production no longer does.
-    timeline: new Timeline({
-      boundaries: Array.from({ length: 201 }, (_, index) => index * SEGMENT_SECONDS),
-      cutGrid: "uniform"
-    }),
-    state: "ready",
-    segmentFormat: fmp4Format,
-    segmentCount: 200,
-    useSyntheticPlaylist: true,
-    // The viewer is at segment #25.
-    furthestViewerSeconds: 100
-  });
-  return { manager, dirPath };
-}
-
-/**
- * @param {number} index
- * @returns {string}
- */
-function segment(index) {
-  return `segment-${String(index).padStart(5, "0")}.mp4`;
-}
-
-test("the width is the encoder's own look-ahead, in segments", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  const width = Math.ceil(manager.lookaheadSeconds / manager.segmentDurationSec);
-  assert.equal(width, 30, "120 s of look-ahead over 4 s segments");
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(25 + width)), true, "the far edge");
-  assert.equal(
-    manager.requestStillWanted(SESSION_ID, segment(25 + width + 1)),
-    false,
-    "past everything the encoder is allowed to have produced"
-  );
-});
-
-test("a request the old eight-segment width would have refused is kept", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  // #34 is nine segments ahead of the viewer — inside a 120 s cushion and
-  // outside the eight the width used to be. This is the request a browser
-  // holding the whole cushion makes constantly.
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(34)), true);
-});
-
-test("a segment behind the viewer is still released", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(24)), false);
-});
-
-test("a seek by one viewer does not release the request held for another", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  const session = manager.sessionsById.get(SESSION_ID);
-
-  // Both are watching the same copied picture, so both are this one session.
-  // One is at segment #25, the other far ahead at #150 — inside the fixture's
-  // own 200-segment timeline, since a position past the end of the grid is
-  // clamped to it and would prove nothing about the width.
-  manager.requestSeek(SESSION_ID, 100, "behind");
-  manager.requestSeek(SESSION_ID, 600, "ahead");
-
-  // The shared field now holds the leader's position, which is what the
-  // encoder is steered by and what every earlier release judged BOTH of them
-  // against.
-  assert.equal(session.furthestViewerSeconds, 600);
-
-  assert.equal(
-    manager.requestStillWanted(SESSION_ID, segment(26), "behind"),
-    true,
-    "the segment the viewer behind is waiting for is still theirs to wait for"
-  );
-  assert.equal(
-    manager.requestStillWanted(SESSION_ID, segment(26), "ahead"),
-    false,
-    "and for the one in front it is a place they have left"
-  );
-});
-
-test("a viewer's own head moves with their seek", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  // Their last request was at #25; they jump to 600 s, which is #150. The
-  // segment at the target must be wanted — refusing it there is the freeze of
-  // 2026-08-18.
-  manager.requestSeek(SESSION_ID, 600, "viewer");
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(150), "viewer"), true);
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(25), "viewer"), false);
-});
-
-test("a viewer nobody can name is judged against the one shared position", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  // A plain HTTP transport builds its own URLs and carries no id. The old
-  // behaviour is what remains, which for a single viewer is the same thing.
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(26), ""), true);
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(24), ""), false);
-});
+/**
+ * @file How far ahead of the viewer a held segment request may sit.
+ *
+ * A request is released when the viewer has moved away from it. "Moved away"
+ * used to mean more than `MAX_LOOKAHEAD_SEGMENTS` — eight segments, which
+ * happened to match a browser holding thirty seconds and would refuse three
+ * quarters of the requests of one holding the whole cushion. The width is the
+ * encoder's own look-ahead now, which is the same figure the browser sizes its
+ * buffer from. Roadmap item 4, step 2.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Timeline } from "../services/output/Timeline.js";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { HlsSessionManager } from "../services/hls-session-manager.js";
+import { fmp4Format } from "../services/segment-formats/fmp4.js";
+
+const SESSION_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+const SEGMENT_SECONDS = 4;
+
+/**
+ * @returns {Promise<{ manager: HlsSessionManager, dirPath: string }>}
+ */
+async function managerWithSession() {
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "held-request-"));
+  const manager = new HlsSessionManager({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  manager.sessionsById.set(SESSION_ID, {
+    id: SESSION_ID,
+    dirPath,
+    // Where this file is cut, held by the file. A fixture that stated it
+    // on the session was describing what production no longer does.
+    timeline: new Timeline({
+      boundaries: Array.from({ length: 201 }, (_, index) => index * SEGMENT_SECONDS),
+      cutGrid: "uniform"
+    }),
+    state: "ready",
+    segmentFormat: fmp4Format,
+    segmentCount: 200,
+    useSyntheticPlaylist: true,
+    // The viewer is at segment #25.
+    furthestViewerSeconds: 100
+  });
+  return { manager, dirPath };
+}
+
+/**
+ * @param {number} index
+ * @returns {string}
+ */
+function segment(index) {
+  return `segment-${String(index).padStart(5, "0")}.mp4`;
+}
+
+test("the width is the encoder's own look-ahead, in segments", async (t) => {
+  const { manager, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+
+  const width = Math.ceil(manager.lookaheadSeconds / manager.segmentDurationSec);
+  assert.equal(width, 30, "120 s of look-ahead over 4 s segments");
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(25 + width)), true, "the far edge");
+  assert.equal(
+    manager.requestStillWanted(SESSION_ID, segment(25 + width + 1)),
+    false,
+    "past everything the encoder is allowed to have produced"
+  );
+});
+
+test("a request the old eight-segment width would have refused is kept", async (t) => {
+  const { manager, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+
+  // #34 is nine segments ahead of the viewer — inside a 120 s cushion and
+  // outside the eight the width used to be. This is the request a browser
+  // holding the whole cushion makes constantly.
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(34)), true);
+});
+
+test("a segment behind the viewer is still released", async (t) => {
+  const { manager, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(24)), false);
+});
+
+test("a seek by one viewer does not release the request held for another", async (t) => {
+  const { manager, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  // Both are watching the same copied picture, so both are this one session.
+  // One is at segment #25, the other far ahead at #150 — inside the fixture's
+  // own 200-segment timeline, since a position past the end of the grid is
+  // clamped to it and would prove nothing about the width.
+  manager.requestSeek(SESSION_ID, 100, "behind");
+  manager.requestSeek(SESSION_ID, 600, "ahead");
+
+  // A SEEK DOES ONE THING: it puts the viewer where they now are. It used to
+  // write that position into five places, this session's shared field among
+  // them, and every held request was then judged against whoever moved last —
+  // which is exactly what this test exists to refuse. Each viewer's own
+  // position is what decides, and the two below are asked separately.
+  assert.equal(manager.viewers.get("behind").positionSeconds(), 100);
+  assert.equal(manager.viewers.get("ahead").positionSeconds(), 600);
+
+  assert.equal(
+    manager.requestStillWanted(SESSION_ID, segment(26), "behind"),
+    true,
+    "the segment the viewer behind is waiting for is still theirs to wait for"
+  );
+  assert.equal(
+    manager.requestStillWanted(SESSION_ID, segment(26), "ahead"),
+    false,
+    "and for the one in front it is a place they have left"
+  );
+});
+
+test("a viewer's own head moves with their seek", async (t) => {
+  const { manager, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+
+  // Their last request was at #25; they jump to 600 s, which is #150. The
+  // segment at the target must be wanted — refusing it there is the freeze of
+  // 2026-08-18.
+  manager.requestSeek(SESSION_ID, 600, "viewer");
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(150), "viewer"), true);
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(25), "viewer"), false);
+});
+
+test("a viewer nobody can name is judged against the one shared position", async (t) => {
+  const { manager, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+
+  // A plain HTTP transport builds its own URLs and carries no id. The old
+  // behaviour is what remains, which for a single viewer is the same thing.
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(26), ""), true);
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(24), ""), false);
+});

package/test/helpers/encode-run.js

@@ -1,128 +1,136 @@
-/**
- * @file A real `EncodeRun` over a process that is not real.
- *
- * Tests used to set a session's process fields by hand — `session.ffmpeg`,
- * `session.runState`, `session.encodeStartIndex` — which is how a test can pass
- * over code that no longer works: the fields were the thing under test as much
- * as the behaviour was. A run is an object now, so a test builds the object the
- * product builds and injects only the one thing a test may not have, which is a
- * child process.
- *
- * The pid is deliberately absent unless a test asks for one. `pause` and
- * `resume` send signals by pid, and a made-up number is somebody else's process
- * on the machine running the tests.
- */
-
-import { EncodeRun } from "../../services/encode/EncodeRun.js";
-
-/**
- * A child process that records what was done to it.
- *
- * @param {object} [options]
- * @param {number | null} [options.pid] - Only where a test genuinely exercises
- *   suspend or resume, and then it must be this process's own.
- * @returns {object}
- */
-export function fakeProcess({ pid = null, exitsWhenKilled = true } = {}) {
-  /** @type {Map<string, (...args: unknown[]) => void>} */
-  const listeners = new Map();
-  return {
-    pid,
-    killed: false,
-    exitCode: null,
-    signalCode: null,
-    /** Every signal it was sent, in order. */
-    signals: [],
-    stdout: { on() {} },
-    stderr: { on() {} },
-    on(event, handler) {
-      const kept = listeners.get(event) ?? [];
-      kept.push(handler);
-      listeners.set(event, kept);
-      return this;
-    },
-    once(event, handler) {
-      return this.on(event, handler);
-    },
-    kill(signal = "SIGTERM") {
-      this.signals.push(signal);
-      this.killed = true;
-      // A real process answers a signal by exiting, and it does so on a later
-      // turn. A fake that never exits makes every disposal wait out the grace
-      // period, which is two seconds a test spends proving nothing.
-      if (exitsWhenKilled && this.exitCode === null && this.signalCode === null) {
-        queueMicrotask(() => this.exit(null, signal));
-      }
-      return true;
-    },
-    /**
-     * Report an exit, as the real thing would.
-     *
-     * @param {number | null} code
-     * @param {string | null} [signal]
-     */
-    exit(code, signal = null) {
-      this.exitCode = code;
-      this.signalCode = signal;
-      for (const handler of listeners.get("exit") ?? []) {
-        handler(code, signal);
-      }
-    }
-  };
-}
-
-/** A logger that says nothing, for tests that are not about the log. */
-export const silentLogger = { info() {}, warn() {}, error() {} };
-
-/**
- * Add a run to a session, started, over a fake process.
- *
- * A session holds a SET of runs — as many as the machine affords — so a test
- * that wants two heads on one output calls this twice.
- *
- * @param {object} session - The session under test.
- * @param {object} [options]
- * @param {number} [options.from] - First segment number it is making.
- * @param {number} [options.to] - Last, inclusive; below `from` means no end.
- * @param {object} [options.process] - The process it should own.
- * @param {boolean} [options.producing] - Whether it has already made its first
- *   segment, which is what moves it out of starting.
- * @param {number | null} [options.lastSegmentIndex] - The film's last number,
- *   for telling a finished file from an input that dried up.
- * @param {boolean} [options.usesExplicitCuts]
- * @returns {import("../../services/encode/EncodeRun.js").EncodeRun}
- */
-export function startRunOn(session, options = {}) {
-  const {
-    from = 0,
-    to = -1,
-    process: child = fakeProcess(),
-    producing = true,
-    lastSegmentIndex = null,
-    usesExplicitCuts = false
-  } = options;
-  const run = new EncodeRun({
-    address: session.outputKey ?? session.id ?? "output",
-    encoder: { name: "libx264", kind: "software" },
-    from,
-    to,
-    buildArgs: () => [],
-    spawn: () => child,
-    logger: silentLogger,
-    lastSegmentIndex: () => lastSegmentIndex,
-    usesExplicitCuts
-  });
-  run.start("a test asked for it");
-  if (producing) {
-    // What moves a run out of starting is its first segment, in the product as
-    // here — so a run that is producing has made one, and its head stands one
-    // past where it began. `from` is still where it started, which is what a
-    // test asserting a run's position asks for.
-    run.noteProduced(from);
-  }
-  if (!(session.runs instanceof Set)) {
-    session.runs = new Set();
-  }
-  session.runs.add(run);
-  return run;
-}
+/**
+ * @file A real `EncodeRun` over a process that is not real.
+ *
+ * Tests used to set a session's process fields by hand — `session.ffmpeg`,
+ * `session.runState`, `session.encodeStartIndex` — which is how a test can pass
+ * over code that no longer works: the fields were the thing under test as much
+ * as the behaviour was. A run is an object now, so a test builds the object the
+ * product builds and injects only the one thing a test may not have, which is a
+ * child process.
+ *
+ * The pid is deliberately absent unless a test asks for one. `pause` and
+ * `resume` send signals by pid, and a made-up number is somebody else's process
+ * on the machine running the tests.
+ */
+
+import { EncodeRun } from "../../services/encode/EncodeRun.js";
+
+/**
+ * A child process that records what was done to it.
+ *
+ * @param {object} [options]
+ * @param {number | null} [options.pid] - Only where a test genuinely exercises
+ *   suspend or resume, and then it must be this process's own.
+ * @returns {object}
+ */
+export function fakeProcess({ pid = null, exitsWhenKilled = true } = {}) {
+  /** @type {Map<string, (...args: unknown[]) => void>} */
+  const listeners = new Map();
+  return {
+    pid,
+    killed: false,
+    exitCode: null,
+    signalCode: null,
+    /** Every signal it was sent, in order. */
+    signals: [],
+    stdout: { on() {} },
+    stderr: { on() {} },
+    on(event, handler) {
+      const kept = listeners.get(event) ?? [];
+      kept.push(handler);
+      listeners.set(event, kept);
+      return this;
+    },
+    once(event, handler) {
+      return this.on(event, handler);
+    },
+    kill(signal = "SIGTERM") {
+      this.signals.push(signal);
+      this.killed = true;
+      // A real process answers a signal by exiting, and it does so on a later
+      // turn. A fake that never exits makes every disposal wait out the grace
+      // period, which is two seconds a test spends proving nothing.
+      if (exitsWhenKilled && this.exitCode === null && this.signalCode === null) {
+        queueMicrotask(() => this.exit(null, signal));
+      }
+      return true;
+    },
+    /**
+     * Report an exit, as the real thing would.
+     *
+     * @param {number | null} code
+     * @param {string | null} [signal]
+     */
+    exit(code, signal = null) {
+      this.exitCode = code;
+      this.signalCode = signal;
+      for (const handler of listeners.get("exit") ?? []) {
+        handler(code, signal);
+      }
+    }
+  };
+}
+
+/** A logger that says nothing, for tests that are not about the log. */
+export const silentLogger = { info() {}, warn() {}, error() {} };
+
+/**
+ * Add a run to a session, started, over a fake process.
+ *
+ * A session holds a SET of runs — as many as the machine affords — so a test
+ * that wants two heads on one output calls this twice.
+ *
+ * @param {object} session - The session under test.
+ * @param {object} [options]
+ * @param {number} [options.from] - First segment number it is making.
+ * @param {number} [options.to] - Last, inclusive; below `from` means no end.
+ * @param {object} [options.process] - The process it should own.
+ * @param {boolean} [options.producing] - Whether it has already made its first
+ *   segment, which is what moves it out of starting.
+ * @param {number | null} [options.lastSegmentIndex] - The film's last number,
+ *   for telling a finished file from an input that dried up.
+ * @param {boolean} [options.usesExplicitCuts]
+ * @returns {import("../../services/encode/EncodeRun.js").EncodeRun}
+ */
+export function startRunOn(session, options = {}) {
+  const {
+    from = 0,
+    to = -1,
+    process: child = fakeProcess(),
+    producing = true,
+    lastSegmentIndex = null,
+    usesExplicitCuts = false,
+    // WHAT FFMPEG HAS REPORTED IT IS RUNNING AT. It says so on its progress
+    // channel from the first seconds, before any piece closes — so a run can be
+    // starting and already have a speed, and every real one does. Left at zero,
+    // the plan has no speed to compute an arrival from, every arrangement of
+    // encoders is equally hopeless, they all tie, and the encoder is taken away
+    // for changing nothing.
+    speedX = 0
+  } = options;
+  const run = new EncodeRun({
+    address: session.outputKey ?? session.id ?? "output",
+    encoder: { name: "libx264", kind: "software" },
+    from,
+    to,
+    buildArgs: () => [],
+    spawn: () => child,
+    logger: silentLogger,
+    lastSegmentIndex: () => lastSegmentIndex,
+    usesExplicitCuts
+  });
+  run.start("a test asked for it");
+  run.noteSpeed(speedX);
+  if (producing) {
+    // What moves a run out of starting is its first segment, in the product as
+    // here — so a run that is producing has made one, and its head stands one
+    // past where it began. `from` is still where it started, which is what a
+    // test asserting a run's position asks for.
+    run.noteProduced(from);
+  }
+  if (!(session.runs instanceof Set)) {
+    session.runs = new Set();
+  }
+  session.runs.add(run);
+  return run;
+}

package/test/keyframe-table-budget.test.js

@@ -79,7 +79,13 @@ test("the read goes on after the budget, so the next session of the file gets th
   assert.equal(first.arrived, false);
 
   answerLate({ times: [0, 5, 10], tolerance: 0, format: "matroska" });
-  await new Promise((resolve) => setTimeout(resolve, 10));
+  // Every microtask this resolution queues, and not a chosen ten milliseconds.
+  // `setImmediate` runs after the whole microtask queue of this turn, so the
+  // answer has been taken in by the time it fires — where the ten milliseconds
+  // were a guess about how long that takes on whatever machine is running.
+  // Asking the reader again instead would have counted as another read, which
+  // is the very thing the last assertion here is about.
+  await new Promise((resolve) => { setImmediate(resolve); });
 
   const second = await sessions.readKeyframeTableWithin(FILE);
   assert.deepEqual(second.times, [0, 5, 10], "the late answer was kept, not thrown away");