@torrent-tv/proxy 2.85.0 → 2.85.1

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2.85.1
+
+- **Chore**: NOTHING IS ADDED TO THE SESSION MANAGER, and 2.85.0 added a delegation and an import to it. Both are gone, and what they were there for went with them: taking in a viewer's report is the VIEWER layer's own operation now (`services/viewer/report-intake.js`), the route calls it directly with the live sessions and the registry of viewers, and the manager has no method for it at all. Which output a viewer has on screen moved out with it (`services/viewer/active-output.js`) — it is a question about a person, not about an encoder, and eight call sites now ask it outward.
+- **Chore**: HOW LONG A LINK READING DESCRIBES A LINK is answered by the reading, once (`Viewer.linkReading`). It was a constant in the session manager consulted in four places, and three of those were conditions over a figure that had already passed that very filter — unreachable by construction. Nothing nulls a stale reading any more either: expiry is answered when it is read, so the write that existed only to make a later read correct is gone, and a viewer who has simply stopped reporting is untouched.
+- **Chore**: The session manager is 103 lines shorter for it, and gained one import and eight calls outward.
+
 ## 2.85.0
 
 - **Fix**: A VIEWER WHO HAS SAID NOTHING IS NOT ASSUMED TO BE WATCHING. `playing` started true on a viewer this proxy had never heard from, and the position is carried forward by the clock at that rate — so a page whose tab was hidden for 145 seconds, while it deliberately held start-up until it was shown, was placed **145.979 s** into a film it had not begun. Field 2026-09-14: that is the exact `-ss` the soundtrack's encoder was given, the browser was asking for segment #0, the map ranked #0 last of a hundred (`p1:#0..#13`), and the request was held 60 145 ms and answered 503. The moment the viewer left and the invented clock stopped, the plan asked for exactly the segment they had been asking for all along. A statement about somebody else's machine is theirs to make: until they make it the rate is zero.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.85.0",
+  "version": "2.85.1",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

package/routes/api/transcode-sessions/net-report/post.js

@@ -1,3 +1,5 @@
+import { recordViewerReport } from "../../../../services/viewer/report-intake.js";
+
 /**
  * Accept a viewer link report for a transcode session (adaptive bitrate).
  * The browser measures its own data-channel throughput per segment fetch and
@@ -17,10 +19,13 @@
  *
  * @param {import("fastify").FastifyRequest} req
  * @param {import("fastify").FastifyReply} reply
- * @param {{ hlsSessionManager: import("../../../../services/hls-session-manager.js").HlsSessionManager }} deps
+ * @param {{ sessions: { get: (id: string) => object | undefined }, viewers: object }} deps -
+ *   The live sessions and the registry of viewers. The VIEWER layer takes the
+ *   statement from here; this route's whole job is turning a request into that
+ *   one call and its answer into a status code.
  * @returns {Promise<void>}
  */
-export async function handleApiTranscodeSessionNetReportPost(req, reply, { hlsSessionManager }) {
+export async function handleApiTranscodeSessionNetReportPost(req, reply, { sessions, viewers }) {
   const sessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
   const body = req.body && typeof req.body === "object" && !Array.isArray(req.body) ? req.body : {};
   // WHAT THIS REPORT IS. A statement by one viewer about itself: where the
@@ -66,16 +71,21 @@ export async function handleApiTranscodeSessionNetReportPost(req, reply, { hlsSe
   const inPictureInPicture =
     typeof body.inPictureInPicture === "boolean" ? body.inPictureInPicture : undefined;
   const positionSeconds = Number(body.positionSeconds);
-  const recorded = hlsSessionManager.recordNetReport(sessionId, {
-    linkMbps: Number.isFinite(linkMbps) && linkMbps > 0 ? linkMbps : undefined,
-    waiting,
-    bufferedAheadSec,
-    consumerId,
-    playing,
-    onScreen,
-    inPictureInPicture,
-    positionSeconds:
-      Number.isFinite(positionSeconds) && positionSeconds >= 0 ? positionSeconds : undefined
+  const recorded = recordViewerReport({
+    sessions,
+    viewers,
+    sessionId,
+    report: {
+      linkMbps: Number.isFinite(linkMbps) && linkMbps > 0 ? linkMbps : undefined,
+      bufferedAheadSec,
+      consumerId,
+      playing,
+      waiting,
+      onScreen,
+      inPictureInPicture,
+      positionSeconds:
+        Number.isFinite(positionSeconds) && positionSeconds >= 0 ? positionSeconds : undefined
+    }
   });
   if (!recorded) {
     return reply.code(404).send({ error: "Transcode session was not found." });

package/server.js

@@ -393,7 +393,13 @@ export async function startProxyServer({
     handleApiTranscodeSessionsProgressGet(req, reply, { hlsSessionManager })
   );
   app.post("/api/transcode-sessions/:sessionId/net-report", async (req, reply) =>
-    handleApiTranscodeSessionNetReportPost(req, reply, { hlsSessionManager })
+    // A viewer's statement about itself goes to the VIEWER layer, not through
+    // the session manager: what it needs is the live sessions and the registry
+    // of viewers, and nothing about encoding.
+    handleApiTranscodeSessionNetReportPost(req, reply, {
+      sessions: hlsSessionManager.sessionsById,
+      viewers: hlsSessionManager.viewers
+    })
   );
   app.post("/api/transcode-sessions/:sessionId/fragment-far", async (req, reply) =>
     handleApiTranscodeSessionFragmentFarPost(req, reply, { hlsSessionManager })

package/services/hls-session-manager.js

@@ -88,8 +88,8 @@ import {
 // — did not move when the code did.
 export { ffmpegSeconds, onKeyframeGridFor, seekLandingOffsetFor, segmentCutTimesFrom };
 import { viewersOf } from "./viewer/Viewer.js";
+import { activeOutputFor } from "./viewer/active-output.js";
 import { earliestViewerSecondsOn, viewerSecondsOn, viewerSegmentsOn } from "./viewer/positions.js";
-import { takeViewerReport } from "./viewer/report-intake.js";
 import { Viewers } from "./viewer/Viewers.js";
 import { LiveOutputs } from "./output/LiveOutputs.js";
 import { variantHeightsFor } from "./output/ladder.js";
@@ -524,7 +524,6 @@ const BUDGET_DOWNLOAD_OK_FACTOR = 1.0;
 // instead. Which of the two, and whether a viewer's own pick may be moved at
 // all, is decided where the viewer's choice lives: in the browser, which
 // honours the request only in automatic mode.
-const LINK_REPORT_FRESH_MS = 30_000;
 // Usable share of the reported link (protocol overhead + measurement noise).
 const LINK_SAFETY = 0.8;
 // Deficit must persist this long before acting (absorbs one slow segment).
@@ -3058,36 +3057,6 @@ export class HlsSessionManager {
    *
    * @returns {Promise<void>}
    */
-  /**
-   * Record the latest viewer link report for a session (adaptive bitrate).
-   * Returns false for an unknown/disposed session.
-   *
-   * Kept per viewer. A browser that does not say who it is lands under one
-   * shared key, which is exactly the old behaviour for that browser and no
-   * worse: with one viewer the two are the same thing.
-   *
-   * @param {string} sessionId
-   * @param {{ linkMbps: number, bufferedAheadSec: number, consumerId?: string, positionSeconds?: number }} report
-   * @returns {boolean}
-   */
-  recordNetReport(sessionId, report) {
-    const named = this.sessionsById.get(sessionId);
-    if (!named || named.state === "disposed") {
-      return false;
-    }
-    const consumerId = typeof report?.consumerId === "string" ? report.consumerId : "";
-    return takeViewerReport({
-      viewers: this.viewers,
-      // The stream on screen is the reporter's own: with two viewers on two
-      // rungs, one report says nothing about the other's encoder.
-      session: this.#activeVariant(named, consumerId),
-      consumerId,
-      report,
-      now: Date.now(),
-      linkFreshMs: LINK_REPORT_FRESH_MS
-    });
-  }
-
   /**
    * Record where one viewer of this session is, and answer with the furthest
    * any of them has reached.
@@ -3135,8 +3104,8 @@ export class HlsSessionManager {
   #worstNetReport(session, now) {
     let worst = null;
     for (const viewer of viewersOf(session).values()) {
-      const report = viewer.netReport;
-      if (report === null || now - report.at > LINK_REPORT_FRESH_MS) {
+      const report = viewer.linkReading(now);
+      if (report === null) {
         continue;
       }
       if (worst === null) {
@@ -3186,7 +3155,7 @@ export class HlsSessionManager {
     // run and its own position, and that is exactly the pair this report exists
     // to tell apart. Answering an audio report from the picture's records would
     // state, confidently, something about the wrong stream.
-    const onScreen = this.#activeVariant(named);
+    const onScreen = activeOutputFor({ base: named, sessions: this.sessionsById, viewers: this.viewers });
     const session = track === "audio"
       ? ([...this.liveOutputs.familyOf(onScreen)].find((member) => member.audioOnly === true) ?? onScreen)
       : onScreen;
@@ -3275,7 +3244,7 @@ export class HlsSessionManager {
    */
   async #checkLinkBudget(session, now) {
     const report = this.#worstNetReport(session, now);
-    if (!report || now - report.at > LINK_REPORT_FRESH_MS) {
+    if (!report) {
       session.linkSlowSince = 0; // no fresh data — old clients / stopped reporter
       return false;
     }
@@ -4666,7 +4635,7 @@ export class HlsSessionManager {
       }
       return false;
     }
-    const playing = this.liveOutputs.variantHeightOf(this.#activeVariant(base));
+    const playing = this.liveOutputs.variantHeightOf(activeOutputFor({ base, sessions: this.sessionsById, viewers: this.viewers }));
     if (height === playing) {
       return false;
     }
@@ -4765,7 +4734,7 @@ export class HlsSessionManager {
       return false;
     }
     const report = this.#worstNetReport(session, now);
-    if (!report || now - report.at > LINK_REPORT_FRESH_MS) {
+    if (!report) {
       // Nothing fresh measures the link, so it has no opinion either way — the
       // same silence that stops #checkLinkBudget from acting.
       return true;
@@ -4793,7 +4762,7 @@ export class HlsSessionManager {
     // The SLOWEST link among the viewers: a step up has to be carried by all of
     // them, not by whichever reported last.
     const report = this.#worstNetReport(session, now);
-    if (!report || now - report.at > LINK_REPORT_FRESH_MS) {
+    if (!report) {
       return true;
     }
     return report.linkMbps * LINK_SAFETY >= wantedMbps;
@@ -7167,7 +7136,7 @@ export class HlsSessionManager {
     if (!ask) {
       return 0;
     }
-    if (ask.height === this.liveOutputs.variantHeightOf(this.#activeVariant(base))) {
+    if (ask.height === this.liveOutputs.variantHeightOf(activeOutputFor({ base, sessions: this.sessionsById, viewers: this.viewers }))) {
       base.qualityAsk = null; // the viewer is there; nothing left to ask for
       return 0;
     }
@@ -7182,45 +7151,6 @@ export class HlsSessionManager {
     return ask.height;
   }
 
-  /**
-   * The variant of a session that the viewer is watching right now.
-   *
-   * Every request that names the base session — seek, progress, link report,
-   * release — means the stream the viewer has on screen, and after a quality
-   * change that is another session. The browser is not told about the swap: it
-   * holds one session id for the whole file, which is what keeps the switch out
-   * of the state machine on that side.
-   *
-   * Kept per viewer, because one picture is shared by everyone watching it and
-   * a quality step is a session of its own: with one answer for the session, a
-   * step taken by one viewer would move the other one's stream, and that
-   * viewer's next seek would be forwarded to a rung they never chose. The
-   * session's own field remains the answer for a viewer who cannot name
-   * themselves, and the last one anybody moved to.
-   *
-   * @param {HlsSession} base
-   * @param {string} [consumerId]
-   * @returns {HlsSession}
-   */
-  #activeVariant(base, consumerId = "") {
-    const named = consumerId ? base.viewers?.get(consumerId)?.activeVariantId ?? null : null;
-    const activeId = named ?? base.activeVariantId;
-    if (!activeId || activeId === base.id) {
-      return base;
-    }
-    const active = this.sessionsById.get(activeId);
-    if (!active || active.state === "disposed") {
-      if (named) {
-        this.viewers.of(base, consumerId).activeVariantId = null;
-      }
-      if (base.activeVariantId === activeId) {
-        base.activeVariantId = base.id;
-      }
-      return base;
-    }
-    return active;
-  }
-
   /**
    * Every session of this family that a live viewer has on screen.
    *
@@ -7245,7 +7175,7 @@ export class HlsSessionManager {
       onScreen.add(viewer.activeVariantId);
     }
     if (onScreen.size === 0) {
-      onScreen.add(this.#activeVariant(base).id);
+      onScreen.add(activeOutputFor({ base, sessions: this.sessionsById, viewers: this.viewers }).id);
     }
     return onScreen;
   }
@@ -7278,7 +7208,7 @@ export class HlsSessionManager {
     if (Number.isInteger(wantedIndex) && wantedIndex >= 0) {
       return this.#segmentStartTime(base, wantedIndex);
     }
-    return viewerSecondsOn(this.#activeVariant(base, consumerId));
+    return viewerSecondsOn(activeOutputFor({ base, consumerId, sessions: this.sessionsById, viewers: this.viewers }));
   }
 
   /**
@@ -7883,7 +7813,7 @@ export class HlsSessionManager {
     // buys it an encoder, and both halves are said here: a warmed rung is one
     // this person is watching for as long as the warm-up lasts, which is why
     // two encoders run through it.
-    if (variant.id !== this.#activeVariant(base, consumerId).id) {
+    if (variant.id !== activeOutputFor({ base, consumerId, sessions: this.sessionsById, viewers: this.viewers }).id) {
       this.viewers.of(variant, consumerId).moveTo(this.#segmentStartTime(base, index));
       this.planEncodersSoon();
     }
@@ -7908,7 +7838,7 @@ export class HlsSessionManager {
    * @returns {void}
    */
   #noteVariantActive(base, variant, wantedIndex = -1, consumerId = "") {
-    const previous = this.#activeVariant(base, consumerId);
+    const previous = activeOutputFor({ base, consumerId, sessions: this.sessionsById, viewers: this.viewers });
     if (previous.id === variant.id) {
       // The rung on screen asking for more of itself, which it does every few
       // seconds. Nothing is being decided here — and deciding anything was the
@@ -9431,7 +9361,7 @@ export class HlsSessionManager {
     // change is another session. Touching the named one as well is what keeps
     // the family alive: only the ACTIVE variant gets segment requests, so
     // without this the base session would idle out from under its own variants.
-    const session = this.#activeVariant(named, consumerId);
+    const session = activeOutputFor({ base: named, consumerId, sessions: this.sessionsById, viewers: this.viewers });
     session.lastAccessedAt = Date.now();
     const warmupTotalSeconds = this.startupWaitMs / 1000;
     const warmupElapsedSeconds = Math.max(0, (Date.now() - session.startedAt) / 1000);

package/services/viewer/Viewer.js

@@ -40,6 +40,15 @@
  * question, and it reads a union of viewers rather than any one of them.
  */
 
+/**
+ * How long a link measurement describes the link it was taken on.
+ *
+ * A reading older than this says nothing about now: the viewer may have seeked,
+ * changed network, or stopped. Thirty seconds is three of the page's own
+ * reporting intervals, so a live viewer always has a fresh one.
+ */
+export const LINK_READING_FRESH_MS = 30_000;
+
 export class Viewer {
   /**
    * @param {string} id - The consumer id the browser sends with every request
@@ -321,6 +330,31 @@ export class Viewer {
    *
    * @returns {boolean}
    */
+  /**
+   * What this viewer's link was last measured to carry, or null when nothing
+   * recent measures it.
+   *
+   * HOW LONG A READING DESCRIBES A LINK is a fact about the reading, so it is
+   * answered here and nowhere else. It used to be a constant in the session
+   * manager, consulted in four places — once where a reading is chosen, and
+   * three more times over a figure that had already passed that very filter,
+   * which made those three conditions unreachable.
+   *
+   * A viewer who has stopped reporting is NOT thereby gone: only the reading
+   * expires. Answering both from one place is what stopped a soundtrack's
+   * encoder on 2026-09-05.
+   *
+   * @param {number} [now]
+   * @returns {{ linkMbps: number, bufferedAheadSec: number, positionSeconds: number | null, at: number } | null}
+   */
+  linkReading(now = Date.now()) {
+    const reading = this.netReport;
+    if (reading === null || now - reading.at > LINK_READING_FRESH_MS) {
+      return null;
+    }
+    return reading;
+  }
+
   /**
    * Whether this viewer wants film NOW — either watching it or waiting for it.
    *

package/services/viewer/active-output.js

@@ -0,0 +1,54 @@
+/**
+ * @file Which output a viewer has on screen.
+ *
+ * Every request that names the picture's session — a seek, a progress poll, a
+ * link report, a release — means the stream the viewer is actually watching,
+ * and after a quality change that is another session. The browser is never told
+ * about the swap: it holds one session id for the whole file, which is what
+ * keeps the switch out of the state machine on that side.
+ *
+ * KEPT PER VIEWER, because one picture is shared by everyone watching it and a
+ * quality step is a session of its own. With one answer for the session, a step
+ * taken by one viewer moved the other one's stream, and that viewer's next seek
+ * was forwarded to a rung they never chose. The session's own field remains the
+ * answer for a viewer who cannot name themselves, and is the last rung anybody
+ * moved to.
+ *
+ * It is handed the picture, a name, the live sessions and the registry of
+ * viewers, and it HOLDS none of them — but it is not read-only: finding a rung
+ * that has been disposed, it puts both remembers back on the picture, or the
+ * next question gets the same dead answer. It lives in the VIEWER layer because
+ * the question is about a person — which of several equally live outputs is
+ * theirs — and it knows nothing of encoders, files or heights.
+ */
+
+/**
+ * @param {object} params
+ * @param {object} params.base - The picture's own session.
+ * @param {string} [params.consumerId] - Whose screen. Empty asks about the
+ *   session's own last answer, which is what an unnamed browser gets.
+ * @param {{ get: (id: string) => object | undefined }} params.sessions - Every live session, by id.
+ * @param {{ of: (session: object, consumerId: string) => { activeVariantId: string | null } }} params.viewers
+ * @returns {object} A live session, never a disposed one.
+ */
+export function activeOutputFor({ base, consumerId = "", sessions, viewers }) {
+  const named = consumerId ? base.viewers?.get(consumerId)?.activeVariantId ?? null : null;
+  const activeId = named ?? base.activeVariantId;
+  if (!activeId || activeId === base.id) {
+    return base;
+  }
+  const active = sessions.get(activeId);
+  if (!active || active.state === "disposed") {
+    // The rung is gone, so the viewer is watching the picture again. Said in
+    // both places that remember it, or the next question gets the same dead
+    // answer.
+    if (named) {
+      viewers.of(base, consumerId).activeVariantId = null;
+    }
+    if (base.activeVariantId === activeId) {
+      base.activeVariantId = base.id;
+    }
+    return base;
+  }
+  return active;
+}

package/services/viewer/report-intake.js

@@ -1,63 +1,44 @@
-/**
- * @file A viewer's statement about itself, taken in.
- *
- * The VIEWER layer's own entry point, and the whole of what happens when a page
- * says where it is: the statement reaches the person it is about, and readings
- * that have gone stale stop deciding for the people still here.
- *
- * It lived in the session manager, which is a description of an OUTPUT, and the
- * two questions were tangled there: whether this is a measurement of a LINK,
- * and whether this is a statement by a VIEWER. Required to be both, a page that
- * had measured nothing could say nothing — see `Viewer.report`.
- *
- * Given the session and the registry as plain arguments, so nothing here knows
- * how a session is found, what a variant is, or that there is an encoder.
- */
-
-import { viewersOf } from "./Viewer.js";
-
-/**
- * Take one report.
- *
- * @param {object} params
- * @param {{ of: (session: object, consumerId: string) => import("./Viewer.js").Viewer }} params.viewers
- * @param {object} params.session - The output this viewer has on screen.
- * @param {string} params.consumerId - Who is reporting; empty when the page
- *   does not name itself, and then every such page shares one viewer, which is
- *   exactly what one unnamed browser is.
- * @param {object} params.report - What they said about themselves.
- * @param {number} params.now
- * @param {number} params.linkFreshMs - How long a link reading describes the
- *   link it was measured on.
- * @returns {true}
- */
-export function takeViewerReport({ viewers, session, consumerId, report, now, linkFreshMs }) {
-  viewers.of(session, consumerId).report(report, now);
-  forgetStaleLinkReadings({ session, now, linkFreshMs });
-  return true;
-}
-
-/**
- * Drop link readings older than the time they describe.
- *
- * ONLY THE READING EXPIRES. Whether the person is still watching is a different
- * question with its own answer — their connection — and a viewer who has simply
- * stopped reporting is not thereby gone. Answering both from this one place is
- * what stopped a soundtrack's encoder on 2026-09-05, seconds after it started
- * and before it had made the `init.mp4` the picture could not be played
- * without.
- *
- * @param {object} params
- * @param {object} params.session
- * @param {number} params.now
- * @param {number} params.linkFreshMs
- * @returns {void}
- */
-export function forgetStaleLinkReadings({ session, now, linkFreshMs }) {
-  for (const viewer of viewersOf(session).values()) {
-    const reading = viewer.netReport;
-    if (reading !== null && now - reading.at > linkFreshMs) {
-      viewer.netReport = null;
-    }
-  }
-}
+/**
+ * @file A viewer's statement about itself, taken in.
+ *
+ * The VIEWER layer's own entry point, and the whole of what happens when a page
+ * says where it is: the output the reporter has on screen is resolved, the
+ * statement reaches the person it is about, and readings that have gone stale
+ * stop deciding for the people still here.
+ *
+ * It lived in the session manager, which is a description of an OUTPUT, and the
+ * two questions were tangled there: whether this is a measurement of a LINK,
+ * and whether this is a statement by a VIEWER. Required to be both, a page that
+ * had measured nothing could say nothing — see `Viewer.report`.
+ *
+ * Given the sessions and the registry as plain values, so nothing here knows
+ * how a session is found, what a variant is, or that there is an encoder.
+ */
+
+import { activeOutputFor } from "./active-output.js";
+
+/**
+ * Take one report from one viewer.
+ *
+ * @param {object} params
+ * @param {{ get: (id: string) => object | undefined }} params.sessions - Every live session, by id.
+ * @param {{ of: (session: object, consumerId: string) => import("./Viewer.js").Viewer }} params.viewers
+ * @param {string} params.sessionId - The session the page addresses, which is
+ *   always the picture's: the browser is not told which rung it is on.
+ * @param {object} params.report - What they said about themselves.
+ * @param {number} [params.now]
+ * @returns {boolean} False when no such session is live, which is the page
+ *   reporting into one that has been disposed.
+ */
+export function recordViewerReport({ sessions, viewers, sessionId, report, now = Date.now() }) {
+  const named = sessions.get(sessionId);
+  if (!named || named.state === "disposed") {
+    return false;
+  }
+  const consumerId = typeof report?.consumerId === "string" ? report.consumerId : "";
+  // The stream on screen is the reporter's own: with two viewers on two rungs,
+  // one report says nothing about the other's encoder.
+  const session = activeOutputFor({ base: named, consumerId, sessions, viewers });
+  viewers.of(session, consumerId).report(report, now);
+  return true;
+}