@torrent-tv/proxy 2.59.3 → 2.61.0

package/test/held-request-width.test.js

@@ -0,0 +1,148 @@
+/**
+ * @file How far ahead of the viewer a held segment request may sit.
+ *
+ * A request is released when the viewer has moved away from it. "Moved away"
+ * used to mean more than `MAX_LOOKAHEAD_SEGMENTS` — eight segments, which
+ * happened to match a browser holding thirty seconds and would refuse three
+ * quarters of the requests of one holding the whole cushion. The width is the
+ * encoder's own look-ahead now, which is the same figure the browser sizes its
+ * buffer from. Roadmap item 4, step 2.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+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 { fmp4Format } from "../services/segment-formats/fmp4.js";
+
+const SESSION_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+const SEGMENT_SECONDS = 4;
+
+/**
+ * @returns {Promise<{ manager: HlsSessionManager, dirPath: string }>}
+ */
+async function managerWithSession() {
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "held-request-"));
+  const manager = new HlsSessionManager({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  manager.sessionsById.set(SESSION_ID, {
+    id: SESSION_ID,
+    dirPath,
+    state: "ready",
+    segmentFormat: fmp4Format,
+    segmentBoundaries: Array.from({ length: 201 }, (_, index) => index * SEGMENT_SECONDS),
+    segmentCount: 200,
+    useSyntheticPlaylist: true,
+    // The viewer is at segment #25.
+    viewerPositionSeconds: 100
+  });
+  return { manager, dirPath };
+}
+
+/**
+ * @param {number} index
+ * @returns {string}
+ */
+function segment(index) {
+  return `segment-${String(index).padStart(5, "0")}.mp4`;
+}
+
+test("the width is the encoder's own look-ahead, in segments", async (t) => {
+  const { manager, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+
+  const width = Math.ceil(manager.lookaheadSeconds / manager.segmentDurationSec);
+  assert.equal(width, 30, "120 s of look-ahead over 4 s segments");
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(25 + width)), true, "the far edge");
+  assert.equal(
+    manager.requestStillWanted(SESSION_ID, segment(25 + width + 1)),
+    false,
+    "past everything the encoder is allowed to have produced"
+  );
+});
+
+test("a request the old eight-segment width would have refused is kept", async (t) => {
+  const { manager, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+
+  // #34 is nine segments ahead of the viewer — inside a 120 s cushion and
+  // outside the eight the width used to be. This is the request a browser
+  // holding the whole cushion makes constantly.
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(34)), true);
+});
+
+test("a segment behind the viewer is still released", async (t) => {
+  const { manager, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(24)), false);
+});
+
+test("a seek by one viewer does not release the request held for another", async (t) => {
+  const { manager, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  const session = manager.sessionsById.get(SESSION_ID);
+
+  // Both are watching the same copied picture, so both are this one session.
+  // One is at segment #25, the other far ahead at #150 — inside the fixture's
+  // own 200-segment timeline, since a position past the end of the grid is
+  // clamped to it and would prove nothing about the width.
+  manager.requestSeek(SESSION_ID, 100, "behind");
+  manager.requestSeek(SESSION_ID, 600, "ahead");
+
+  // The shared field now holds the leader's position, which is what the
+  // encoder is steered by and what every earlier release judged BOTH of them
+  // against.
+  assert.equal(session.viewerPositionSeconds, 600);
+
+  assert.equal(
+    manager.requestStillWanted(SESSION_ID, segment(26), "behind"),
+    true,
+    "the segment the viewer behind is waiting for is still theirs to wait for"
+  );
+  assert.equal(
+    manager.requestStillWanted(SESSION_ID, segment(26), "ahead"),
+    false,
+    "and for the one in front it is a place they have left"
+  );
+});
+
+test("a viewer's own head moves with their seek", async (t) => {
+  const { manager, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+
+  // Their last request was at #25; they jump to 600 s, which is #150. The
+  // segment at the target must be wanted — refusing it there is the freeze of
+  // 2026-08-18.
+  manager.requestSeek(SESSION_ID, 600, "viewer");
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(150), "viewer"), true);
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(25), "viewer"), false);
+});
+
+test("a viewer nobody can name is judged against the one shared position", async (t) => {
+  const { manager, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+
+  // A plain HTTP transport builds its own URLs and carries no id. The old
+  // behaviour is what remains, which for a single viewer is the same thing.
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(26), ""), true);
+  assert.equal(manager.requestStillWanted(SESSION_ID, segment(24), ""), false);
+});

package/test/quality-variants.test.js

@@ -59,6 +59,7 @@ function fakeSession({ id, encodeHeight, dirPath, transcodeVideo = true }) {
     seekSettleTimer: null,
     seekTarget: null,
     waitEpoch: 0,
+    netReports: new Map(),
     usesExplicitCuts: false,
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
@@ -660,7 +661,12 @@ test("a separately published audio track starts where the picture is, from the r
   // picture — so the viewer is at 100 s, and that, less a segment of margin,
   // is where the track has to begin.
   base.viewerPositionSeconds = 140;
-  base.netReport = { linkMbps: 20, bufferedAheadSec: 40, at: Date.now() };
+  base.netReports.set("viewer", {
+    linkMbps: 20,
+    bufferedAheadSec: 40,
+    positionSeconds: null,
+    at: Date.now()
+  });
   manager.getCachedAudioTracks = () => [
     { index: 0, language: "rus", title: "", isDefault: true },
     { index: 1, language: "eng", title: "", isDefault: false }
@@ -683,6 +689,87 @@ test("a separately published audio track starts where the picture is, from the r
   );
 });
 
+test("with two viewers the audio track starts at the EARLIEST picture, not the read head", async (t) => {
+  const { manager, base, dirPath } = await managerWithBase();
+  t.after(async () => {
+    await manager.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  base.audioSeparate = true;
+  // A copied picture is one session shared by both of them. The read head is
+  // the furthest request of EITHER, so it belongs to the viewer in front.
+  base.viewerPositionSeconds = 140;
+  base.netReports.set("ahead", {
+    linkMbps: 20,
+    bufferedAheadSec: 40,
+    positionSeconds: 100,
+    at: Date.now()
+  });
+  base.netReports.set("behind", {
+    linkMbps: 20,
+    bufferedAheadSec: 8,
+    positionSeconds: 40,
+    at: Date.now()
+  });
+  manager.getCachedAudioTracks = () => [
+    { index: 0, language: "rus", title: "", isDefault: true },
+    { index: 1, language: "eng", title: "", isDefault: false }
+  ];
+  const created = [];
+  manager.createOrGetSession = async (params) => {
+    created.push(params);
+    const rendition = fakeSession({ id: VARIANT_ID, encodeHeight: 0, dirPath });
+    rendition.audioOnly = true;
+    return { sessionId: VARIANT_ID, session: rendition };
+  };
+
+  await manager.resolveAudioRenditionFile(BASE_ID, 1, "segment-00010.mp4");
+
+  assert.equal(
+    created[0].startPositionSeconds,
+    36,
+    "the viewer at 40 s, less one segment of margin — a run starting at the leader " +
+      "has nothing to give the one behind them"
+  );
+});
+
+test("a position past the read head is clamped rather than acted on", async (t) => {
+  const { manager, base, dirPath } = await managerWithBase();
+  t.after(async () => {
+    await manager.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  base.audioSeparate = true;
+  base.viewerPositionSeconds = 140;
+  // Reports and requests race; a position claiming to be past everything that
+  // has been asked for would start the run where no request can reach it.
+  base.netReports.set("viewer", {
+    linkMbps: 20,
+    bufferedAheadSec: 40,
+    positionSeconds: 900,
+    at: Date.now()
+  });
+  manager.getCachedAudioTracks = () => [
+    { index: 0, language: "rus", title: "", isDefault: true },
+    { index: 1, language: "eng", title: "", isDefault: false }
+  ];
+  const created = [];
+  manager.createOrGetSession = async (params) => {
+    created.push(params);
+    const rendition = fakeSession({ id: VARIANT_ID, encodeHeight: 0, dirPath });
+    rendition.audioOnly = true;
+    return { sessionId: VARIANT_ID, session: rendition };
+  };
+
+  await manager.resolveAudioRenditionFile(BASE_ID, 1, "segment-00010.mp4");
+
+  assert.equal(
+    created[0].startPositionSeconds,
+    136,
+    "clamped to the read head, less one segment of margin"
+  );
+});
+
 test("a stale buffer report is not used to place an audio track", async (t) => {
   const { manager, base, dirPath } = await managerWithBase();
   t.after(async () => {
@@ -691,9 +778,14 @@ test("a stale buffer report is not used to place an audio track", async (t) => {
   });
   base.audioSeparate = true;
   base.viewerPositionSeconds = 300;
-  // Sent a minute ago: the viewer may have seeked anywhere since, so it says
-  // nothing about where they are now.
-  base.netReport = { linkMbps: 20, bufferedAheadSec: 5, at: Date.now() - 60_000 };
+  // Sent a minute ago: the viewer may have seeked anywhere since, so neither
+  // the buffer nor the position in it says where they are now.
+  base.netReports.set("viewer", {
+    linkMbps: 20,
+    bufferedAheadSec: 5,
+    positionSeconds: 250,
+    at: Date.now() - 60_000
+  });
   manager.getCachedAudioTracks = () => [
     { index: 0, language: "rus", title: "", isDefault: true },
     { index: 1, language: "eng", title: "", isDefault: false }

package/test/seek-target-not-superseded.test.js

@@ -104,3 +104,79 @@ test("a playlist belongs to no position and is never stale", async () => {
 
   await rm(dirPath, { recursive: true, force: true });
 });
+
+test("a request as deep as the cushion the browser is told to hold is still wanted", async () => {
+  const { manager, dirPath } = await managerAfterSeek();
+
+  // The browser sizes its forward buffer from the proxy's own look-ahead, so
+  // the deepest request it can make is one for the segment at the far edge of
+  // that cushion. Refusing it would be refusing the very depth this proxy
+  // asked for: at the old width — eight segments ahead of the viewer — three
+  // quarters of a full cushion's requests were stale by definition.
+  const edge = Math.floor((SEEK_TO_SECONDS + manager.lookaheadSeconds) / SEGMENT_SECONDS);
+
+  assert.ok(edge - SEGMENT_AT_SEEK > 8, "the case only exists past the old eight-segment width");
+  assert.equal(
+    manager.requestStillWanted(SESSION_ID, `segment-${String(edge).padStart(5, "0")}.mp4`),
+    true,
+    "the far edge of the cushion the proxy itself keeps produced"
+  );
+
+  await rm(dirPath, { recursive: true, force: true });
+});
+
+test("the viewer who made the request is the one it is judged against", async () => {
+  const { manager, dirPath } = await managerAfterSeek();
+  const session = manager.sessionsById.get(SESSION_ID);
+  session.consumerHeads = new Map();
+  // Two people watching one copied picture. The shared position belongs to the
+  // one in front — it is the furthest segment anybody asked for — and the one
+  // behind is a hundred segments back, waiting for a segment there.
+  const behind = SEGMENT_AT_SEEK - 100;
+  session.consumerHeads.set("behind", {
+    segment: behind,
+    seconds: behind * SEGMENT_SECONDS,
+    at: Date.now()
+  });
+
+  assert.equal(
+    manager.requestStillWanted(SESSION_ID, `segment-${String(behind).padStart(5, "0")}.mp4`, "behind"),
+    true,
+    "held for the viewer who is there, whatever the viewer in front is doing"
+  );
+  assert.equal(
+    manager.requestStillWanted(SESSION_ID, `segment-${String(behind).padStart(5, "0")}.mp4`),
+    false,
+    "unnamed, it can only be judged against the shared position — which is the leader's"
+  );
+
+  await rm(dirPath, { recursive: true, force: true });
+});
+
+test("a seek moves the seeking viewer's own head, and nobody else's", async () => {
+  const { manager, dirPath } = await managerAfterSeek();
+  const session = manager.sessionsById.get(SESSION_ID);
+  session.consumerHeads = new Map();
+  const staying = SEGMENT_AT_SEEK - 40;
+  session.consumerHeads.set("staying", {
+    segment: staying,
+    seconds: staying * SEGMENT_SECONDS,
+    at: Date.now()
+  });
+
+  const jumpTo = 120;
+  manager.requestSeek(SESSION_ID, jumpTo, "jumping");
+
+  assert.equal(
+    manager.requestStillWanted(SESSION_ID, `segment-${String(Math.floor(jumpTo / SEGMENT_SECONDS)).padStart(5, "0")}.mp4`, "jumping"),
+    true,
+    "the segment at the seek target — the request that raced the epoch in 2026-08-18"
+  );
+  assert.equal(
+    manager.requestStillWanted(SESSION_ID, `segment-${String(staying).padStart(5, "0")}.mp4`, "staying"),
+    true,
+    "somebody else's seek does not move where this viewer is"
+  );
+
+  await rm(dirPath, { recursive: true, force: true });
+});