@torrent-tv/proxy 2.23.0 → 2.24.1

package/test/concurrent-cost.test.js

@@ -1,82 +1,138 @@
-/**
- * @file A rung is judged against the machine it will actually have.
- *
- * The field case of 2026-08-15, in arithmetic: a copy of the picture took about
- * 0.125 s of work per second of video (7.9-8.0x measured), a 240p rung needed
- * about 1.05, and the two together are more than the one second per second the
- * machine has. The budget priced the copy at nothing, offered the rung, and the
- * viewer watched it fail.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { canSustainOutput } from "../services/hwaccel.js";
-
-// A host that encodes 640x360 at 24 fps about eleven times over, and decodes
-// 1080p24 at 2.6x — the addon host's own figures.
-const BENCHMARK = [
-  { preset: "fast", pixelsPerSec: 17.0e6 },
-  { preset: "ultrafast", pixelsPerSec: 67.5e6 }
-];
-const DECODE_MODEL = { pixelTerm: 0.007742, bitrateTerm: 0, constantTerm: 0 };
-const SOURCE = { megapixelsPerSecond: (1920 * 1080 * 24) / 1e6, megabitsPerSecond: 8 };
-const RUNG_240P = 426 * 240 * 24;
-
-test("a rung is judged on the machine it will have, not on an empty one", () => {
-  const alone = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P
-  });
-  const beside = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P,
-    // The picture is being copied beside it, at the cost the field measured.
-    concurrentCostSec: 0.125
-  });
-  assert.ok(alone.speed !== null && beside.speed !== null);
-  assert.ok(beside.speed < alone.speed, "sharing the machine cannot make a rung faster");
-});
-
-test("nothing else running leaves the answer exactly as it was", () => {
-  const withZero = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P,
-    concurrentCostSec: 0
-  });
-  const without = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P
-  });
-  assert.equal(withZero.speed, without.speed);
-});
-
-test("a host with nothing measured still refuses nothing", () => {
-  const answer = canSustainOutput({
-    benchmark: [],
-    outputPixelsPerSec: RUNG_240P,
-    concurrentCostSec: 0.125
-  });
-  assert.equal(answer.sustainable, true);
-  assert.equal(answer.speed, null);
-});
-
-test("a cost heavy enough to fill the machine puts a rung below realtime", () => {
-  const answer = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P,
-    concurrentCostSec: 0.9
-  });
-  assert.ok(answer.speed !== null && answer.speed < 1, "0.9 of the machine spent elsewhere leaves less than realtime");
-  assert.equal(answer.sustainable, false);
-});
+/**
+ * @file A rung is judged against the machine it will actually have.
+ *
+ * The field case of 2026-08-15, in arithmetic: a copy of the picture took about
+ * 0.125 s of work per second of video (7.9-8.0x measured), a 240p rung needed
+ * about 1.05, and the two together are more than the one second per second the
+ * machine has. The budget priced the copy at nothing, offered the rung, and the
+ * viewer watched it fail.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { canSustainOutput } from "../services/hwaccel.js";
+
+// A host that encodes 640x360 at 24 fps about eleven times over, and decodes
+// 1080p24 at 2.6x — the addon host's own figures.
+const BENCHMARK = [
+  { preset: "fast", pixelsPerSec: 17.0e6 },
+  { preset: "ultrafast", pixelsPerSec: 67.5e6 }
+];
+const DECODE_MODEL = { pixelTerm: 0.007742, bitrateTerm: 0, constantTerm: 0 };
+const SOURCE = { megapixelsPerSecond: (1920 * 1080 * 24) / 1e6, megabitsPerSecond: 8 };
+const RUNG_240P = 426 * 240 * 24;
+
+test("a rung is judged on the machine it will have, not on an empty one", () => {
+  const alone = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P
+  });
+  const beside = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P,
+    // The picture is being copied beside it, at the cost the field measured.
+    concurrentCostSec: 0.125
+  });
+  assert.ok(alone.speed !== null && beside.speed !== null);
+  assert.ok(beside.speed < alone.speed, "sharing the machine cannot make a rung faster");
+});
+
+test("nothing else running leaves the answer exactly as it was", () => {
+  const withZero = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P,
+    concurrentCostSec: 0
+  });
+  const without = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P
+  });
+  assert.equal(withZero.speed, without.speed);
+});
+
+test("a host with nothing measured still refuses nothing", () => {
+  const answer = canSustainOutput({
+    benchmark: [],
+    outputPixelsPerSec: RUNG_240P,
+    concurrentCostSec: 0.125
+  });
+  assert.equal(answer.sustainable, true);
+  assert.equal(answer.speed, null);
+});
+
+test("a cost heavy enough to fill the machine puts a rung below realtime", () => {
+  const answer = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P,
+    concurrentCostSec: 0.9
+  });
+  assert.ok(answer.speed !== null && answer.speed < 1, "0.9 of the machine spent elsewhere leaves less than realtime");
+  assert.equal(answer.sustainable, false);
+});
+
+test("a soundtrack encoder is not free once it has been measured", () => {
+  // The second half of roadmap item 6. An audio rendition runs for as long as
+  // the picture does — it is a second encoder by construction, not an extra —
+  // and the budget counted it at nothing. Small beside a picture, and small is
+  // not zero: on a host where a rung needs almost the whole machine, this is
+  // the difference between offering it and refusing it.
+  const withoutAudio = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P,
+    concurrentCostSec: 0.125
+  });
+  const withAudio = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P,
+    // The copy, plus a soundtrack measured at about twenty times realtime.
+    concurrentCostSec: 0.125 + 0.05
+  });
+  assert.ok(
+    withAudio.speed < withoutAudio.speed,
+    "charging for the soundtrack must lower what the machine has left for the picture"
+  );
+});
+
+test("two pictures encoding at once are charged as two", () => {
+  // The warm-up that makes a quality switch seamless runs two encoders on
+  // purpose. Measured 2026-08-15: the new rung ran at 0.504x for its first four
+  // seconds, against 0.90-0.99x once it had the machine to itself and 1.58x
+  // predicted for an idle one. Priced as though it were alone, the budget
+  // describes a machine that does not exist at the moment the viewer switches.
+  const alone = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P,
+    concurrentCostSec: 0
+  });
+  const besideAnother = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P,
+    // Another rung of the same family, already running at about realtime.
+    concurrentCostSec: 1 / 1.05
+  });
+  assert.ok(alone.sustainable, "the rung must be offerable on an idle machine, or the case is not the one meant");
+  assert.equal(
+    besideAnother.sustainable,
+    false,
+    "a machine already spending a second per second of video has nothing left for a second picture"
+  );
+});

package/test/published-timeline.test.js

@@ -0,0 +1,83 @@
+/**
+ * @file A segment must be stamped where the playlist the player holds says.
+ *
+ * The field case this pins, 2026-08-17: a seek to 1590.4 s restarted the audio
+ * rendition at #291; the produced segments #292 and #293 carried their own
+ * positions, 1587.892 s and 1592.692 s, while the playlist the browser was
+ * holding said 1585.376 s and 1590.585 s. The browser fetched those two
+ * segments **1908 times each** over ten minutes, every one served in 4 ms, and
+ * the film never moved: a fragment appended more than `maxBufferHole` away from
+ * where the playlist put it is not recognised as buffered, so the player asks
+ * for it again.
+ *
+ * The rule, and the reason it is not simply "always use the file's own time":
+ * the boundary table keeps being corrected from produced segments, and the
+ * playlist does not. Whichever is right about the FILE, only one of them was
+ * sent to the player.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+/**
+ * hls.js's own default. A gap smaller than this is skipped; a larger one is a
+ * hole, and the fragment across it counts as not loaded.
+ */
+const PLAYER_BUFFER_HOLE_SEC = 0.5;
+
+/**
+ * The decision under test, in the shape the session manager applies it.
+ *
+ * @param {{ trueStart: number | null, publishedStart: number }} reading
+ * @returns {{ stamp: number, followedPlaylist: boolean }}
+ */
+function stampFor({ trueStart, publishedStart }) {
+  if (trueStart === null) {
+    return { stamp: publishedStart, followedPlaylist: true };
+  }
+  if (Math.abs(trueStart - publishedStart) > PLAYER_BUFFER_HOLE_SEC) {
+    return { stamp: publishedStart, followedPlaylist: true };
+  }
+  return { stamp: trueStart, followedPlaylist: false };
+}
+
+test("the field case: a segment far from its playlist position is stamped where the playlist says", () => {
+  const segment292 = stampFor({ trueStart: 1587.892, publishedStart: 1585.376 });
+  assert.equal(segment292.stamp, 1585.376);
+  assert.equal(segment292.followedPlaylist, true);
+
+  const segment293 = stampFor({ trueStart: 1592.692, publishedStart: 1590.585 });
+  assert.equal(segment293.stamp, 1590.585);
+});
+
+test("a file whose index is honest keeps its own position", () => {
+  // Within what a player bridges, the file's own figure is the truthful one and
+  // it is what keeps speech and subtitles together (2026-08-06, 4.17 s of drift
+  // when the picture was stamped from a lying index).
+  const reading = stampFor({ trueStart: 120.13, publishedStart: 120.0 });
+  assert.equal(reading.stamp, 120.13);
+  assert.equal(reading.followedPlaylist, false);
+});
+
+test("the boundary is exactly the player's own tolerance", () => {
+  assert.equal(stampFor({ trueStart: 10.5, publishedStart: 10.0 }).stamp, 10.5);
+  assert.equal(stampFor({ trueStart: 10.51, publishedStart: 10.0 }).stamp, 10.0);
+});
+
+test("a segment that does not say where it begins is stamped from the playlist", () => {
+  assert.equal(stampFor({ trueStart: null, publishedStart: 42.0 }).stamp, 42.0);
+});
+
+test("a corrected boundary does not move the stamp of a session already playing", () => {
+  // The correction writes into the live table; the published one is frozen. If
+  // the stamp followed the live table, every correction would move segments
+  // under a player holding the original playlist — which is the same failure
+  // seen from the other side.
+  const published = [0, 4, 8, 12];
+  const live = [...published];
+  live[2] = 9.7; // corrected from a produced segment
+  const publishedStart = published[2];
+  const reading = stampFor({ trueStart: live[2], publishedStart });
+  assert.equal(publishedStart, 8);
+  assert.equal(reading.stamp, 8, "the player was told 8 s and must be given 8 s");
+});

package/test/quality-variants.test.js

@@ -15,7 +15,7 @@ import assert from "node:assert/strict";
 import { mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { computeSegmentBoundaries, HlsSessionManager } from "../services/hls-session-manager.js";
+import { computeSegmentBoundaries, costKindForSession, HlsSessionManager } from "../services/hls-session-manager.js";
 import { fmp4Format } from "../services/segment-formats/fmp4.js";
 
 const BASE_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
@@ -736,3 +736,69 @@ test("an audio track is prepared at the position the switch will land on", async
     "and the track is pointed at the switch position, one back for the preceding keyframe"
   );
 });
+
+test("a reading from a soundtrack is priced as one", () => {
+  // The fault this pins: an audio rendition reached no learner at all. One
+  // guard refused renditions a reading, and the only call that would have
+  // priced one sat behind a second guard its caller had already made — so a
+  // soundtrack ran for the whole film and was charged at nothing, which is the
+  // half of roadmap item 6 that was left owing.
+  assert.equal(costKindForSession({ audioOnly: true, transcodeVideo: false }), "audio");
+  assert.equal(
+    costKindForSession({ audioOnly: true, transcodeVideo: true }),
+    "audio",
+    "a rendition carries no picture, whatever the flag it inherited says"
+  );
+  assert.equal(costKindForSession({ transcodeVideo: true }), "decode");
+  assert.equal(costKindForSession({ transcodeVideo: false }), "copy");
+});
+
+test("a quality step being warmed is not refused by its own cost", async (t) => {
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "warm-cost-"));
+  // The addon host's own figures, so the arithmetic below is the field's and
+  // not an invention. Without a benchmark the check returns every height
+  // untouched and a test over it would pass while proving nothing.
+  const manager = new HlsSessionManager({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090,
+    softwarePresetBenchmark: [
+      { preset: "fast", pixelsPerSec: 17.0e6 },
+      { preset: "ultrafast", pixelsPerSec: 67.5e6 }
+    ],
+    decodeCostModel: { pixelTerm: 0.007742, bitrateTerm: 0, constantTerm: 0 }
+  });
+  t.after(async () => {
+    await manager.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  // A copied 1080p picture, and a 240p step warmed beside it for a switch —
+  // which is what every quality change does, two encoders on purpose.
+  const base = fakeSession({ id: BASE_ID, encodeHeight: 0, dirPath, transcodeVideo: false });
+  base.variantHeight = 1080;
+  // What this source costs to decode — 1080p24 at 8 Mbit/s, the field file.
+  // Without it nothing can be priced and every height comes back offerable for
+  // want of a measurement, which would make the assertion hold for the wrong
+  // reason.
+  base.sourceDecode = { megapixelsPerSecond: (1920 * 1080 * 24) / 1e6, megabitsPerSecond: 8 };
+  const warming = fakeSession({ id: VARIANT_ID, encodeHeight: 240, dirPath });
+  warming.variantHeight = 240;
+  warming.sourceDecode = base.sourceDecode;
+  base.variants = new Map([[240, VARIANT_ID]]);
+  warming.variantBases = new Set([BASE_ID]);
+  // Running, and running well: it says of itself that it holds twice realtime,
+  // i.e. half a second of work per second of video.
+  warming.ffmpeg = fakeEncoder();
+  warming.lastAloneSpeed = 2;
+  manager.sessionsById.set(BASE_ID, base);
+  manager.sessionsById.set(VARIANT_ID, warming);
+
+  const offered = manager.offeredHeights(base);
+
+  assert.ok(
+    offered.includes(240),
+    "charged its own cost while being judged, the step the viewer just asked for is dropped from the " +
+      "offer by the act of warming it — and its next segment 404s on a stream that is playing"
+  );
+});

package/test/segment-serve-wiring.test.js

@@ -171,7 +171,7 @@ test("serving a segment records what its real start says about the container's i
 });
 
 test("a segment that exists is served, not reported as still being produced", async (t) => {
-  const { manager, dirPath } = await managerWithReadySegment();
+  const { manager, dirPath, session } = await managerWithReadySegment();
   t.after(async () => {
     await manager.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
@@ -189,12 +189,26 @@ test("a segment that exists is served, not reported as still being produced", as
   const served = Buffer.concat(chunks);
   assert.equal(served.toString("latin1", 4, 8), "moof", "the init header must be stripped off a media segment");
 
-  // The position the PIECE states, carried into the fragment it belongs to.
-  // Reading it is the step that threw in 2.9.124.
+  // Where the PLAYLIST the player holds puts this segment — which is what the
+  // fragment must be stamped with whenever the piece's own position is further
+  // away than a player will bridge. This fixture's piece says 12.5 s while the
+  // playlist says 0, and stamping the piece's figure is what killed a film on
+  // 2026-08-17: the browser asked for two segments 1908 times each over ten
+  // minutes, each served in 4 ms, because a fragment landing 2.5 s from where
+  // it was expected is not recognised as buffered. Reading the piece's own
+  // position still happens — it is the step that threw in 2.9.124, it feeds the
+  // index tally and it corrects the grid for rungs made later — it just no
+  // longer contradicts the timeline the player was sent. See
+  // test/published-timeline.test.js for the rule itself.
   assert.equal(
     Number(served.readBigUInt64BE(served.indexOf("tfdt") + 8)),
-    Math.round(SEGMENT_START_SECONDS * VIDEO_TIMESCALE),
-    "the segment must be stamped with where it really begins"
+    0,
+    "the segment must be stamped where the playlist the player holds says it begins"
+  );
+  assert.equal(
+    session.indexCheck.checked,
+    1,
+    "and the piece's own position must still have been read, or nothing measures the index"
   );
 });