@torrent-tv/proxy 2.80.9 → 2.80.11

package/test/viewer-outputs.test.js

@@ -82,7 +82,6 @@ function fakeSession({ id, dirPath, file, encodeHeight = 0, audioOnly = false, i
       applyTonemap: false
     }),
     encodeRunGeneration: 0,
-    lastRestartAt: 0,
     failedStartAt: -1,
     failedStartCount: 0,
     seekSettleTimer: null,
@@ -128,14 +127,7 @@ async function pictureWithStepAndSoundtrack() {
     manager.sessionsById.set(session.id, session);
   }
   file.stepHeights.set(540, 540);
-  /** @type {string[]} */
-  const released = [];
-  const realRelease = manager.encodeOrchestrator.release.bind(manager.encodeOrchestrator);
-  manager.encodeOrchestrator.release = (claimant) => {
-    released.push(claimant);
-    return realRelease(claimant);
-  };
-  return { manager, base, step, audio, dirPath, released };
+  return { manager, base, step, audio, dirPath };
 }
 
 test("a viewer who steps down, back to the picture's own height and down again keeps their record", async (t) => {
@@ -224,8 +216,8 @@ test("an output somebody else is still watching is kept when one viewer leaves",
   assert.equal(step.viewers.size, 0, "the step they had is watched by nobody");
 });
 
-test("leaving an output releases what the watching claimed of production", async (t) => {
-  const { manager, base, step, audio, dirPath, released } = await pictureWithStepAndSoundtrack();
+test("nothing is left wanting production once the last viewer has left", async (t) => {
+  const { manager, base, step, audio, dirPath } = await pictureWithStepAndSoundtrack();
   t.after(() => rm(dirPath, { recursive: true, force: true }));
   manager.viewers.of(base, VIEWER).position = { segment: 25, seconds: 100, at: Date.now() };
   manager.viewers.of(step, VIEWER);
@@ -233,10 +225,22 @@ test("leaving an output releases what the watching claimed of production", async
 
   await manager.releaseSessionConsumer(BASE_ID, VIEWER, "the viewer left");
 
+  // NOTHING HAS TO BE RELEASED, and that is the point of the shape. A claim per
+  // viewer per output used to be held in the encoding layer and taken back one
+  // by one when they left — the viewer's own name as the key of a claim, which
+  // is the coupling the layer rule forbids. What the plan is given now is a map
+  // with nobody's name in it, rebuilt from whoever is watching; a viewer who has
+  // left is simply not in the next one.
   for (const id of [BASE_ID, STEP_ID, AUDIO_ID]) {
-    assert.ok(
-      released.includes(`${id}:${VIEWER}`),
-      `the claim on ${id.slice(0, 8)} is released — the plan's own pass cannot do it once the viewer is out of the map`
+    const session = manager.sessionsById.get(id);
+    assert.equal(session, undefined, `${id.slice(0, 8)} is let go with its last viewer`);
+  }
+  manager.planEncodersNow();
+  for (const address of [base.outputKey, step.outputKey, audio.outputKey]) {
+    assert.deepEqual(
+      manager.encodeOrchestrator.demand.mapOn(address),
+      [],
+      "and no output is left asking for an encoder"
     );
   }
 });

package/test/behind-head-repair.test.js

@@ -1,261 +0,0 @@
-/**
- * @file A segment request below the running encode must not be held for ever.
- *
- * The encoder only moves forward from where its run began, so a request BELOW
- * that point cannot be answered by anything the run does. Every other far
- * request is a claim the running encode may yet reach; this one is a hole.
- *
- * Measured 2026-08-11: a quality switch placed a run at segment #770 while the
- * player needed #757, and the request was held for two minutes forty-one while
- * the encoder produced 409 s of video nobody had asked for at 2.48x. The
- * placement that caused it is fixed; this is the guard that stops the SHAPE
- * from hanging a session again, whatever puts it there.
- */
-
-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 } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { HlsSessionManager } from "../services/hls-session-manager.js";
-import { startRunOn } from "./helpers/encode-run.js";
-import { fmp4Format } from "../services/segment-formats/fmp4.js";
-
-const SESSION_ID = "bbbbbbbb-cccc-dddd-eeee-ffffffffffff";
-const SEGMENT_SECONDS = 4;
-const RUN_STARTS_AT = 770;
-const WANTED = 757;
-
-/**
- * A session whose run began well past the segment being asked for.
- *
- * @returns {Promise<{ manager: HlsSessionManager, session: object, dirPath: string, restarts: number[] }>}
- */
-async function managerWithRunAhead() {
-  const dirPath = await mkdtemp(path.join(os.tmpdir(), "behind-head-"));
-  const manager = new HlsSessionManager({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  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: Array.from({ length: 1937 }, (_, index) => index * SEGMENT_SECONDS),
-      cutGrid: "uniform"
-    }),
-    state: "ready",
-    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.avi" }),
-    // 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(),
-    lastError: "",
-    consumers: new Set(),
-    segmentFormat: fmp4Format,
-    transcodeVideo: true,
-    useSyntheticPlaylist: true,
-    playlistText: "#EXTM3U\n",
-    lastRestartAt: 0,
-    failedStartAt: -1,
-    failedStartCount: 0,
-    seekSettleTimer: null,
-    seekTarget: null,
-    waitEpoch: 0,
-    firstWantedAt: new Map(),
-    runs: new Set(),
-    progress: { state: "running", processedSeconds: RUN_STARTS_AT * SEGMENT_SECONDS + 400, startPositionSeconds: RUN_STARTS_AT * SEGMENT_SECONDS }
-  };
-  manager.sessionsById.set(SESSION_ID, session);
-  startRunOn(session, { from: RUN_STARTS_AT });
-  const restarts = [];
-  return { manager, session, dirPath, restarts };
-}
-
-test("a request behind the run is repaired once the player asks again", async (t) => {
-  const { manager, session, dirPath } = await managerWithRunAhead();
-  t.after(async () => {
-    await manager.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  // Asked for a moment ago and still unanswerable. What decides is that the
-  // player comes BACK for the same segment: it is the only one it wants, and no
-  // amount of waiting could say that as clearly.
-  session.firstWantedAt.set(WANTED, Date.now() - 1000);
-  const name = fmp4Format.segmentFileName(WANTED);
-
-  await manager.getFileStream(SESSION_ID, name, { requestSeq: 1 });
-
-  assert.equal(session.seekTarget, null, "one poll is not yet evidence");
-
-  await manager.getFileStream(SESSION_ID, name, { requestSeq: 2 });
-
-  assert.equal(
-    session.seekTarget,
-    WANTED - 1,
-    "the encoder must be moved back to it — one segment early, for the preceding keyframe"
-  );
-});
-
-test("a burst of different segments behind the run is a scan, and moves nothing", async (t) => {
-  const { manager, session, dirPath } = await managerWithRunAhead();
-  t.after(async () => {
-    await manager.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  // What hls.js does on a seek: dozens of indices within half a second, each
-  // abandoned. Field log 2026-08-02: #178, #681, #725, #807, #74, #245, #387.
-  const scanned = [WANTED, WANTED - 40, WANTED - 120, WANTED - 200, WANTED - 300];
-  for (const index of scanned) {
-    session.firstWantedAt.set(index, Date.now() - 1000);
-  }
-  // Asked ONCE each, which is what a scan is: the player opens them together
-  // and abandons them together. Field log 2026-08-02 — #178, #681, #725, #807,
-  // #74, #245, #387 within half a second, none of them repeated.
-  for (const index of scanned) {
-    await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(index), { requestSeq: 1 });
-  }
-
-  assert.equal(
-    session.seekTarget,
-    null,
-    "moving the encoder to one of these would be moving it to a number the player picked at random"
-  );
-});
-
-test("a request behind the run is left alone at first", async (t) => {
-  const { manager, session, dirPath } = await managerWithRunAhead();
-  t.after(async () => {
-    await manager.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(WANTED), { requestSeq: 1 });
-
-  assert.equal(
-    session.seekTarget,
-    null,
-    "a burst around a reported seek settles by itself, and the seek is what should move the encoder"
-  );
-});
-
-test("a seek already settling is not overridden", async (t) => {
-  const { manager, session, dirPath } = await managerWithRunAhead();
-  t.after(async () => {
-    await manager.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  session.firstWantedAt.set(WANTED, Date.now() - 4000);
-  // The viewer has stated where they are and it is about to be acted on.
-  session.seekTarget = 1200;
-  session.seekSettleTimer = setTimeout(() => {}, 60_000);
-  t.after(() => clearTimeout(session.seekSettleTimer));
-
-  await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(WANTED), { requestSeq: 1 });
-
-  assert.equal(
-    session.seekTarget,
-    1200,
-    "a statement from the viewer outranks anything inferred from what the player is fetching"
-  );
-});
-
-test("a playlist scan far below the run is left where it belongs", async (t) => {
-  const { manager, session, dirPath } = await managerWithRunAhead();
-  t.after(async () => {
-    await manager.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  // A player that cannot get what it wants scans the playlist: field log
-  // 2026-08-02, probes at #178, #681, #725, #807, #74, #245, #387 within half a
-  // second. Steering on the lowest of those put the encoder at the start of the
-  // film and left the viewer's own requests unreachable ahead of it — the exact
-  // reason request-steering was removed from this proxy.
-  const probe = 74;
-  session.firstWantedAt.set(probe, Date.now() - 30_000);
-
-  await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(probe), { requestSeq: 1 });
-
-  assert.equal(
-    session.seekTarget,
-    null,
-    "a misplaced run is out by a buffer; a scan probe is out by anything, and the two must not be confused"
-  );
-});
-
-test("a rung whose encoder was stopped is not brought back by a held request", async (t) => {
-  const { manager, session, dirPath } = await managerWithRunAhead();
-  t.after(async () => {
-    await manager.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  // What a quality switch leaves behind: the rung nobody is watching, parked.
-  session.runs = new Set();
-  session.firstWantedAt.set(WANTED, Date.now() - 4000);
-
-  await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(WANTED), { requestSeq: 1 });
-
-  assert.equal(
-    session.seekTarget,
-    null,
-    "restarting it would put a second encoder on a host sized for one, for a rung nobody is watching"
-  );
-});
-
-test("a request ahead of the run is not touched", async (t) => {
-  const { manager, session, dirPath } = await managerWithRunAhead();
-  t.after(async () => {
-    await manager.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  const ahead = RUN_STARTS_AT + 400;
-  session.firstWantedAt.set(ahead, Date.now() - 30_000);
-
-  await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(ahead), { requestSeq: 1 });
-
-  assert.equal(
-    session.seekTarget,
-    null,
-    "the running encode may yet reach it; restarting on a far request is what produced nine restarts in a minute"
-  );
-});
-
-test("a request far beyond the repair's reach is answered at once, not held", async (t) => {
-  const { manager, session, dirPath } = await managerWithRunAhead();
-  t.after(async () => {
-    await manager.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  // What a track change does: hls.js asks the new stream for segment #0 while
-  // the run is hundreds of segments in. The repair cannot reach it, no seek is
-  // coming, and the run only moves forward — so it can never be produced.
-  // Measured 2026-08-15: held for the full minute, and the viewer watched a
-  // spinner for 63 s after a track that had been made ready in 7.
-  const answer = await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(0), { requestSeq: 1 });
-
-  assert.equal(answer.kind, "not-found", "answered, so the player can move on to what it can have");
-  assert.equal(session.seekTarget, null, "and the encoder was not sent to the start of the film for it");
-});
-
-test("a request just behind the run is still held, because the repair will fetch it", async (t) => {
-  const { manager, session, dirPath } = await managerWithRunAhead();
-  t.after(async () => {
-    await manager.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  const name = fmp4Format.segmentFileName(WANTED);
-  session.firstWantedAt.set(WANTED, Date.now() - 1000);
-
-  const answer = await manager.getFileStream(SESSION_ID, name, { requestSeq: 1 });
-
-  assert.equal(answer.kind, "warming-up", "within reach: the encoder is about to be moved there");
-});

package/test/decode-measurement.test.js

@@ -1,83 +0,0 @@
-/**
- * @file What the decode measurement must never get wrong.
- *
- * The quality menu is predicted from these readings, so a reading that is
- * merely PRECISE is worth nothing — it has to be ordered the way decoding is.
- * Under `-stream_loop -1` it was not: the loop restart costs 0.03 s on a 480p
- * clip and 0.12 s on a 1080p one (the decoder tearing down and re-allocating
- * its frame buffers), a five-second clip at 55x restarts eleven times a second,
- * and the resulting bias depends on the clip's own resolution and on how fast
- * the host is. On a fast desktop, 2026-08-20, that made 1080p read cheaper than
- * 720p — which is not a thing a decoder does, and the fit refused to solve.
- *
- * These tests state the orderings instead of the numbers: the numbers are
- * properties of whatever machine runs them.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import ffmpegStatic from "ffmpeg-static";
-import { measureDecodeSlope } from "../services/hwaccel.js";
-
-const CLIPS = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "assets", "calibration");
-const clip = (name) => path.join(CLIPS, name);
-
-test("a bigger picture costs more than a smaller one of the same bitrate", async () => {
-  const big = await measureDecodeSlope(ffmpegStatic, clip("cal-h264-1080-hi.mp4"));
-  const small = await measureDecodeSlope(ffmpegStatic, clip("cal-h264-480-hi.mp4"));
-
-  assert.ok(big, "the 1080p clip was measured");
-  assert.ok(small, "the 480p clip was measured");
-  assert.ok(
-    small.speed > big.speed,
-    `480p decoded at ${small.speed.toFixed(1)}x and 1080p at ${big.speed.toFixed(1)}x — ` +
-      `an ordering no decoder produces, which is what the loop used to invert`
-  );
-});
-
-test("a thicker stream costs more than a thin one of the same size", async () => {
-  const thick = await measureDecodeSlope(ffmpegStatic, clip("cal-h264-480-hi.mp4"));
-  const thin = await measureDecodeSlope(ffmpegStatic, clip("cal-h264-480-lo.mp4"));
-
-  assert.ok(thick && thin);
-  assert.ok(
-    thin.speed > thick.speed,
-    `the same picture at ${thin.megabitsPerSecond.toFixed(2)} Mbit/s decoded at ${thin.speed.toFixed(1)}x ` +
-      `and at ${thick.megabitsPerSecond.toFixed(2)} Mbit/s at ${thick.speed.toFixed(1)}x`
-  );
-});
-
-test("HEVC costs more than H.264 for the same picture on the same machine", async () => {
-  const h264 = await measureDecodeSlope(ffmpegStatic, clip("cal-h264-480-lo.mp4"), "h264");
-  const hevc = await measureDecodeSlope(ffmpegStatic, clip("cal-hevc-480-lo.mp4"), "hevc");
-
-  assert.ok(h264 && hevc, "both families are lifted out of their containers correctly");
-  assert.ok(
-    h264.speed > hevc.speed,
-    `H.264 ${h264.speed.toFixed(1)}x against HEVC ${hevc.speed.toFixed(1)}x — the reason the model ` +
-      `is fitted per codec family at all`
-  );
-});
-
-test("the clip's own characteristics come back with the reading", async () => {
-  const measured = await measureDecodeSlope(ffmpegStatic, clip("cal-h264-1080-hi.mp4"));
-
-  assert.ok(measured);
-  // Read from the container rather than declared anywhere, so replacing a clip
-  // cannot silently invalidate the fit that rests on it.
-  assert.ok(measured.megapixelsPerSecond > 40 && measured.megapixelsPerSecond < 60);
-  assert.ok(measured.megabitsPerSecond > 5 && measured.megabitsPerSecond < 15);
-  assert.ok(measured.windowSec >= 0.5, "the slope is taken over a window wide enough to divide by");
-});
-
-test("a reading carries what the pipe was actually fed, for item 4(d2)'s sanity check", async () => {
-  const measured = await measureDecodeSlope(ffmpegStatic, clip("cal-h264-480-lo.mp4"));
-
-  assert.ok(measured);
-  assert.ok(
-    measured.pipeThroughputMBps > 0,
-    "the write path pushed a nonzero amount of the clip through, or nothing was measured at all"
-  );
-});