@torrent-tv/proxy 2.80.9 → 2.80.11

package/test/segment-serve-wiring.test.js

@@ -19,8 +19,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { SourceFile } from "../services/source/SourceFile.js";
 import { Timeline } from "../services/output/Timeline.js";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
+import { rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { HlsSessionManager } from "../services/hls-session-manager.js";
 import { ENCODE_RUN_STATE } from "../services/encode/encode-run-state.js";
@@ -32,6 +31,9 @@ const VIDEO_TIMESCALE = 90_000;
 const AUDIO_TIMESCALE = 48_000;
 const SEGMENT_START_SECONDS = 12.5;
 const SESSION_ID = "11111111-2222-3333-4444-555555555555";
+// Its own address, so this file's directory in the shared store is nobody
+// else's.
+const OUTPUT_KEY = "serve-wiring:fmt=fmp4:grid=uniform:video-only:v=0/copy";
 
 /**
  * @param {string} type
@@ -120,39 +122,62 @@ function selfContainedPiece(offsetSeconds) {
  * @returns {Promise<{ manager: HlsSessionManager, session: object, dirPath: string }>}
  */
 async function managerWithReadySegment(overrides = {}) {
-  const dirPath = await mkdtemp(path.join(os.tmpdir(), "segment-serve-"));
-  const piece = selfContainedPiece(SEGMENT_START_SECONDS);
-  // Two segments, because a piece is only finished once the next one exists.
-  await writeFile(path.join(dirPath, "segment-00000.mp4"), piece);
-  await writeFile(path.join(dirPath, "segment-00001.mp4"), piece);
-
   const manager = new HlsSessionManager({
     enabled: true,
     ffmpegBin: "ffmpeg",
     localBindHost: "127.0.0.1",
     localPort: 9090
   });
+  // ADDRESSED THE WAY PRODUCTION ADDRESSES IT. A session's segments live in the
+  // store's directory for its OUTPUT, and whether one is finished is asked of
+  // the store by that same address. This fixture used to make a directory of its
+  // own and leave the session with no output address at all, so it described a
+  // proxy that no longer exists and asked for a segment the store had never
+  // heard of.
+  manager.segmentStore.useFormat(OUTPUT_KEY, overrides.segmentFormat ?? fmp4Format);
+  const dirPath = manager.segmentStore.directoryFor(OUTPUT_KEY);
+  const piece = selfContainedPiece(SEGMENT_START_SECONDS);
+  // Two segments, because a piece is only finished once the next one exists.
+  await writeFile(path.join(dirPath, "segment-00000.mp4"), piece);
+  await writeFile(path.join(dirPath, "segment-00001.mp4"), piece);
+
   const session = {
     id: SESSION_ID,
+    outputKey: OUTPUT_KEY,
     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.
+    // LONGER THAN WHAT IS ON DISK. Two segments exist; the film runs to five, so
+    // there is film left to make and an encoder on it is warranted. With the
+    // whole film already made, an encoder is not — the plan stops it, correctly,
+    // and a fixture that wants a live run has to give it something to do.
     timeline: new Timeline({
-      boundaries: [0, SEGMENT_START_SECONDS, 25],
+      boundaries: [0, SEGMENT_START_SECONDS, 25, 37.5, 50, 62.5],
       cutGrid: "uniform"
     }),
     state: "ready",
-    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" }),
+    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" }).learn({ durationSeconds: 62.5 }),
     // 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; },
+    // WHAT THIS HOST ENCODES AT. Every real host measures it before a viewer
+    // exists, and the plan compares arrivals — which cannot be computed without
+    // it. A fixture that leaves it out describes a machine that has never
+    // measured itself: every arrangement is then equally hopeless, they all tie,
+    // and the plan takes the encoder away for changing nothing.
+    lastAloneSpeed: 2,
     startedAt: Date.now(),
     createEntryMs: Date.now(),
     lastAccessedAt: Date.now(),
     runs: new Set(),
     lastError: "",
     consumers: new Set(),
+    // Who is watching this output, and how long it is. Without the first the
+    // output has no viewers to build a priority map from, so it states no zones
+    // at all — which reads as nobody watching and stops every encoder on it.
+    viewers: new Map(),
+    segmentCount: 5,
     segmentFormat: overrides.segmentFormat ?? fmp4Format,
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
@@ -161,9 +186,20 @@ async function managerWithReadySegment(overrides = {}) {
     waitEpoch: 0
   };
   manager.sessionsById.set(SESSION_ID, session);
+  // SOMEBODY IS WATCHING IT. A segment is requested by a viewer, so a fixture
+  // that asks for one without stating a viewer describes a state production
+  // never reaches — and an output nobody is watching has every encoder on it
+  // stopped, which is right and is what left the run here reading STOPPED.
+  // NO PLAN RUNS HERE. This file is about the path that answers a request for a
+  // segment. Deciding how many encoders there should be and where is a separate
+  // question with its own checks, and letting it run inside these would spawn
+  // real ffmpeg processes and replace the very run each test is watching — the
+  // test would then be about the plan, and about it at its least stable.
+  manager.planEncodersNow = () => {};
+  manager.planEncodersSoon = () => {};
   // The run in force. The fixture's segments live directly in the session
   // directory, which is exactly what one run's directory is here.
-  startRunOn(session, { from: 0, usesExplicitCuts: true });
+  startRunOn(session, { from: 0, usesExplicitCuts: true, speedX: 2 });
   return { manager, session, dirPath };
 }
 
@@ -245,7 +281,7 @@ test("a fault while preparing an existing segment is named, not turned into a wa
 });
 
 test("a run's FIRST segment is served once the encoder has passed it, without waiting for a next one", async (t) => {
-  const { manager, session, dirPath } = await managerWithReadySegment();
+  const { manager, dirPath } = await managerWithReadySegment();
   t.after(async () => {
     await manager.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
@@ -254,7 +290,12 @@ test("a run's FIRST segment is served once the encoder has passed it, without wa
   // successor and nothing is producing one. Waiting for that successor is what
   // held #317 for 46 s and then answered 404 to a browser that had given up.
   await rm(path.join(dirPath, "segment-00001.mp4"));
-  session.progress = { processedSeconds: SEGMENT_START_SECONDS + 10 };
+  // WHAT PROVES IT INSTEAD: the encoder named it. ffmpeg writes the name of each
+  // piece on a channel of its own as it closes it, so a run's own first piece is
+  // proven the moment it is finished and the absence of a next one says nothing.
+  // This used to be inferred from the encoder's reported position instead, which
+  // is a different question — where it has read to, not what it has closed.
+  manager.segmentStore.markClosed(OUTPUT_KEY, 0);
 
   const result = await manager.getFileStream(SESSION_ID, "segment-00000.mp4", { requestSeq: 1 });
 
@@ -301,12 +342,26 @@ test("serving a run's own segment moves the run out of STARTING", async (t) => {
   // let go first, because this test is about ONE run and what serving does to
   // it.
   session.runs.clear();
-  const run = startRunOn(session, { from: 0, producing: false, usesExplicitCuts: true });
+  // ITS OWN PIECE, AND FILM STILL TO MAKE BEHIND IT. A run standing on material
+  // that already exists is moved forward — correctly — so a fixture that wants a
+  // live run has to put it where the work is. #1 is what it is making; #2..#4
+  // are unmade, so it is wanted; and the encoder has named #1 on its ready
+  // channel, which is what makes the piece servable at all.
+  const run = startRunOn(session, { from: 1, producing: false, usesExplicitCuts: true, speedX: 2 });
+  manager.segmentStore.markClosed(OUTPUT_KEY, 1);
   assert.equal(run.state, ENCODE_RUN_STATE.STARTING);
-
-  await manager.getFileStream(SESSION_ID, "segment-00000.mp4", { requestSeq: 1 });
-
-  assert.equal(run.state, ENCODE_RUN_STATE.PRODUCING);
+  assert.deepEqual(run.produced, [], "it has made nothing yet");
+
+  await manager.getFileStream(SESSION_ID, "segment-00001.mp4", { requestSeq: 1 });
+
+  // ASKED OF WHAT THE SERVE WROTE, not of the state that happens to follow it.
+  // The plan owns a run's life and may end it in the same turn for reasons of
+  // its own — the machine's budget, a viewer leaving, nothing left to make —
+  // and a check that reads the state afterwards is really asking what the plan
+  // decided. What the SERVE does is tell the run the piece is finished, and that
+  // is what moves it out of starting.
+  assert.deepEqual(run.produced, [1], "the serve told the run its piece is finished");
+  assert.equal(run.head, 2, "so the run stands one past it");
 });
 
 test("a segment behind a run's own start does not claim that run has produced", async (t) => {
@@ -321,9 +376,10 @@ test("a segment behind a run's own start does not claim that run has produced",
   // the number alone, and a run believed to be producing is one the look-ahead
   // may suspend and the seek path may wave through as "already covered".
   session.runs.clear();
-  const run = startRunOn(session, { from: 5, producing: false, usesExplicitCuts: true });
+  const run = startRunOn(session, { from: 5, producing: false, usesExplicitCuts: true, speedX: 2 });
 
   await manager.getFileStream(SESSION_ID, "segment-00000.mp4", { requestSeq: 1 });
 
-  assert.equal(run.state, ENCODE_RUN_STATE.STARTING);
+  assert.deepEqual(run.produced, [], "#0 is somebody else's work and says nothing about this run");
+  assert.equal(run.head, 5, "which is still where it began");
 });

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

@@ -1,19 +1,21 @@
 /**
- * @file A request issued before a seek must not steer the encoder.
+ * @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.
  *
- * The rule pinned here: a reported seek is the viewer STATING where they are; a
- * segment request is evidence about where the player is reading. Evidence may
- * refine a statement forward, never contradict it backwards.
+ * 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.
  *
- * Both cases go through `getFileStream`, the way production reaches the repair,
- * and the second is the control: without a reported seek the very same traffic
- * DOES move the encoder, which is what makes the first case a measurement of
- * the guard rather than of the weather.
+ * 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";
@@ -40,79 +42,48 @@ const SESSION_ID = "22222222-3333-4444-5555-666666666666";
  * @returns {Promise<{ manager: HlsSessionManager, session: object, dirPath: string }>}
  */
 async function sessionWithRunAt373() {
-  const dirPath = await mkdtemp(path.join(os.tmpdir(), "stale-seek-"));
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "stale-request-"));
   const manager = new HlsSessionManager({
     enabled: true,
     ffmpegBin: "ffmpeg",
     localBindHost: "127.0.0.1",
     localPort: 9090
   });
-  const boundaries = [];
-  for (let index = 0; index <= 600; index += 1) {
-    boundaries.push(index * SEGMENT_SECONDS);
-  }
   const session = {
     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: boundaries,
+      boundaries: Array.from({ length: 901 }, (_, index) => index * SEGMENT_SECONDS),
       cutGrid: "uniform"
     }),
     state: "ready",
     file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.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; },
+    segmentFormat: fmp4Format,
+    segmentCount: 900,
+    startedAt: Date.now(),
     createEntryMs: Date.now(),
     lastAccessedAt: Date.now(),
+    runs: new Set(),
     consumers: new Set(),
-    segmentFormat: fmp4Format,
+    viewers: new Map(),
+    progress: { processedSeconds: RUN_STARTS_AT * SEGMENT_SECONDS },
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
-    segmentCount: boundaries.length - 1,
-    runs: new Set(),
-    behindHeadAsks: new Map(),
-    firstWantedAt: new Map(),
-    holdExplainedAt: new Map(),
-    seekSettleTimer: null,
-    seekTarget: null,
-    failedStartAt: -1,
-    failedStartCount: 0,
-    waitEpoch: 0,
-    firstSegmentLogged: true,
-    progress: { processedSeconds: RUN_STARTS_AT * SEGMENT_SECONDS, speed: "1.0x", startPositionSeconds: RUN_STARTS_AT * SEGMENT_SECONDS }
+    lastError: "",
+    firstSegmentLogged: false,
+    waitEpoch: 0
   };
   manager.sessionsById.set(SESSION_ID, session);
-  // A live run: the repair refuses outright when nothing is encoding.
-  startRunOn(session, { from: RUN_STARTS_AT, usesExplicitCuts: true });
+  startRunOn(session, { from: RUN_STARTS_AT, usesExplicitCuts: true, speedX: 2 });
   return { manager, session, dirPath };
 }
 
 /**
- * The traffic that dragged the encoder back: the same index asked for twice,
- * first wanted long enough ago to pass the repair's patience guard.
- *
- * @param {object} session
- */
-function askedTwiceLongEnough(session) {
-  session.firstWantedAt.set(BEHIND_INDEX, Date.now() - 5_000);
-  session.behindHeadAsks.set(BEHIND_INDEX, { count: 3, at: Date.now() });
-}
-
-/**
- * Put the session down without going through disposal.
- *
- * Disposal signals the encoder and waits for it to die, which a stub cannot do
- * — and none of that is what these tests are about. Clearing the map and any
- * armed timer leaves nothing running.
- *
  * @param {HlsSessionManager} manager
  * @param {object} session
  * @param {string} dirPath
- * @returns {Promise<void>}
  */
 async function tidy(manager, session, dirPath) {
   if (session.seekSettleTimer) {
@@ -131,45 +102,48 @@ test("a request behind where the viewer said they are does not move the encoder"
   });
 
   // The viewer stated their position: 2083.4 s, which is segment #520 here.
-  manager.requestSeek(SESSION_ID, 2083.4);
-  askedTwiceLongEnough(session);
+  manager.requestSeek(SESSION_ID, 2083.4, "viewer-1");
 
-  const answer = await manager.getFileStream(
+  await manager.getFileStream(
     SESSION_ID,
     fmp4Format.segmentFileName(BEHIND_INDEX),
     { requestSeq: 1 }
   );
 
-  assert.equal(answer.kind, "warming-up", "the request is answered, not obeyed");
-  // The viewer's own seek legitimately armed a move to #519. What must NOT
-  // happen is the stale request replacing that with #370 — which is exactly
-  // what the field log shows: `seek settle → restart at segment #370`.
-  assert.notEqual(
-    session.seekTarget,
-    BEHIND_INDEX - 1,
+  // 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.seekTarget, 519, "the viewer's own seek is what the encoder is going to");
+  assert.equal(
+    session.seekSettleTimer ?? null,
+    null,
+    "and it must not arm a restart"
+  );
 });
 
-test("the same traffic DOES move the encoder when the viewer has said nothing", async (t) => {
+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);
   });
 
-  // No reported seek: a run placed wrongly is exactly what the repair is for,
-  // and this is the case it must keep serving.
-  askedTwiceLongEnough(session);
-
-  await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(BEHIND_INDEX), { requestSeq: 1 });
-
-  assert.equal(
-    session.seekTarget,
-    BEHIND_INDEX - 1,
-    "with nothing said by the viewer, a request stuck behind the head still repairs the run"
+  // 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.getFileStream(
+    SESSION_ID,
+    fmp4Format.segmentFileName(BEHIND_INDEX),
+    { requestSeq: 1 }
   );
-  assert.notEqual(session.seekSettleTimer, null);
+
+  assert.equal(session.seekTarget ?? null, null);
+  assert.equal(session.seekSettleTimer ?? null, null);
 });
 
 test("a request cannot move the viewer's position backwards", async (t) => {
@@ -178,12 +152,12 @@ test("a request cannot move the viewer's position backwards", async (t) => {
     await tidy(manager, session, dirPath);
   });
 
-  manager.requestSeek(SESSION_ID, 2083.4);
+  manager.requestSeek(SESSION_ID, 2083.4, "viewer-1");
   await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(BEHIND_INDEX), { requestSeq: 1 });
 
   assert.equal(
-    session.furthestViewerSeconds,
+    manager.viewers.get("viewer-1")?.positionSeconds(),
     2083.4,
-    "a stale request must not rewrite what the viewer reported — that is how the repair came to believe it"
+    "a stale request must not rewrite what the viewer said about themselves"
   );
 });