@torrent-tv/proxy 2.89.5 → 2.89.7

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

@@ -1,89 +1,89 @@
-/**
- * @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");
-});
+/**
+ * @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 +1,64 @@
-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);
-});
+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);
+});