@torrent-tv/proxy 2.80.19 → 2.81.0

package/test/orchestrator-wired.test.js

@@ -1,199 +1,199 @@
-/**
- * @file The plan is what decides the encoders, and it is asked of real sessions.
- *
- * Three rules written into the session manager become one here: where a run
- * belongs, when it has been overtaken, and how many the machine affords. The
- * point of wiring rather than duplicating is that the arithmetic has sixteen
- * checks of its own and no ffmpeg behind it.
- */
-
-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 { 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 { fmp4Format } from "../services/segment-formats/fmp4.js";
-import { viewerOf } from "../services/viewer/Viewer.js";
-import { startRunOn } from "./helpers/encode-run.js";
-
-const KEY = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
-
-function managerWithAnOutput() {
-  const root = mkdtempSync(path.join(os.tmpdir(), "orchestrator-wired-"));
-  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 };
-}
-
-function sessionOn({ id, dirPath, encodeStartIndex = 0, runEndIndex = -1, speed = 0, running = true }) {
-  const session = {
-    id,
-    outputKey: 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.
-    timeline: new Timeline({
-      boundaries: Array.from({ length: 1001 }, (_, index) => index * 4),
-      cutGrid: "uniform"
-    }),
-    state: "ready",
-    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" }).learn({ durationSeconds: 4000 }),
-    // 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: 1000,
-    recentSpeed: null,
-    consumers: new Set(),
-    viewers: new Map(),
-    runs: new Set(),
-    lastAccessedAt: Date.now()
-  };
-  if (running) {
-    const run = startRunOn(session, { from: encodeStartIndex, to: runEndIndex });
-    // A speed is a reading taken FROM a run, so it names the run it came from.
-    session.recentSpeed = speed > 0 ? { speed, at: Date.now(), run } : null;
-    run.noteSpeed(speed);
-  }
-  return session;
-}
-
-test("a session is handed to the plan as the run it is", (t) => {
-  const { manager, root, dirPath } = managerWithAnOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const session = sessionOn({ id: "one", dirPath, encodeStartIndex: 10, runEndIndex: 40 });
-  manager.sessionsById.set(session.id, session);
-  viewerOf(session, "watching").position = { segment: 12, seconds: 48, at: Date.now() };
-
-  manager.runQualityBudgetOnce;
-  manager.planEncodersNow();
-
-  const runs = manager.encodeOrchestrator.runsOn(KEY);
-  assert.equal(runs.length, 1, "the session the browser already has is a run like any other");
-  assert.equal(runs[0], [...session.runs][0], "and it is the run the session actually holds");
-  assert.equal(runs[0].from, 10);
-  assert.equal(runs[0].to, 40);
-});
-
-test("what a viewer waits for reaches the plan without their name", (t) => {
-  const { manager, root, dirPath } = managerWithAnOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const session = sessionOn({ id: "one", dirPath, encodeStartIndex: 0, runEndIndex: -1 });
-  manager.sessionsById.set(session.id, session);
-  viewerOf(session, "someone").position = { segment: 5, seconds: 20, at: Date.now() };
-
-  manager.planEncodersNow();
-
-  // THE MAP IS BANDS NOW, not one window per viewer: what a viewer is stopped
-  // on, then what is in front of them band by band, then the rest of the track.
-  // The check is the same question asked of that shape — where the most urgent
-  // band begins, and that there is film in front of it.
-  const wanted = manager.encodeOrchestrator.demand.mapOn(KEY);
-  const first = [...wanted].sort((left, right) => right.priority - left.priority)[0];
-  assert.equal(first.from, 5, "where they are");
-  assert.ok(wanted.some((zone) => zone.to > 5), "and the cushion in front of them");
-});
-
-test("a viewer nothing has been heard from at all stops being waited for", (t) => {
-  const { manager, root, dirPath } = managerWithAnOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const session = sessionOn({ id: "one", dirPath });
-  manager.sessionsById.set(session.id, session);
-  const gone = viewerOf(session, "gone");
-  gone.position = { segment: 5, seconds: 20, at: Date.now() - 10 * 60 * 1000 };
-  // What decides it is when they were last HEARD FROM, not when they last
-  // asked for a segment: a viewer holding a full cushion asks for nothing for
-  // as long as it takes to drain, and is no less present for it.
-  gone.seen(Date.now() - 10 * 60 * 1000);
-
-  manager.planEncodersNow();
-
-  assert.equal(manager.encodeOrchestrator.demand.mapOn(KEY).length, 0);
-});
-
-test("a viewer who has arrived and asked for nothing is waited for", (t) => {
-  const { manager, root, dirPath } = managerWithAnOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const session = sessionOn({ id: "one", dirPath });
-  manager.sessionsById.set(session.id, session);
-  // Nothing places them here on purpose: this is a viewer known to the output
-  // and nothing more, which is what a viewer IS between arriving and asking
-  // for their first file. Answered from the position alone, this viewer read
-  // as absent, and on 2026-09-05 that stopped a soundtrack's encoder 1.25 s
-  // after it started, with nothing produced.
-  const fresh = manager.viewers.of(session, "fresh");
-  assert.equal(fresh.position, null, "nobody has placed them");
-
-  manager.planEncodersNow();
-
-  const wanted = manager.encodeOrchestrator.demand.mapOn(KEY);
-  assert.ok(wanted.length > 0, "an output with a viewer on it is wanted");
-  const first = [...wanted].sort((left, right) => right.priority - left.priority)[0];
-  assert.equal(first.from, 0, "and the beginning is where an unplaced viewer is");
-});
-
-test("how many encoders the machine affords is measured, not chosen", (t) => {
-  const { manager, root, dirPath } = managerWithAnOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  // Nothing measured yet: one is what it has.
-  const cold = sessionOn({ id: "cold", dirPath });
-  manager.sessionsById.set(cold.id, cold);
-  assert.equal(manager.maxRunsForOutput(KEY), 1);
-
-  // Fast, but what a second job costs on THIS machine has not been measured,
-  // and an unmeasured penalty of 1 is not a statement that it is free.
-  cold.lastAloneSpeed = 7.12;
-  assert.equal(manager.maxRunsForOutput(KEY), 1, "no measurement, no second encoder");
-
-  // Measured on the addon host 2026-09-03: at 854x480 one run made 7.12x and
-  // two made 4.20x and 4.16x, a penalty of 1.70x, and both stayed far above
-  // realtime.
-  manager.contentionPenalties = new Map([[1, 1.7]]);
-  assert.ok(manager.maxRunsForOutput(KEY) > 1, "measured, and a second fits");
-
-  // The same host at 1920x1080: one made 1.96x, two made 0.99x and 0.98x.
-  manager.contentionPenalties = new Map([[1, 1.98]]);
-  cold.lastAloneSpeed = 1.96;
-  assert.equal(manager.maxRunsForOutput(KEY), 1, "the machine is full at one");
-});
-
-test("segments already made are known to the plan, whoever made them", (t) => {
-  const { manager, store, root, dirPath } = managerWithAnOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  for (const index of [0, 1, 2, 3]) {
-    writeFileSync(path.join(dirPath, fmp4Format.segmentFileName(index)), Buffer.alloc(16, 1));
-  }
-  const session = sessionOn({ id: "one", dirPath });
-  manager.sessionsById.set(session.id, session);
-
-  manager.planEncodersNow();
-
-  const coverage = manager.encodeOrchestrator.coverageOf(KEY);
-  assert.equal(coverage.isReady(0), true);
-  assert.equal(coverage.isReady(2), true);
-  // Including the highest. It used to be excluded for having no successor to
-  // prove it closed, which left the last piece of every run unprovable for ever
-  // — and proved a half-written one whenever the number above it was written by
-  // another run of the same output. A served name is the proof now.
-  assert.equal(coverage.isReady(3), true, "its name says it is closed");
-  void store;
-});
+/**
+ * @file The plan is what decides the encoders, and it is asked of real sessions.
+ *
+ * Three rules written into the session manager become one here: where a run
+ * belongs, when it has been overtaken, and how many the machine affords. The
+ * point of wiring rather than duplicating is that the arithmetic has sixteen
+ * checks of its own and no ffmpeg behind it.
+ */
+
+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 { 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 { fmp4Format } from "../services/segment-formats/fmp4.js";
+import { viewerOf } from "../services/viewer/Viewer.js";
+import { startRunOn } from "./helpers/encode-run.js";
+
+const KEY = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
+
+function managerWithAnOutput() {
+  const root = mkdtempSync(path.join(os.tmpdir(), "orchestrator-wired-"));
+  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 };
+}
+
+function sessionOn({ id, dirPath, encodeStartIndex = 0, runEndIndex = -1, speed = 0, running = true }) {
+  const session = {
+    id,
+    outputKey: 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.
+    timeline: new Timeline({
+      boundaries: Array.from({ length: 1001 }, (_, index) => index * 4),
+      cutGrid: "uniform"
+    }),
+    state: "ready",
+    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" }).learn({ durationSeconds: 4000 }),
+    // 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: 1000,
+    recentSpeed: null,
+    consumers: new Set(),
+    viewers: new Map(),
+    runs: new Set(),
+    lastAccessedAt: Date.now()
+  };
+  if (running) {
+    const run = startRunOn(session, { from: encodeStartIndex, to: runEndIndex });
+    // A speed is a reading taken FROM a run, so it names the run it came from.
+    session.recentSpeed = speed > 0 ? { speed, at: Date.now(), run } : null;
+    run.noteSpeed(speed);
+  }
+  return session;
+}
+
+test("a session is handed to the plan as the run it is", (t) => {
+  const { manager, root, dirPath } = managerWithAnOutput();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const session = sessionOn({ id: "one", dirPath, encodeStartIndex: 10, runEndIndex: 40 });
+  manager.sessionsById.set(session.id, session);
+  viewerOf(session, "watching").position = { segment: 12, seconds: 48, at: Date.now() };
+
+  manager.runQualityBudgetOnce;
+  manager.planEncodersNow();
+
+  const runs = manager.encodeOrchestrator.runsOn(KEY);
+  assert.equal(runs.length, 1, "the session the browser already has is a run like any other");
+  assert.equal(runs[0], [...session.runs][0], "and it is the run the session actually holds");
+  assert.equal(runs[0].from, 10);
+  assert.equal(runs[0].to, 40);
+});
+
+test("what a viewer waits for reaches the plan without their name", (t) => {
+  const { manager, root, dirPath } = managerWithAnOutput();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const session = sessionOn({ id: "one", dirPath, encodeStartIndex: 0, runEndIndex: -1 });
+  manager.sessionsById.set(session.id, session);
+  viewerOf(session, "someone").position = { segment: 5, seconds: 20, at: Date.now() };
+
+  manager.planEncodersNow();
+
+  // THE MAP IS BANDS NOW, not one window per viewer: what a viewer is stopped
+  // on, then what is in front of them band by band, then the rest of the track.
+  // The check is the same question asked of that shape — where the most urgent
+  // band begins, and that there is film in front of it.
+  const wanted = manager.encodeOrchestrator.demand.mapOn(KEY);
+  const first = [...wanted].sort((left, right) => right.priority - left.priority)[0];
+  assert.equal(first.from, 5, "where they are");
+  assert.ok(wanted.some((zone) => zone.to > 5), "and the cushion in front of them");
+});
+
+test("a viewer nothing has been heard from at all stops being waited for", (t) => {
+  const { manager, root, dirPath } = managerWithAnOutput();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const session = sessionOn({ id: "one", dirPath });
+  manager.sessionsById.set(session.id, session);
+  const gone = viewerOf(session, "gone");
+  gone.position = { segment: 5, seconds: 20, at: Date.now() - 10 * 60 * 1000 };
+  // What decides it is when they were last HEARD FROM, not when they last
+  // asked for a segment: a viewer holding a full cushion asks for nothing for
+  // as long as it takes to drain, and is no less present for it.
+  gone.seen(Date.now() - 10 * 60 * 1000);
+
+  manager.planEncodersNow();
+
+  assert.equal(manager.encodeOrchestrator.demand.mapOn(KEY).length, 0);
+});
+
+test("a viewer who has arrived and asked for nothing is waited for", (t) => {
+  const { manager, root, dirPath } = managerWithAnOutput();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const session = sessionOn({ id: "one", dirPath });
+  manager.sessionsById.set(session.id, session);
+  // Nothing places them here on purpose: this is a viewer known to the output
+  // and nothing more, which is what a viewer IS between arriving and asking
+  // for their first file. Answered from the position alone, this viewer read
+  // as absent, and on 2026-09-05 that stopped a soundtrack's encoder 1.25 s
+  // after it started, with nothing produced.
+  const fresh = manager.viewers.of(session, "fresh");
+  assert.equal(fresh.position, null, "nobody has placed them");
+
+  manager.planEncodersNow();
+
+  const wanted = manager.encodeOrchestrator.demand.mapOn(KEY);
+  assert.ok(wanted.length > 0, "an output with a viewer on it is wanted");
+  const first = [...wanted].sort((left, right) => right.priority - left.priority)[0];
+  assert.equal(first.from, 0, "and the beginning is where an unplaced viewer is");
+});
+
+test("how many encoders the machine affords is measured, not chosen", (t) => {
+  const { manager, root, dirPath } = managerWithAnOutput();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  // Nothing measured yet: one is what it has.
+  const cold = sessionOn({ id: "cold", dirPath });
+  manager.sessionsById.set(cold.id, cold);
+  assert.equal(manager.maxRunsForOutput(KEY), 1);
+
+  // Fast, but what a second job costs on THIS machine has not been measured,
+  // and an unmeasured penalty of 1 is not a statement that it is free.
+  cold.lastAloneSpeed = 7.12;
+  assert.equal(manager.maxRunsForOutput(KEY), 1, "no measurement, no second encoder");
+
+  // Measured on the addon host 2026-09-03: at 854x480 one run made 7.12x and
+  // two made 4.20x and 4.16x, a penalty of 1.70x, and both stayed far above
+  // realtime.
+  manager.contentionPenalties = new Map([[1, 1.7]]);
+  assert.ok(manager.maxRunsForOutput(KEY) > 1, "measured, and a second fits");
+
+  // The same host at 1920x1080: one made 1.96x, two made 0.99x and 0.98x.
+  manager.contentionPenalties = new Map([[1, 1.98]]);
+  cold.lastAloneSpeed = 1.96;
+  assert.equal(manager.maxRunsForOutput(KEY), 1, "the machine is full at one");
+});
+
+test("segments already made are known to the plan, whoever made them", (t) => {
+  const { manager, store, root, dirPath } = managerWithAnOutput();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  for (const index of [0, 1, 2, 3]) {
+    writeFileSync(path.join(dirPath, fmp4Format.segmentFileName(index)), Buffer.alloc(16, 1));
+  }
+  const session = sessionOn({ id: "one", dirPath });
+  manager.sessionsById.set(session.id, session);
+
+  manager.planEncodersNow();
+
+  const coverage = manager.encodeOrchestrator.coverageOf(KEY);
+  assert.equal(coverage.isReady(0), true);
+  assert.equal(coverage.isReady(2), true);
+  // Including the highest. It used to be excluded for having no successor to
+  // prove it closed, which left the last piece of every run unprovable for ever
+  // — and proved a half-written one whenever the number above it was written by
+  // another run of the same output. A served name is the proof now.
+  assert.equal(coverage.isReady(3), true, "its name says it is closed");
+  void store;
+});