@torrent-tv/proxy 2.89.17 → 2.89.19

package/test/run-inputs.test.js

@@ -1,80 +0,0 @@
-/**
- * @file What an encoder is told to read.
- *
- * The encoder's own read of its source is the one read that tracks where the
- * viewer is (`reader=playback`), and the only one sized in seconds of playback
- * (`windowBytes`). Both travel on the input address. When the address stopped
- * being kept on the session and started being built per run, both were left
- * off it: every encoder read looked to the stream route like a probe, and the
- * read window fell back to the reader's default.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { encoderInputs } from "../services/encode/run-inputs.js";
-
-const BASE = "http://127.0.0.1:9090";
-
-function file(fileIndex) {
-  return {
-    fileIndex,
-    streamUrl(baseUrl, { sessionId = "" } = {}) {
-      const url = new URL("/stream", `${baseUrl}/`);
-      url.searchParams.set("fileIndex", String(fileIndex));
-      if (sessionId) {
-        url.searchParams.set("session", sessionId);
-      }
-      return url;
-    }
-  };
-}
-
-test("the picture's read says it is the playback read, with its window", () => {
-  const picture = file(0);
-  const { inputUrl } = encoderInputs({
-    picture,
-    soundtrack: picture,
-    carries: "video-only",
-    audioSeparate: true,
-    sessionId: "aaaaaaaabbbbcccc",
-    readWindowBytes: 32_000_000,
-    baseUrl: BASE
-  });
-  const url = new URL(inputUrl);
-  assert.equal(url.searchParams.get("reader"), "playback");
-  assert.equal(url.searchParams.get("windowBytes"), "32000000");
-  assert.equal(url.searchParams.get("session"), "aaaaaaaabbbbcccc");
-});
-
-test("with no window measured the read states neither parameter", () => {
-  const picture = file(0);
-  const { inputUrl } = encoderInputs({
-    picture,
-    soundtrack: picture,
-    carries: "muxed",
-    audioSeparate: false,
-    sessionId: "aaaaaaaabbbbcccc",
-    readWindowBytes: 0,
-    baseUrl: BASE
-  });
-  const url = new URL(inputUrl);
-  assert.equal(url.searchParams.get("windowBytes"), null);
-  assert.equal(url.searchParams.get("reader"), null, "exactly as before: both are set together or neither");
-});
-
-test("a soundtrack in its own file is read directly by its rendition, and is a second input only when muxed", () => {
-  const picture = file(0);
-  const dub = file(3);
-  const rendition = encoderInputs({
-    picture, soundtrack: dub, carries: "audio-only", audioSeparate: true,
-    sessionId: "s", readWindowBytes: 1000, baseUrl: BASE
-  });
-  assert.equal(new URL(rendition.inputUrl).searchParams.get("fileIndex"), "3");
-  assert.equal(rendition.audioInputUrl, "");
-  const muxed = encoderInputs({
-    picture, soundtrack: dub, carries: "muxed", audioSeparate: false,
-    sessionId: "s", readWindowBytes: 1000, baseUrl: BASE
-  });
-  assert.equal(new URL(muxed.inputUrl).searchParams.get("fileIndex"), "0");
-  assert.equal(new URL(muxed.audioInputUrl).searchParams.get("fileIndex"), "3");
-});

package/test/run-intervals.test.js

@@ -1,100 +0,0 @@
-/**
- * @file How far a run may work, and who decides it.
- *
- * 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.
- *
- * 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 { CoverageMap } from "../services/encode/CoverageMap.js";
-
-/** 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", () => {
-  const coverage = new CoverageMap({ segmentCount: 100 });
-
-  assert.equal(coverage.freeRunFrom(0), 100, "the whole track is free");
-  assert.equal(coverage.firstGapFrom(0), 0);
-});
-
-test("a run stops before material that is already made", () => {
-  const coverage = new CoverageMap({ segmentCount: 100 });
-  coverage.setReady([10, 11, 12, 13, 14, 15, 16, 17, 18, 19]);
-
-  assert.equal(coverage.freeRunFrom(0), 10, "0..9, and it stops where 10 begins");
-});
-
-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);
-
-  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 run's own claim does not hold it back", () => {
-  const coverage = new CoverageMap({ segmentCount: 100 });
-  const mine = run("mine");
-  coverage.claim(mine, 40, 60);
-
-  assert.equal(
-    coverage.freeRunFrom(40, mine),
-    60,
-    "asked by the run that holds it, the stretch is its own to work through"
-  );
-});
-
-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);
-
-  assert.equal(coverage.freeRunFrom(0), 100, "what it did not finish is free again");
-});
-
-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.setReady([40, 41, 42]);
-  coverage.release(dead);
-
-  assert.equal(coverage.firstGapFrom(40), 43, "a closed file is closed whoever made it");
-});
-
-test("nothing left to make is answered with nothing", () => {
-  const coverage = new CoverageMap({ segmentCount: 5 });
-  coverage.setReady([0, 1, 2, 3, 4]);
-
-  assert.equal(coverage.firstGapFrom(0), null, "and a run started here would only repeat somebody's work");
-});
-
-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);
-
-  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");
-});

package/test/run-position-follows-published-grid.test.js

@@ -1,89 +0,0 @@
-/**
- * @file A run is POSITIONED where the player was told the segment begins.
- *
- * The companion of `cuts-follow-published-grid`, and the half that was missing.
- * 2.45.0 moved the cut list onto the published table and left the position on
- * the live one — but `-segment_times` are measured from wherever the run really
- * began, so any distance between the two moves EVERY cut of that run by it. The
- * live table keeps being corrected, and the corrections run backwards, so each
- * restart began a little earlier than the grid its cuts were stated on and the
- * distance accumulated across restarts.
- *
- * Field 2026-08-21, `JUFD665.mp4` (MP4, copy path, index read cleanly): after
- * one seek restart a produced segment held the boundary two places before its
- * own number — 16.684 s, which is 2.0000 segments — and after the next restart,
- * four places, 33.5 s. The player's buffer then stopped extending at all,
- * because every fragment's content landed before the time its playlist entry
- * named: `bufferEnd` stood still at 4571.1 s through four `frag-far` warnings
- * until hls.js gave up and jumped the viewer 16.8 s forward.
- */
-
-import assert from "node:assert/strict";
-import { Timeline } from "../services/encode/output/Timeline.js";
-import test from "node:test";
-
-import { wireOutputs } from "../services/server/wire-outputs.js";
-import { segmentCutTimesFrom } from "../services/encode/run-command.js";
-import { describeGridDrift } from "../services/encode/OutputTimes.js";
-
-/** What the playlist in the player's hands says. */
-const PUBLISHED = [0, 8.342, 16.684, 25.026, 33.368, 41.71];
-/** The same grid after produced segments moved two of its cuts backwards. */
-const CORRECTED = [0, 8.342, 14.682, 25.026, 31.366, 41.71];
-
-/**
- * @returns {{ manager: object, session: object }}
- */
-function sessionWithDriftedGrid() {
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  const session = {
-    id: "picture",
-    timeline: new Timeline({ boundaries: [...CORRECTED], published: [...PUBLISHED], cutGrid: "uniform" })
-  };
-  return { manager, session };
-}
-
-test("a run starts at the time the player was told, not at the corrected one", () => {
-  const { manager, session } = sessionWithDriftedGrid();
-  assert.equal(manager.outputTimes.runStartTimeFor(session, 2), 16.684);
-  assert.notEqual(manager.outputTimes.runStartTimeFor(session, 2), session.timeline.boundaries[2]);
-});
-
-test("position and cut list come from the same table", () => {
-  const { manager, session } = sessionWithDriftedGrid();
-  const grid = manager.outputTimes.publishedGridFor(session);
-  const start = manager.outputTimes.runStartTimeFor(session, 2);
-  // The cut list is stated as offsets from where the run begins. Adding the
-  // position back must land on the published boundaries exactly — which is the
-  // property that was false while the two came from different tables.
-  const absolute = segmentCutTimesFrom(grid, 2).map((offset) => Number((start + offset).toFixed(3)));
-  assert.deepEqual(absolute, [25.026, 33.368]);
-});
-
-test("a session that published no grid positions on the live one", () => {
-  const { manager } = sessionWithDriftedGrid();
-  const session = { id: "no-playlist", timeline: new Timeline({ boundaries: [...CORRECTED], published: [], cutGrid: "uniform" }) };
-  assert.equal(manager.outputTimes.runStartTimeFor(session, 2), CORRECTED[2]);
-});
-
-test("an index beyond the table is clamped rather than returning nothing", () => {
-  const { manager, session } = sessionWithDriftedGrid();
-  assert.equal(manager.outputTimes.runStartTimeFor(session, 9999), PUBLISHED[PUBLISHED.length - 1]);
-  assert.equal(manager.outputTimes.runStartTimeFor(session, -3), PUBLISHED[0]);
-});
-
-test("the drift between the two tables is stated in full", () => {
-  assert.equal(describeGridDrift(PUBLISHED, PUBLISHED), "identical");
-  assert.equal(
-    describeGridDrift(PUBLISHED, CORRECTED),
-    "2 of 6 boundaries apart, worst 2.002s at #2"
-  );
-  assert.equal(describeGridDrift(PUBLISHED, [0, 1]), "a different length (6 against 2)");
-  assert.equal(describeGridDrift(null, CORRECTED), "not comparable");
-  assert.equal(describeGridDrift([], []), "not comparable");
-});

package/test/run-progress.test.js

@@ -1,64 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { RunProgress } from "../services/encode/RunProgress.js";
-import { EncodeOrchestrator } from "../services/encode/EncodeOrchestrator.js";
-
-function orchestrator() {
-  return new EncodeOrchestrator({
-    maxRunsFor: () => 2,
-    makeRun: () => null,
-    segmentSeconds: 4,
-    logger: { info() {}, warn() {} }
-  });
-}
-
-test("a run rebases ffmpeg's relative clock onto its own source position", () => {
-  let now = 10;
-  const progress = new RunProgress({ startSeconds: 600, totalSeconds: 1000, now: () => now });
-  now = 20;
-  progress.note({ processedSeconds: 12.5 });
-
-  assert.deepEqual(progress.snapshot(), {
-    processedSeconds: 612.5,
-    startPositionSeconds: 600,
-    totalSeconds: 1000,
-    percent: 3.125,
-    remainingSeconds: 387.5,
-    updatedAt: 20
-  });
-});
-
-test("two runs of one output retain separate clocks", () => {
-  const made = orchestrator();
-  const first = { from: 0, to: 49, isAlive: true, progress: new RunProgress({ startSeconds: 0 }) };
-  const second = { from: 50, to: 99, isAlive: true, progress: new RunProgress({ startSeconds: 200 }) };
-  first.progress.note({ processedSeconds: 40 });
-  second.progress.note({ processedSeconds: 8, speed: "2.0x" });
-  made.adopt("picture", first);
-  made.adopt("picture", second);
-
-  assert.equal(made.progressOf("picture", 20).processedSeconds, 40);
-  assert.equal(made.progressOf("picture", 60).processedSeconds, 208);
-});
-
-test("the last run's progress remains available after it ends", () => {
-  const made = orchestrator();
-  const progress = new RunProgress({ startSeconds: 100 });
-  progress.note({ processedSeconds: 5, speed: "1.5x" });
-  const run = { from: 25, to: 30, isAlive: false, state: "ENDED_COMPLETE", progress };
-  made.adopt("picture", run);
-  made.noteEnded({
-    address: "picture",
-    run,
-    ending: "complete",
-    because: "the assigned stretch was completed",
-    from: 25,
-    to: 30,
-    reached: 30,
-    livedMs: 1000,
-    normal: true,
-    lastError: ""
-  });
-
-  assert.equal(made.progressOf("picture").processedSeconds, 105);
-});