@torrent-tv/proxy 2.77.0 → 2.79.0

package/test/run-intervals.test.js

@@ -1,336 +1,100 @@
 /**
- * @file A run is given a stretch nobody else holds, and stops at the end of it.
+ * @file How far a run may work, and who decides it.
  *
- * This is what removes the per-run directories. Runs used to be kept apart by a
- * directory each, because two of them writing one segment name at the same time
- * produce a file belonging to neither — which was also the only reason a restart
- * ever had to wait for its predecessor to die. Intervals remove that by
- * construction, so one flat directory per output is correct.
+ * These cases used to be asked of `planRunInterval`, a second authority inside
+ * the session manager that answered by its own rules: it walked the whole track
+ * for the first free number, MOVED the start there, and counted every live run
+ * as claiming up to `head + look-ahead`. It contradicted the plan directly, and
+ * the two together produced the field oscillation of 2026-09-05 — the plan
+ * commanded a start at #46, this moved it to #78, the plan killed the run for
+ * standing outside the window it had asked for, and the same start was
+ * commanded again, 350-700ms per cycle, no segment ever produced, the viewer's
+ * picture stopped for 125 seconds.
  *
- * The other half is the argument that states the end, and WHICH argument it is
- * belongs to the branch — measured, not reasoned:
- * `research/encoder-layer-2026-09-04.md` §11.
+ * It is gone. WHERE a run starts is the plan's decision and nothing moves it;
+ * HOW FAR it may work is a fact of the one coverage map, and that is what these
+ * cases now ask. The map is the same object the plan reads, so there is no
+ * second set of rules for the two to disagree about.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { SourceFile } from "../services/source/SourceFile.js";
-import { startRunOn } from "./helpers/encode-run.js";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { HlsSessionManager } from "../services/hls-session-manager.js";
-import { SegmentStore } from "../services/encode/SegmentStore.js";
-import { Timeline } from "../services/output/Timeline.js";
-import { fmp4Format } from "../services/segment-formats/fmp4.js";
-import { viewerOf } from "../services/viewer/Viewer.js";
+import { CoverageMap } from "../services/encode/CoverageMap.js";
 
-const KEY = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
-
-/**
- * @returns {{ manager: HlsSessionManager, store: SegmentStore, root: string, dirPath: string }}
- */
-function managerWithAnEmptyOutput() {
-  const root = mkdtempSync(path.join(os.tmpdir(), "run-intervals-"));
-  const store = new SegmentStore({ root });
-  const manager = new HlsSessionManager({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090,
-    segmentStore: store
-  });
-  const dirPath = store.directoryFor(KEY);
-  store.useFormat(KEY, fmp4Format);
-  return { manager, store, root, dirPath };
-}
-
-/**
- * @param {object} params
- * @returns {object}
- */
-function sessionOn({ id, dirPath, segmentCount = 100, runState = null, encodeStartIndex = 0, runEndIndex = -1 }) {
-  const session = {
-    id,
-    outputKey: KEY,
-    dirPath,
-    state: "ready",
-    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.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,
-    // How the file is cut, held by the TIMELINE. A fixture that stated it on the
-    // session was describing a shape the product had left, and it kept a defect
-    // alive for a release: `session.segmentCount` is undefined on every real
-    // session, so runs were given no end and the coverage map had no length.
-    timeline: new Timeline({
-      boundaries: Array.from({ length: segmentCount + 1 }, (_, index) => index * 4),
-      cutGrid: "uniform"
-    }),
-    runs: new Set(),
-    consumers: new Set(),
-    lastAccessedAt: Date.now()
-  };
-  if (runState !== null) {
-    const run = startRunOn(session, { from: encodeStartIndex, to: runEndIndex });
-    if (runState === "ENDED_FAILED") {
-      // A run that failed, said so, and left what it had made behind.
-      run.process?.exit(255, null);
-    }
-  }
-  return session;
-}
-
-/**
- * @param {string} dirPath
- * @param {number[]} indexes
- */
-function alreadyMade(dirPath, indexes) {
-  for (const index of indexes) {
-    writeFileSync(path.join(dirPath, fmp4Format.segmentFileName(index)), Buffer.alloc(16, 1));
-  }
+/** A stand-in for a run: the map identifies one by being it. */
+function run(name) {
+  return { name };
 }
 
-test("with nothing made, a run gets everything from where it was asked", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const session = sessionOn({ id: "s", dirPath });
-  // -1 for the end means "to the end of the film", which is what every run had
-  // before ends existed — and the only case where that is still right.
-  assert.deepEqual(manager.planRunInterval(session, 0), { from: 0, to: -1 });
-});
-
-test("a run stops before material that is already made", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  // 10..20 on the disk. Only 10..19 are PROVEN — the highest has no successor,
-  // so nothing shows whether it was closed or was being written when its run
-  // died.
-  alreadyMade(dirPath, [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]);
-  const session = sessionOn({ id: "s", dirPath });
-
-  assert.deepEqual(manager.planRunInterval(session, 0), { from: 0, to: 9 });
-});
-
-test("a run asked to start inside made material is moved forward to the gap", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  alreadyMade(dirPath, [10, 11, 12, 13, 14, 15]);
-  const session = sessionOn({ id: "s", dirPath });
-
-  // Asked for 11, which is made, and so is everything to 14. The first thing
-  // worth encoding is 15 — unproven, because 16 does not exist.
-  assert.deepEqual(manager.planRunInterval(session, 11), { from: 15, to: -1 });
-});
-
-test("a run stops before a stretch another live run was given", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const other = sessionOn({
-    id: "other",
-    dirPath,
-    runState: "PRODUCING",
-    encodeStartIndex: 40,
-    runEndIndex: 60
-  });
-  manager.sessionsById.set(other.id, other);
-  const session = sessionOn({ id: "s", dirPath });
+test("with nothing made, a run gets everything from where it was asked", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
 
-  // Two viewers of one film, one already encoding 40..60. The second run takes
-  // what is free in front of it and stops where the other one begins, so
-  // neither ever writes a name the other wants.
-  assert.deepEqual(manager.planRunInterval(session, 0), { from: 0, to: 39 });
-  assert.deepEqual(manager.planRunInterval(session, 45), { from: 61, to: -1 });
+  assert.equal(coverage.freeRunFrom(0), 100, "the whole track is free");
+  assert.equal(coverage.firstGapFrom(0), 0);
 });
 
-test("a run that has died holds nothing back", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  // The same stretch, but the process cannot be signalled — it has ended. What
-  // it did not finish is free again, without anything having to release it.
-  const dead = sessionOn({
-    id: "dead",
-    dirPath,
-    runState: "ENDED_FAILED",
-    encodeStartIndex: 40,
-    runEndIndex: 60
-  });
-  manager.sessionsById.set(dead.id, dead);
-  const session = sessionOn({ id: "s", dirPath });
+test("a run stops before material that is already made", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  coverage.markReadyAll([10, 11, 12, 13, 14, 15, 16, 17, 18, 19]);
 
-  assert.deepEqual(manager.planRunInterval(session, 0), { from: 0, to: -1 });
+  assert.equal(coverage.freeRunFrom(0), 10, "0..9, and it stops where 10 begins");
 });
 
-test("nothing left to make is answered with nothing, not with a run", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+test("a run stops before a stretch another live run was given", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  const other = run("other");
+  coverage.claim(other, 40, 60);
 
-  const session = sessionOn({ id: "s", dirPath, segmentCount: 5 });
-  alreadyMade(dirPath, [0, 1, 2, 3, 4]);
-  const other = sessionOn({
-    id: "other",
-    dirPath,
-    segmentCount: 5,
-    runState: "PRODUCING",
-    encodeStartIndex: 4,
-    runEndIndex: 4
-  });
-  manager.sessionsById.set(other.id, other);
-
-  // Starting an encoder here would only repeat somebody else's work, which is
-  // what three ffmpeg processes making one identical picture cost on a CM4.
-  assert.equal(manager.planRunInterval(session, 0), null);
+  assert.equal(coverage.freeRunFrom(0), 40, "0..39, and the other run's claim begins at 40");
+  assert.equal(coverage.firstGapFrom(45), 61, "the first thing nobody holds after it");
 });
 
-test("a session with no address keeps the old shape: start here, no end", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const session = sessionOn({ id: "s", dirPath });
-  session.outputKey = "";
-
-  assert.deepEqual(manager.planRunInterval(session, 7), { from: 7, to: -1 });
-});
-
-test("a run without an end does not claim the whole film away from a later viewer", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  // The first viewer's run, at the beginning, with no end — which is every run
-  // whose output was empty when it started.
-  const first = sessionOn({
-    id: "first",
-    dirPath,
-    segmentCount: 1000,
-    runState: "PRODUCING",
-    encodeStartIndex: 0,
-    runEndIndex: -1
-  });
-  manager.sessionsById.set(first.id, first);
-  const second = sessionOn({ id: "second", dirPath, segmentCount: 1000 });
-
-  // A second viewer opens the same film in the middle. Counting the first run's
-  // claim as the whole film would leave them with no encoder at all, waiting for
-  // it to encode its way there — an hour on a long film. It only claims as far
-  // as it will actually get, which is its head plus the look-ahead.
-  const planned = manager.planRunInterval(second, 500);
-  assert.notEqual(planned, null);
-  assert.equal(planned.from, 500);
-});
+test("a run's own claim does not hold it back", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  const mine = run("mine");
+  coverage.claim(mine, 40, 60);
 
-test("a run stops when it reaches a stretch another run was given", async (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const stopped = [];
-  const ahead = sessionOn({
-    id: "ahead",
-    dirPath,
-    runState: "PRODUCING",
-    encodeStartIndex: 500,
-    runEndIndex: 600
-  });
-  manager.sessionsById.set(ahead.id, ahead);
-  const behind = sessionOn({
-    id: "behind",
-    dirPath,
-    runState: "PRODUCING",
-    encodeStartIndex: 0,
-    runEndIndex: -1
-  });
-  manager.sessionsById.set(behind.id, behind);
-
-  // Its own end was set from the gaps of the moment it began, and the viewer who
-  // opened the film further on was not in that picture. Walking into their
-  // stretch means writing names they are writing.
-  const behindRun = [...behind.runs][0];
-  const aheadRun = [...ahead.runs][0];
-  assert.equal(manager.runMakingSegment(behind, 550, behindRun), aheadRun);
-  assert.equal(manager.runMakingSegment(behind, 499, behindRun), null);
   assert.equal(
-    manager.runMakingSegment(ahead, 550, aheadRun),
-    null,
-    "a run without an end owns only as far as it will get, not the rest of the film"
+    coverage.freeRunFrom(40, mine),
+    60,
+    "asked by the run that holds it, the stretch is its own to work through"
   );
-  void stopped;
 });
 
-test("a seek backwards does not drag the picture away from a viewer watching ahead", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const shared = sessionOn({
-    id: "shared",
-    dirPath,
-    segmentCount: 1000,
-    runState: "PRODUCING",
-    encodeStartIndex: 200,
-    runEndIndex: -1
-  });
-  shared.sourceKey = "torrent:abc";
-  shared.fileIndex = 0;
-  shared.timeline = new Timeline({ boundaries: Array.from({ length: 1001 }, (_, index) => index * 4), cutGrid: "uniform" });
-  shared.acquireSource = null;
-  shared.progress = { processedSeconds: 900, startPositionSeconds: 800 };
-  manager.sessionsById.set(shared.id, shared);
+test("a run that has ended holds nothing back", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  const dead = run("dead");
+  coverage.claim(dead, 40, 60);
+  coverage.release(dead);
 
-  // One viewer is at segment 250 and being served. The other jumps back an hour.
-  viewerOf(shared, "ahead").position = { segment: 250, seconds: 1000, at: Date.now() };
-  viewerOf(shared, "back").position = { segment: 250, seconds: 1000, at: Date.now() };
+  assert.equal(coverage.freeRunFrom(0), 100, "what it did not finish is free again");
+});
 
-  const servingAhead = [...shared.runs][0];
-  const startedAt = servingAhead.from;
-  manager.requestSeek("shared", 40, "back");
+test("what a dead run DID finish stays made", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  const dead = run("dead");
+  coverage.claim(dead, 40, 60);
+  coverage.markReadyAll([40, 41, 42]);
+  coverage.release(dead);
 
-  assert.equal(
-    servingAhead.from,
-    startedAt,
-    "the run serving the viewer in front is left exactly where it was"
-  );
-  assert.ok(shared.runs.has(servingAhead), "and it is not stopped");
-  // A run start claims its attempt before it awaits anything, so the assertion
-  // holds without the test needing an ffmpeg. 40 s is segment #10 on this grid.
-  assert.equal(
-    shared.pendingRun?.startIndex,
-    10,
-    "and the one who jumped is given a run of their own, there"
-  );
+  assert.equal(coverage.firstGapFrom(40), 43, "a closed file is closed whoever made it");
 });
 
-test("a seek backwards with nobody else watching still moves the run", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+test("nothing left to make is answered with nothing", () => {
+  const coverage = new CoverageMap({ segmentCount: 5 });
+  coverage.markReadyAll([0, 1, 2, 3, 4]);
 
-  let created = 0;
-  manager.createOrGetSession = async () => {
-    created += 1;
-    return null;
-  };
-
-  const alone = sessionOn({
-    id: "alone",
-    dirPath,
-    segmentCount: 1000,
-    runState: "PRODUCING",
-    encodeStartIndex: 200,
-    runEndIndex: -1
-  });
-  alone.timeline = new Timeline({ boundaries: Array.from({ length: 1001 }, (_, index) => index * 4), cutGrid: "uniform" });
-  alone.progress = { processedSeconds: 900, startPositionSeconds: 800 };
-  manager.sessionsById.set(alone.id, alone);
-  viewerOf(alone, "only").position = { segment: 250, seconds: 1000, at: Date.now() };
+  assert.equal(coverage.firstGapFrom(0), null, "and a run started here would only repeat somebody's work");
+});
 
-  manager.requestSeek("alone", 40, "only");
+test("a run without an end does not take the film away from a viewer further in", () => {
+  // The case that used to need a second authority's `head + look-ahead` guess.
+  // A run's claim is now the stretch the plan GAVE it, so a viewer opening the
+  // same film in the middle finds their own position free.
+  const coverage = new CoverageMap({ segmentCount: 1000 });
+  const first = run("first");
+  coverage.claim(first, 0, 499);
 
-  // Nobody is left behind, so a second run would be an encoder for one viewer
-  // who is not there any more.
-  assert.equal(created, 0);
-  assert.equal(alone.seekTarget !== undefined, true, "the run itself is repositioned, as before");
+  assert.equal(coverage.firstGapFrom(500), 500, "the second viewer's own position is free");
+  assert.equal(coverage.freeRunFrom(500), 500, "and everything from there to the end");
 });