@torrent-tv/proxy 2.80.18 → 2.81.0

package/test/encode-run.test.js

@@ -52,7 +52,8 @@ function makeRun(span = {}) {
       warn: (line) => lines.push(["warn", line])
     },
     now: () => 1000,
-    onEnded: (ended) => ends.push(ended)
+    onEnded: (ended) => ends.push(ended),
+    because: "nobody is making #10 and a viewer is waiting for it"
   });
   return { run, process: process_, lines, ends };
 }
@@ -61,8 +62,7 @@ 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 { run, lines } = makeRun();
-  run.start("nobody is making #10 and a viewer is waiting for it");
+  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
@@ -74,7 +74,6 @@ test("a start says why it is starting and with what", () => {
 
 test("its head is the next number it will make, and moves as it makes them", () => {
   const { run } = makeRun();
-  run.start("first");
   assert.equal(run.head, 10);
   run.noteProduced(10);
   run.noteProduced(11);
@@ -84,7 +83,6 @@ test("its head is the next number it will make, and moves as it makes them", ()
 
 test("reaching the end of its stretch and exiting is the one normal ending", () => {
   const { run, process, ends, lines } = makeRun({ from: 10, to: 12 });
-  run.start("first");
   for (const index of [10, 11, 12]) {
     run.noteProduced(index);
   }
@@ -99,7 +97,6 @@ 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.start("first");
   run.noteProduced(10);
   run.noteProduced(11);
   process.exitWith(0, null);
@@ -110,8 +107,7 @@ test("exiting cleanly short of its stretch is abnormal and says where it stopped
 });
 
 test("a non-zero exit is a failure carrying its code", () => {
-  const { run, process, ends, lines } = makeRun();
-  run.start("first");
+  const { process, ends, lines } = makeRun();
   process.exitWith(255, null);
   assert.equal(ends[0].ending, ENCODE_EXIT.FAILED);
   assert.equal(ends[0].code, 255);
@@ -122,7 +118,6 @@ 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.start("first");
   run.stop("moved past 20 segments that are already made");
   assert.deepEqual(process.signals, ["SIGTERM"]);
   process.exitWith(null, "SIGTERM");
@@ -133,7 +128,6 @@ test("our own kill is abnormal too, and carries the reason we gave", () => {
 
 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.start("first");
   run.noteProduced(10);
   process.exitWith(1, null);
   const ended = ends[0];
@@ -145,8 +139,7 @@ test("an ending reports the stretch, how far it got and how long it lived", () =
 });
 
 test("a process that could not be started ends like any other failure", () => {
-  const { run, process, ends } = makeRun();
-  run.start("first");
+  const { process, ends } = makeRun();
   process.emit("error", new Error("ENOENT"));
   assert.equal(ends[0].ending, ENCODE_EXIT.FAILED);
   assert.match(ends[0].because, /ENOENT/);

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

@@ -1,155 +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 });
-  });
-  // 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);
-});
+/**
+ * @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

@@ -117,9 +117,9 @@ export function startRunOn(session, options = {}) {
     spawn: () => child,
     logger: silentLogger,
     lastSegmentIndex: () => lastSegmentIndex,
-    usesExplicitCuts
+    usesExplicitCuts,
+    because: "a test asked for it"
   });
-  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