@torrent-tv/proxy 2.75.0 → 2.76.1

package/test/output-spec.test.js

@@ -0,0 +1,157 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { AudioOutput, CutGrid, OutputSpec, VideoOutput } from "../services/output/OutputSpec.js";
+
+const TORRENT = "torrent:11f0929918e2b5aa2e5b71ecdbe5c0f1a4bbf7d1";
+
+/**
+ * The picture of a file, copied, cut at that file's own keyframes.
+ *
+ * @param {object} [over]
+ * @returns {OutputSpec}
+ */
+function copiedPicture(over = {}) {
+  return new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "fmp4",
+    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
+    video: new VideoOutput({ fileIndex: 0, encode: null }),
+    audio: null,
+    ...over
+  });
+}
+
+test("two viewers who chose different soundtracks share one copied picture", () => {
+  // The measurement of 2026-09-03: both sessions described the same thing word
+  // for word and answered `segment-00000.mp4` with the same 4141899 bytes. The
+  // soundtrack they picked is not a property of a picture that carries no
+  // sound, so it cannot tell the two apart.
+  assert.equal(copiedPicture().toKey(), copiedPicture().toKey());
+  assert.equal(copiedPicture().carries, "video-only");
+});
+
+test("the viewer's viewport does not fork a picture that is copied", () => {
+  // A copy is the source's own size whatever box was asked for, so there is
+  // nowhere for a target to appear in the key.
+  const key = copiedPicture().toKey();
+  assert.ok(!key.includes("x"), `a copied picture states no box: ${key}`);
+});
+
+test("two heights of one picture are two outputs", () => {
+  const at720 = copiedPicture({
+    video: new VideoOutput({ fileIndex: 0, encode: { width: 1280, height: 720, manual: true } })
+  });
+  const at480 = copiedPicture({
+    video: new VideoOutput({ fileIndex: 0, encode: { width: 854, height: 480, manual: true } })
+  });
+  assert.notEqual(at720.toKey(), at480.toKey());
+});
+
+test("a height the viewer forced is not the same output as one the budget may move", () => {
+  const forced = copiedPicture({
+    video: new VideoOutput({ fileIndex: 0, encode: { width: 1280, height: 720, manual: true } })
+  });
+  const chosen = copiedPicture({
+    video: new VideoOutput({ fileIndex: 0, encode: { width: 1280, height: 720, manual: false } })
+  });
+  assert.notEqual(forced.toKey(), chosen.toKey());
+});
+
+test("a soundtrack is named by the file it lives in and the track inside it", () => {
+  // Not by the flat number the browser sends: that number spans the picture's
+  // own tracks and the files beside it, so it means different things for
+  // different pictures of one torrent.
+  const dub = new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "fmp4",
+    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
+    audio: new AudioOutput({ fileIndex: 7, trackIndex: 0, transcode: true })
+  });
+  assert.equal(dub.carries, "audio-only");
+  assert.ok(dub.toKey().includes("a=7/0/aac"), dub.toKey());
+});
+
+test("one soundtrack cut for two different pictures is two outputs", () => {
+  // The grid of a soundtrack is the picture's, so a rendition made for episode
+  // one cannot stand in for one made for episode two even when the dub is the
+  // same file.
+  const forFirst = new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "fmp4",
+    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
+    audio: new AudioOutput({ fileIndex: 7, trackIndex: 0, transcode: true })
+  });
+  const forSecond = new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "fmp4",
+    grid: new CutGrid({ kind: "keyframe", fileIndex: 1 }),
+    audio: new AudioOutput({ fileIndex: 7, trackIndex: 0, transcode: true })
+  });
+  assert.notEqual(forFirst.toKey(), forSecond.toKey());
+});
+
+test("a copied soundtrack and a re-encoded one are two outputs", () => {
+  const copied = new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "fmp4",
+    grid: new CutGrid({ kind: "uniform", fileIndex: 0 }),
+    audio: new AudioOutput({ fileIndex: 0, trackIndex: 1, transcode: false })
+  });
+  const encoded = new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "fmp4",
+    grid: new CutGrid({ kind: "uniform", fileIndex: 0 }),
+    audio: new AudioOutput({ fileIndex: 0, trackIndex: 1, transcode: true })
+  });
+  assert.notEqual(copied.toKey(), encoded.toKey());
+});
+
+test("a browser without rendition groups gets an output carrying both tracks", () => {
+  const muxed = new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "mpegts",
+    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
+    video: new VideoOutput({ fileIndex: 0, encode: null }),
+    audio: new AudioOutput({ fileIndex: 0, trackIndex: 2, transcode: true })
+  });
+  assert.equal(muxed.carries, "muxed");
+  // And there the soundtrack DOES tell two of them apart, because the output
+  // really carries it.
+  const other = new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "mpegts",
+    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
+    video: new VideoOutput({ fileIndex: 0, encode: null }),
+    audio: new AudioOutput({ fileIndex: 0, trackIndex: 3, transcode: true })
+  });
+  assert.notEqual(muxed.toKey(), other.toKey());
+});
+
+test("the picture, its soundtrack and the two of them muxed are three outputs", () => {
+  const video = copiedPicture();
+  const audio = new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "fmp4",
+    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
+    audio: new AudioOutput({ fileIndex: 0, trackIndex: 0, transcode: true })
+  });
+  const muxed = copiedPicture({
+    audio: new AudioOutput({ fileIndex: 0, trackIndex: 0, transcode: true })
+  });
+  assert.equal(new Set([video.toKey(), audio.toKey(), muxed.toKey()]).size, 3);
+});
+
+test("two containers of the same tracks are two outputs", () => {
+  assert.notEqual(copiedPicture().toKey(), copiedPicture({ segmentFormatId: "mpegts" }).toKey());
+});
+
+test("the same tracks of two different torrents are two outputs", () => {
+  assert.notEqual(copiedPicture().toKey(), copiedPicture({ sourceKey: "torrent:0000" }).toKey());
+});
+
+test("a picture cut at keyframes and the same picture cut on the even grid are two outputs", () => {
+  assert.notEqual(
+    copiedPicture().toKey(),
+    copiedPicture({ grid: new CutGrid({ kind: "uniform", fileIndex: 0 }) }).toKey()
+  );
+});

package/test/produced-copy-choice.test.js

@@ -1,6 +1,5 @@
 /**
- * @file When several runs have written the same segment number, which copy
- * answers — and what happens to the one that cannot.
+ * @file A piece that cannot be played: waited for, or removed and made again.
  *
  * Field 2026-09-03. A run was suspended 548 ms after it started with
  * `segment-00025.mp4` newly opened, so the file stayed at zero bytes. From then
@@ -8,17 +7,23 @@
  * other's reason: the look-ahead counted the NAME, found the numbering unbroken
  * through #83, called it `420s ahead of the viewer` and kept the encoder
  * stopped; the serving path read the FILE, found it short of a track, and
- * waited for a run that had produced nothing to finish it. A complete copy of
- * #25 lay in the previous run's directory the whole time and was never reached,
- * because the search returned the first name it found and stopped.
+ * waited for a run that had produced nothing to finish it.
  *
- * The viewer's picture stood still for ten minutes with the bytes they needed
- * already on the disk, on a transport measuring 3-9 ms round trip.
+ * The viewer's picture stood still for ten minutes on a transport measuring
+ * 3-9 ms round trip.
+ *
+ * The question of WHICH copy answers is gone with the directory-per-run scheme:
+ * there is one directory per output, runs are kept apart by their stretches,
+ * and one name is one file. What is left is the question that remains real —
+ * whether a file that cannot be played is being written now or was left by a
+ * run that has ended.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdir, mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
+import { SourceFile } from "../services/source/SourceFile.js";
+import { Timeline } from "../services/output/Timeline.js";
+import { mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import {
@@ -26,6 +31,7 @@ import {
   discardOpenPiece,
   usableSegmentIndices
 } from "../services/hls-session-manager.js";
+import { startRunOn } from "./helpers/encode-run.js";
 import { fmp4Format } from "../services/segment-formats/fmp4.js";
 
 const MOVIE_TIMESCALE = 1000;
@@ -137,14 +143,12 @@ function halfPiece(offsetSeconds) {
 }
 
 /**
- * A session whose runs are laid out on disk exactly as the field case was.
+ * A session with the output directory every run writes into.
  *
  * @returns {Promise<{ manager: HlsSessionManager, session: object, dirPath: string }>}
  */
-async function sessionWithTwoRuns() {
+async function sessionOnOneDirectory() {
   const dirPath = await mkdtemp(path.join(os.tmpdir(), "produced-copy-"));
-  await mkdir(path.join(dirPath, "run-1"), { recursive: true });
-  await mkdir(path.join(dirPath, "run-2"), { recursive: true });
   const manager = new HlsSessionManager({
     enabled: true,
     ffmpegBin: "ffmpeg",
@@ -154,90 +158,56 @@ async function sessionWithTwoRuns() {
   const session = {
     id: SESSION_ID,
     dirPath,
-    runDirPath: path.join(dirPath, "run-2"),
-    runSerial: 2,
+    // 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: [0, SEGMENT_SECONDS, 25, 37.5, 50],
+      cutGrid: "uniform"
+    }),
     state: "ready",
-    fileName: "Drifters - 04.mkv",
+    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "Drifters - 04.mkv" }),
+    // An ordinary session reads its own file, and its sound is inside it. The
+    // three differ only for a soundtrack shipped as a file of its own.
+    get inputFile() { return this.file; },
+    get audioFile() { return this.file; },
     startedAt: Date.now(),
     createEntryMs: Date.now(),
     lastAccessedAt: Date.now(),
-    // A run exists and is alive — the state the field case was in, and the one
-    // in which the old test called every leftover "still being written".
-    ffmpeg: { pid: 0, killed: false, kill() {} },
+    runs: new Set(),
     lastError: "",
     consumers: new Set(),
-    netReports: new Map(),
+    viewers: new Map(),
     segmentFormat: fmp4Format,
-    usesExplicitCuts: true,
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
-    segmentBoundaries: [0, SEGMENT_SECONDS, 25, 37.5, 50],
     initBytes: fmp4Format.extractInit(wholePiece(0)),
-    encodeStartIndex: 0,
     firstSegmentLogged: false,
     waitEpoch: 0
   };
   manager.sessionsById.set(SESSION_ID, session);
+  // A run exists and is alive — the state the field case was in, and the one in
+  // which the old test called every leftover "still being written".
+  startRunOn(session, { from: 0, usesExplicitCuts: true });
   return { manager, session, dirPath };
 }
 
-test("the complete copy answers when the newest run's is empty", async (t) => {
-  const { manager, dirPath } = await sessionWithTwoRuns();
-  t.after(async () => {
-    await manager.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  // run-1 made this segment and finished it; run-2 opened it and was stopped.
-  await writeFile(path.join(dirPath, "run-1", "segment-00001.mp4"), wholePiece(SEGMENT_SECONDS));
-  await writeFile(path.join(dirPath, "run-1", "segment-00002.mp4"), wholePiece(25));
-  await writeFile(path.join(dirPath, "run-2", "segment-00001.mp4"), Buffer.alloc(0));
 
-  const result = await manager.getFileStream(SESSION_ID, "segment-00001.mp4", { requestSeq: 1 });
-
-  assert.equal(
-    result.kind,
-    "file",
-    "a complete copy exists one run away; holding here is what froze the picture for ten minutes"
-  );
-  const chunks = [];
-  for await (const chunk of result.stream) {
-    chunks.push(chunk);
-  }
-  assert.ok(Buffer.concat(chunks).length > 0, "and it must be the copy with bytes in it");
-});
-
-test("a copy short of a track is passed over for an older one that is whole", async (t) => {
-  const { manager, dirPath } = await sessionWithTwoRuns();
-  t.after(async () => {
-    await manager.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  // Not empty — a terminated run closes its file properly, with only what it
-  // had muxed by then, which after a seek-restart is routinely one track of two.
-  await writeFile(path.join(dirPath, "run-1", "segment-00001.mp4"), wholePiece(SEGMENT_SECONDS));
-  await writeFile(path.join(dirPath, "run-1", "segment-00002.mp4"), wholePiece(25));
-  await writeFile(path.join(dirPath, "run-2", "segment-00001.mp4"), halfPiece(SEGMENT_SECONDS));
-
-  const result = await manager.getFileStream(SESSION_ID, "segment-00001.mp4", { requestSeq: 1 });
-
-  assert.equal(result.kind, "file", "a piece carrying one track of two is not servable; the whole one is");
-});
 
 test("a leftover of a run that has ended is removed, not waited on", async (t) => {
-  const { manager, dirPath } = await sessionWithTwoRuns();
+  const { manager, session, dirPath } = await sessionOnOneDirectory();
   t.after(async () => {
     await manager.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
-  // The only copy, and it belongs to a run that is gone. The current run —
-  // run-2 — has written nothing, so calling this "still being written" waits on
-  // a process that will never touch it.
-  await writeFile(path.join(dirPath, "run-1", "segment-00001.mp4"), Buffer.alloc(0));
+  // Opened by a run that is gone, and nothing is encoding now — so calling it
+  // "still being written" waits on a process that will never touch it.
+  session.runs = new Set();
+  await writeFile(path.join(dirPath, "segment-00001.mp4"), Buffer.alloc(0));
 
   const result = await manager.getFileStream(SESSION_ID, "segment-00001.mp4", { requestSeq: 1 });
 
   assert.equal(result.kind, "warming-up", "nothing servable exists yet, so the viewer waits");
-  const left = await readdir(path.join(dirPath, "run-1"));
+  const left = (await readdir(dirPath)).filter((name) => name === "segment-00001.mp4");
   assert.deepEqual(
     left,
     [],
@@ -246,7 +216,7 @@ test("a leftover of a run that has ended is removed, not waited on", async (t) =
 });
 
 test("the current run's own unfinished piece is waited for, never deleted", async (t) => {
-  const { manager, session, dirPath } = await sessionWithTwoRuns();
+  const { manager, session, dirPath } = await sessionOnOneDirectory();
   t.after(async () => {
     await manager.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
@@ -255,13 +225,15 @@ test("the current run's own unfinished piece is waited for, never deleted", asyn
   // written right now. Deleting it is the 2026-08-06 incident: #225 was removed
   // 14 s into the run producing it, which then wrote on into a file nobody
   // could open, and the segment never appeared.
-  session.encodeStartIndex = 1;
-  await writeFile(path.join(dirPath, "run-2", "segment-00001.mp4"), Buffer.alloc(0));
+  //
+  // The live run begins at #1, so #1 is its own first piece.
+  startRunOn(session, { from: 1, producing: false, usesExplicitCuts: true });
+  await writeFile(path.join(dirPath, "segment-00001.mp4"), Buffer.alloc(0));
 
   const result = await manager.getFileStream(SESSION_ID, "segment-00001.mp4", { requestSeq: 1 });
 
   assert.equal(result.kind, "warming-up");
-  const left = await readdir(path.join(dirPath, "run-2"));
+  const left = (await readdir(dirPath)).filter((name) => name === "segment-00001.mp4");
   assert.deepEqual(left, ["segment-00001.mp4"], "the live run's own output must be left alone");
 });
 
@@ -270,43 +242,37 @@ test("the look-ahead does not count a file with nothing in it", async (t) => {
   t.after(async () => {
     await rm(dirPath, { recursive: true, force: true });
   });
-  const runTwo = path.join(dirPath, "run-2");
-  const runOne = path.join(dirPath, "run-1");
-  await mkdir(runTwo, { recursive: true });
-  await mkdir(runOne, { recursive: true });
-  await writeFile(path.join(runTwo, "segment-00000.mp4"), wholePiece(0));
-  await writeFile(path.join(runTwo, "segment-00001.mp4"), Buffer.alloc(0));
+  await writeFile(path.join(dirPath, "segment-00000.mp4"), wholePiece(0));
+  await writeFile(path.join(dirPath, "segment-00001.mp4"), Buffer.alloc(0));
 
   assert.deepEqual(
-    [...usableSegmentIndices([runTwo, runOne], fmp4Format, new Set())].sort((a, b) => a - b),
+    [...usableSegmentIndices([dirPath], fmp4Format, new Set())].sort((a, b) => a - b),
     [0],
     "an empty file bridged the hole and bought the encoder a suspension it had not earned"
   );
 
-  // The same number, made properly by an earlier run: now it genuinely is ready.
-  await writeFile(path.join(runOne, "segment-00001.mp4"), wholePiece(SEGMENT_SECONDS));
+  // The same number, made properly: now it genuinely is ready.
+  await writeFile(path.join(dirPath, "segment-00001.mp4"), wholePiece(SEGMENT_SECONDS));
   assert.deepEqual(
-    [...usableSegmentIndices([runTwo, runOne], fmp4Format, new Set())].sort((a, b) => a - b),
+    [...usableSegmentIndices([dirPath], fmp4Format, new Set())].sort((a, b) => a - b),
     [0, 1],
-    "some run holds a copy with bytes in it, which is what the serving path will find"
+    "a copy with bytes in it, which is what the serving path will find"
   );
 });
 
-test("what a run holds is asked of the filesystem once per file", async (t) => {
+test("what the output holds is asked of the filesystem once per file", async (t) => {
   const dirPath = await mkdtemp(path.join(os.tmpdir(), "usable-memo-"));
   t.after(async () => {
     await rm(dirPath, { recursive: true, force: true });
   });
-  const runOne = path.join(dirPath, "run-1");
-  await mkdir(runOne, { recursive: true });
-  await writeFile(path.join(runOne, "segment-00000.mp4"), wholePiece(0));
+  await writeFile(path.join(dirPath, "segment-00000.mp4"), wholePiece(0));
   const known = new Set();
 
-  usableSegmentIndices([runOne], fmp4Format, known);
+  usableSegmentIndices([dirPath], fmp4Format, known);
 
   assert.deepEqual(
     [...known],
-    [path.join(runOne, "segment-00000.mp4")],
+    [path.join(dirPath, "segment-00000.mp4")],
     "a piece that has bytes never loses them, and this runs on the thread carrying the data channel"
   );
 });
@@ -319,7 +285,7 @@ test("a run killed with a piece open leaves nothing behind", async (t) => {
   await writeFile(path.join(dirPath, "segment-00000.mp4"), wholePiece(0));
   await writeFile(path.join(dirPath, "segment-00001.mp4"), Buffer.alloc(0));
 
-  assert.equal(await discardOpenPiece(dirPath, fmp4Format, null), 1);
+  assert.equal(await discardOpenPiece(dirPath, fmp4Format, null, null), 1);
   assert.deepEqual(
     await readdir(dirPath),
     ["segment-00000.mp4"],
@@ -336,7 +302,7 @@ test("a run that finished its last piece keeps it", async (t) => {
   await writeFile(path.join(dirPath, "segment-00001.mp4"), wholePiece(SEGMENT_SECONDS));
 
   assert.equal(
-    await discardOpenPiece(dirPath, fmp4Format, () => true),
+    await discardOpenPiece(dirPath, fmp4Format, null, () => true),
     null,
     "a stop between two cuts leaves good output; deleting it means encoding it twice"
   );
@@ -353,7 +319,7 @@ test("a last piece short of a track goes, even though it has bytes", async (t) =
   const init = fmp4Format.extractInit(wholePiece(0));
 
   assert.equal(
-    await discardOpenPiece(dirPath, fmp4Format, (raw) =>
+    await discardOpenPiece(dirPath, fmp4Format, null, (raw) =>
       fmp4Format.hasEveryTrack(fmp4Format.stripInit(raw), init)),
     1,
     "a size above zero is not the same as a piece that can be played"