@torrent-tv/proxy 2.83.8 → 2.84.0

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

@@ -42,7 +42,7 @@ async function managerAfterSeek() {
     localBindHost: "127.0.0.1",
     localPort: 9090
   });
-  manager.sessionsById.set(SESSION_ID, {
+  const session = {
     id: SESSION_ID,
     dirPath,
     // Where this file is cut, held by the file. A fixture that stated it
@@ -66,9 +66,11 @@ async function managerAfterSeek() {
     segmentCount: 399,
     encodeStartIndex: SEGMENT_AT_SEEK,
     waitEpoch: 1,
-    furthestViewerSeconds: SEEK_TO_SECONDS,
     runState: "PRODUCING"
-  });
+  };
+  manager.sessionsById.set(SESSION_ID, session);
+  viewerOf(session, "").moveTo(SEEK_TO_SECONDS);
+  viewerOf(session, "").playing = false;
   return { manager, dirPath };
 }
 
@@ -141,15 +143,15 @@ 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.viewers = 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.
+  // Two people watching one copied picture: one at the seek target, one a
+  // hundred segments back and waiting for a segment there. Asked about nobody
+  // in particular the answer is the FURTHEST of them, because what lies behind
+  // that one has already been made.
   const behind = SEGMENT_AT_SEEK - 100;
-  viewerOf(session, "behind").position = {
-    segment: behind,
-    seconds: behind * SEGMENT_SECONDS,
-    at: Date.now()
-  };
+  viewerOf(session, "behind").moveTo(behind * SEGMENT_SECONDS);
+  viewerOf(session, "behind").playing = false;
+  viewerOf(session, "ahead").moveTo(SEEK_TO_SECONDS);
+  viewerOf(session, "ahead").playing = false;
 
   assert.equal(
     manager.requestStillWanted(SESSION_ID, `segment-${String(behind).padStart(5, "0")}.mp4`, "behind"),
@@ -159,7 +161,7 @@ test("the viewer who made the request is the one it is judged against", async ()
   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"
+    "unnamed, it is judged against the furthest viewer, which is the leader"
   );
 
   await rm(dirPath, { recursive: true, force: true });

package/test/stale-request-after-seek.test.js

@@ -155,9 +155,8 @@ test("a request cannot move the viewer's position backwards", async (t) => {
   manager.requestSeek(SESSION_ID, 2083.4, "viewer-1");
   await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(BEHIND_INDEX), { requestSeq: 1 });
 
-  assert.equal(
-    manager.viewers.get("viewer-1")?.positionSeconds(),
-    2083.4,
+  assert.ok(
+    Math.abs((manager.viewers.get("viewer-1")?.positionSeconds() ?? -1) - 2083.4) < 1,
     "a stale request must not rewrite what the viewer said about themselves"
   );
 });

package/test/viewer.test.js

@@ -1,108 +1,115 @@
-/**
- * @file One object per person watching, and one deletion to forget them.
- *
- * It was six maps hung on the session, each keyed by consumer id, and the
- * forgetting was already wrong: releasing a consumer emptied none of them, so a
- * viewer who had left went on counting as wanting their soundtrack until their
- * head expired, and their entries stayed for the life of the session.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { SourceFile } from "../services/source/SourceFile.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 { Viewer, viewerOf, viewersOf } from "../services/viewer/Viewer.js";
-
-const SESSION_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
-
-test("presence and position are two facts, and presence does not wait for a request", () => {
-  const now = 1_000_000;
-  const viewer = new Viewer("someone", now);
-
-  // The whole of the 2026-09-05 failure in one assertion: a viewer who has
-  // arrived and asked for nothing yet IS watching. Answered from the position
-  // alone — which is written only when a segment is requested — this read
-  // false, every encoder on their output was stopped for having nobody, and
-  // the `init.mp4` they needed in order to request their first segment was
-  // therefore never made.
-  assert.equal(viewer.position, null, "nothing has placed them yet");
-  assert.equal(viewer.isPresent(now, 60_000), true, "and they are still here");
-
-  viewer.seen(now - 10_000);
-  assert.equal(viewer.isPresent(now, 60_000), true);
-
-  // Silence longer than any a watching viewer can produce. This is a backstop
-  // for a connection that failed to say so, not the ordinary way of leaving.
-  viewer.seen(now - 120_000);
-  assert.equal(viewer.isPresent(now, 60_000), false);
-
-  // Something SAID they are gone. Then it does not matter how recently they
-  // were heard from.
-  viewer.seen(now);
-  viewer.gone = true;
-  assert.equal(viewer.isPresent(now, 60_000), false, "a statement outranks silence");
-});
-
-test("a stated position outranks the segment they last asked for", () => {
-  const viewer = new Viewer("someone");
-  assert.equal(viewer.positionSeconds(), null);
-
-  viewer.position = { segment: 10, seconds: 40, at: 1 };
-  assert.equal(viewer.positionSeconds(), 40, "where their player is reading");
-
-  viewer.position = { segment: 10, seconds: 40, at: 1, seeked: 900 };
-  assert.equal(viewer.positionSeconds(), 900, "a seek is the viewer saying where they are");
-});
-
-test("asking for a viewer twice is the same viewer", () => {
-  const session = {};
-  const first = viewerOf(session, "one");
-  first.audio = { trackIndex: 3, transcode: false };
-
-  assert.equal(viewerOf(session, "one"), first);
-  assert.equal(viewerOf(session, "one").audio.trackIndex, 3);
-  assert.notEqual(viewerOf(session, "two"), first);
-  assert.equal(viewersOf(session).size, 2);
-});
-
-test("releasing a consumer forgets everything that was true of them alone", async (t) => {
-  const dirPath = await mkdtemp(path.join(os.tmpdir(), "viewer-"));
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  const manager = new HlsSessionManager({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  const session = {
-    id: SESSION_ID,
-    dirPath,
-    state: "live",
-    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" }),
-    // 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; },
-    consumers: new Set(["staying", "leaving"]),
-    viewers: new Map(),
-    lastAccessedAt: Date.now()
-  };
-  manager.sessionsById.set(SESSION_ID, session);
-
-  const leaving = viewerOf(session, "leaving");
-  leaving.audio = { trackIndex: 2, transcode: true };
-  leaving.activeVariantId = "some-variant";
-  leaving.position = { segment: 40, seconds: 160, at: Date.now() };
-  viewerOf(session, "staying").audio = { trackIndex: 0, transcode: false };
-
-  await manager.releaseSessionConsumer(SESSION_ID, "leaving", "the tab was closed");
-
-  assert.equal(session.viewers.has("leaving"), false, "one deletion, not six");
-  assert.equal(session.viewers.has("staying"), true, "and it takes nobody else with it");
-  assert.equal(session.consumers.size, 1);
-});
+/**
+ * @file One object per person watching, and one deletion to forget them.
+ *
+ * It was six maps hung on the session, each keyed by consumer id, and the
+ * forgetting was already wrong: releasing a consumer emptied none of them, so a
+ * viewer who had left went on counting as wanting their soundtrack until their
+ * head expired, and their entries stayed for the life of the session.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { SourceFile } from "../services/source/SourceFile.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 { Viewer, viewerOf, viewersOf } from "../services/viewer/Viewer.js";
+
+const SESSION_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+
+test("presence and position are two facts, and presence does not wait for a request", () => {
+  const now = 1_000_000;
+  const viewer = new Viewer("someone", now);
+
+  // The whole of the 2026-09-05 failure in one assertion: a viewer who has
+  // arrived and asked for nothing yet IS watching. Answered from the position
+  // alone — which is written only when a segment is requested — this read
+  // false, every encoder on their output was stopped for having nobody, and
+  // the `init.mp4` they needed in order to request their first segment was
+  // therefore never made.
+  assert.equal(viewer.position, null, "nothing has placed them yet");
+  assert.equal(viewer.isPresent(), true, "and they are still here");
+
+  // SILENCE IS NOT ABSENCE, however long it lasts. A paused viewer, a hidden
+  // tab whose timers the browser has throttled, and one holding two minutes of
+  // cushion all say nothing and are all still watching — so there is no
+  // interval that separates them from someone who has left, and the threshold
+  // that used to try is gone.
+  viewer.seen(now - 600_000);
+  assert.equal(viewer.isPresent(), true, "ten minutes of silence is not leaving");
+
+  // Something SAID they are gone: the browser released the session, or their
+  // connection closed. That is the only way out.
+  viewer.gone = true;
+  assert.equal(viewer.isPresent(), false, "a statement is what ends it");
+});
+
+test("position is one fact with one writer, and a function of time", () => {
+  const viewer = new Viewer("someone");
+  assert.equal(viewer.positionSeconds(), null);
+
+  viewer.moveTo(40, 1_000_000);
+  viewer.playing = false;
+  assert.equal(viewer.positionSeconds(1_000_000), 40);
+  assert.equal(viewer.positionSeconds(1_060_000), 40, "a stopped picture covers no film");
+
+  viewer.playing = true;
+  assert.equal(viewer.positionSeconds(1_010_000), 50, "a playing one covers a second a second");
+
+  // A seek is the same statement, and there is no second field for it to win
+  // against: two writers taking turns on one reading is what made the priority
+  // map jump backwards several times a second in the field on 2026-09-13.
+  viewer.moveTo(900, 1_010_000);
+  assert.equal(viewer.positionSeconds(1_010_000), 900);
+});
+
+test("asking for a viewer twice is the same viewer", () => {
+  const session = {};
+  const first = viewerOf(session, "one");
+  first.audio = { trackIndex: 3, transcode: false };
+
+  assert.equal(viewerOf(session, "one"), first);
+  assert.equal(viewerOf(session, "one").audio.trackIndex, 3);
+  assert.notEqual(viewerOf(session, "two"), first);
+  assert.equal(viewersOf(session).size, 2);
+});
+
+test("releasing a consumer forgets everything that was true of them alone", async (t) => {
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "viewer-"));
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  const manager = new HlsSessionManager({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  const session = {
+    id: SESSION_ID,
+    dirPath,
+    state: "live",
+    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" }),
+    // 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; },
+    consumers: new Set(["staying", "leaving"]),
+    viewers: new Map(),
+    lastAccessedAt: Date.now()
+  };
+  manager.sessionsById.set(SESSION_ID, session);
+
+  const leaving = viewerOf(session, "leaving");
+  leaving.audio = { trackIndex: 2, transcode: true };
+  leaving.activeVariantId = "some-variant";
+  leaving.position = { segment: 40, seconds: 160, at: Date.now() };
+  viewerOf(session, "staying").audio = { trackIndex: 0, transcode: false };
+
+  await manager.releaseSessionConsumer(SESSION_ID, "leaving", "the tab was closed");
+
+  assert.equal(session.viewers.has("leaving"), false, "one deletion, not six");
+  assert.equal(session.viewers.has("staying"), true, "and it takes nobody else with it");
+  assert.equal(session.consumers.size, 1);
+});

package/test/viewer-position-on-open.test.js

@@ -1,92 +0,0 @@
-/**
- * @file Opening a file at a position puts the SOUND there too.
- *
- * The audio rendition is a session of its own, and where it starts is computed
- * from where the viewer is. That reading had three sources and only two were
- * consulted — a position seeked to, and the last segment this session served —
- * both of which are written by things that have not happened yet at the moment
- * a file is opened at a position. So the answer was zero.
- *
- * Field 2026-08-21, `Minions.and.Monsters.1080p.mkv` reopened from the address
- * bar at 52:07:
- *
- *   18:02:55.124  8ed85605  start=3130s  -ss 3125.25  -an -map 0:v:0 -c:v copy
- *   18:02:55.632  33b0b046  start=0s     no -ss       -vn -map 0:a:0 -c:a aac
- *
- * The picture went to segment #781, the sound to #0. The player asked both for
- * #782; the picture had it, the sound re-encoded 57.5 s of a 3130 s film in the
- * 45 s the request lasted and then answered 404 — shown to the viewer as "the
- * proxy accepted the request but sent no video".
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { resolveViewerPosition, viewerPositionSource } from "../services/hls-session-manager.js";
-
-test("a file opened at a position has its viewer at that position", () => {
-  // Nothing has been seeked and nothing served yet — the state at the instant
-  // the audio rendition is created.
-  assert.equal(resolveViewerPosition({ openedAt: 3130 }), 3130);
-});
-
-test("a seek beats everything else", () => {
-  assert.equal(
-    resolveViewerPosition({ seeked: 900, lastRequestedStart: 400, openedAt: 3130 }),
-    900
-  );
-});
-
-test("what has been served beats where the file was opened", () => {
-  // The opening position is the oldest of the three readings: once a segment
-  // has been served, that is where the reading is.
-  assert.equal(resolveViewerPosition({ lastRequestedStart: 400, openedAt: 3130 }), 400);
-});
-
-test("with nothing to go on the answer is the beginning", () => {
-  assert.equal(resolveViewerPosition({}), 0);
-  assert.equal(resolveViewerPosition({ seeked: 0, lastRequestedStart: 0, openedAt: 0 }), 0);
-  // Values that are not readings must not become one.
-  assert.equal(resolveViewerPosition({ seeked: Number.NaN, openedAt: Number.NaN }), 0);
-  assert.equal(resolveViewerPosition({ seeked: -5, openedAt: -5 }), 0);
-  assert.equal(resolveViewerPosition({ lastRequestedStart: null, openedAt: undefined }), 0);
-});
-
-/**
- * Which of the three answered is a separate question, and the audio start needs
- * it. A seek and a served segment are request edges — the picture is behind
- * them by however deep the viewer's buffer is, which is what the subtraction in
- * `#audioStartSecondsFor` converts. The opening position is not an edge: it is
- * where the session was made, nothing has been asked for since, and a browser
- * that has just opened holds nothing.
- *
- * Field 2026-08-31: a page opened at 588s, no report yet, and the whole 120 s
- * look-ahead was subtracted — the sound started at 460s and its first segment
- * took 38.8 s to appear against the picture's 8.4 s.
- */
-test("the reading says which of the three it came from", () => {
-  assert.equal(viewerPositionSource({ seeked: 900, lastRequestedStart: 400, openedAt: 3130 }), "seeked");
-  assert.equal(viewerPositionSource({ lastRequestedStart: 400, openedAt: 3130 }), "requested");
-  assert.equal(viewerPositionSource({ openedAt: 3130 }), "opened");
-  assert.equal(viewerPositionSource({}), "none");
-});
-
-test("the source agrees with the position, reading for reading", () => {
-  const readings = [
-    { seeked: 900, lastRequestedStart: 400, openedAt: 3130 },
-    { lastRequestedStart: 400, openedAt: 3130 },
-    { openedAt: 3130 },
-    { seeked: Number.NaN, openedAt: Number.NaN },
-    { seeked: -5, openedAt: -5 },
-    {}
-  ];
-  for (const reading of readings) {
-    const position = resolveViewerPosition(reading);
-    const source = viewerPositionSource(reading);
-    assert.equal(
-      source === "none",
-      position === 0,
-      `no source must mean no position, and the other way round: ${JSON.stringify(reading)}`
-    );
-  }
-});