@torrent-tv/proxy 2.85.1 → 2.86.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2.86.0
+
+- **Fix**: A LINK READING NO LONGER EXPIRES, and the thirty seconds that made it expire were a chosen number holding two facts at once: how fast the link is, and whether we are still hearing from the page. The speed persists — a link does not stop being what it was measured to be because nobody measured it for a minute, which is why the page keeps its own last figure rather than reporting nothing. It is measured once when the connection comes up and corrected by every transfer after that: one estimate, continuously refined, never a fact with a deadline. Whether a reading is still somebody's is PRESENCE, which has its own owner — a viewer who has gone is removed from the output, so the readings weighed for a decision are only those of people still there.
+- **Chore**: The worst reading across the viewers of one output moved to the viewer's own layer (`services/viewer/link-readings.js`), and skips anybody not present. With the expiry gone, `#linkCouldCarry` no longer takes a clock it cannot use.
+- **Chore**: Where a soundtrack must begin moved out too (`services/viewer/audio-start.js`) — it is a question about where the earliest PERSON stands across every rung of a picture, decided one parameter of an output, and had no business being answered inside the session manager. The manager is 199 lines shorter than before this work for both moves, and every line it gained is an import or a call outward.
+
 ## 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.

package/package.json

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

package/services/hls-session-manager.js

@@ -89,7 +89,9 @@ import {
 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 { audioStartSecondsFor } from "./viewer/audio-start.js";
+import { worstLinkReading } from "./viewer/link-readings.js";
+import { viewerSecondsOn, viewerSegmentsOn } from "./viewer/positions.js";
 import { Viewers } from "./viewer/Viewers.js";
 import { LiveOutputs } from "./output/LiveOutputs.js";
 import { variantHeightsFor } from "./output/ladder.js";
@@ -3086,44 +3088,6 @@ export class HlsSessionManager {
     this.viewers.of(session, consumerId).seen();
   }
 
-  /**
-   * The worst of what the viewers of this session report, as one reading.
-   *
-   * The budget asks one question — is anybody failing to keep up — so both
-   * terms are the worst case: the slowest link and the emptiest buffer, which
-   * may belong to different people. That is deliberate. Taking the last report
-   * instead meant a session with two viewers acted on whichever of them
-   * happened to report most recently.
-   *
-   * @param {HlsSession} session
-   * @param {number} now
-   * @returns {{ linkMbps: number, bufferedAheadSec: number, at: number, viewers: number } | null}
-   *   Null when nothing fresh measures the link, which is the silence every
-   *   caller already treats as "no opinion".
-   */
-  #worstNetReport(session, now) {
-    let worst = null;
-    for (const viewer of viewersOf(session).values()) {
-      const report = viewer.linkReading(now);
-      if (report === null) {
-        continue;
-      }
-      if (worst === null) {
-        worst = {
-          linkMbps: report.linkMbps,
-          bufferedAheadSec: report.bufferedAheadSec,
-          at: report.at,
-          viewers: 1
-        };
-        continue;
-      }
-      worst.linkMbps = Math.min(worst.linkMbps, report.linkMbps);
-      worst.bufferedAheadSec = Math.min(worst.bufferedAheadSec, report.bufferedAheadSec);
-      worst.at = Math.max(worst.at, report.at);
-      worst.viewers += 1;
-    }
-    return worst;
-  }
 
   /**
    * Answer the player's report that a delivered fragment sits far from the edge
@@ -3243,9 +3207,9 @@ export class HlsSessionManager {
    * @returns {Promise<boolean>}
    */
   async #checkLinkBudget(session, now) {
-    const report = this.#worstNetReport(session, now);
+    const report = worstLinkReading(session);
     if (!report) {
-      session.linkSlowSince = 0; // no fresh data — old clients / stopped reporter
+      session.linkSlowSince = 0; // nobody present has measured their link
       return false;
     }
     if (report.bufferedAheadSec >= LINK_LOW_BUFFER_SEC) {
@@ -4689,7 +4653,7 @@ export class HlsSessionManager {
       // top offered height has no next rung at all, and answering "nothing to
       // step to, so yes" is how a cap came off a link measured at a fifth of
       // what the picture needs.
-      if (!this.#linkCouldCarry(session, this.#peakMbpsForHeight(this.liveOutputs.pictureOf(session), current), now)) {
+      if (!this.#linkCouldCarry(session, this.#peakMbpsForHeight(this.liveOutputs.pictureOf(session), current))) {
         return;
       }
       session.budgetUpSince = 0;
@@ -4733,10 +4697,10 @@ export class HlsSessionManager {
     if (session.linkSlowSince !== 0 || session.budgetSlowSince !== 0) {
       return false;
     }
-    const report = this.#worstNetReport(session, now);
+    const report = worstLinkReading(session);
     if (!report) {
-      // Nothing fresh measures the link, so it has no opinion either way — the
-      // same silence that stops #checkLinkBudget from acting.
+      // Nothing measures the link, so it has no opinion either way — the same
+      // silence that stops #checkLinkBudget from acting.
       return true;
     }
     const base = this.liveOutputs.pictureOf(session);
@@ -4744,24 +4708,23 @@ export class HlsSessionManager {
     if (next === undefined) {
       return true; // nothing to step to; only the cap decision is left
     }
-    return this.#linkCouldCarry(session, this.#peakMbpsForHeight(base, next), now);
+    return this.#linkCouldCarry(session, this.#peakMbpsForHeight(base, next));
   }
 
   /**
    * Whether the viewer's measured link can carry a given number of Mbit/s.
    *
-   * A link nobody has measured recently has no opinion either way — the same
+   * A link nobody has ever measured has no opinion either way — the same
    * silence that stops `#checkLinkBudget` from acting — so it answers yes.
    *
    * @param {HlsSession} session
    * @param {number} wantedMbps
-   * @param {number} now
    * @returns {boolean}
    */
-  #linkCouldCarry(session, wantedMbps, now) {
+  #linkCouldCarry(session, wantedMbps) {
     // 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);
+    const report = worstLinkReading(session);
     if (!report) {
       return true;
     }
@@ -7280,54 +7243,6 @@ export class HlsSessionManager {
     return { earliestPosition, deepestBuffer, viewers };
   }
 
-  /**
-   * Where a soundtrack must begin: at the earliest film anybody is waiting on.
-   *
-   * ASKED OF THE MAP, NOT OF A VIEWER. Sound is produced for the same reason a
-   * picture is, and the map already states it — in seconds of film, merged over
-   * everybody watching, with the map's own order saying which of them is
-   * earliest. Reading it off a viewer put a person inside the encoding layer,
-   * and then every question about WHICH person had to be answered a second time
-   * here: the earliest of two, the one on this rung, the one who has not
-   * reported yet.
-   *
-   * The apparatus this replaced is worth naming so it is not rebuilt: three
-   * position sources ranked by priority, a function saying which had answered,
-   * a subtraction of the deepest reported buffer, and a special case for a
-   * session nobody had asked anything of. Each repaired a quantity that meant
-   * two things. It means one thing now.
-   *
-   * One segment back, and that is not a margin: a cut grid places the
-   * soundtrack's own boundaries where it will, so the piece holding a moment of
-   * film begins at or before it.
-   *
-   * @param {HlsSession} base
-   * @returns {number} Seconds.
-   */
-  #audioStartSecondsFor(base) {
-    // WHERE THE EARLIEST OF THEM STANDS, across every rung of this picture. A
-    // track begun at the leader has nothing to give the viewer behind them, and
-    // two viewers of one film may be on different rungs.
-    //
-    // NO SUBTRACTION, and that is the whole of the change. A viewer's position
-    // is where their PICTURE is, so the sound belongs exactly there — while the
-    // apparatus this replaced turned a request edge back into a playhead with
-    // three ranked sources, a name for which had answered, a subtraction of the
-    // deepest reported buffer, and a special case for a session nobody had
-    // asked anything of. Field 2026-08-31: a page opened at 588 s started its
-    // sound at 460 s, 131 seconds nobody would hear
-    // (`research/cold-open-audio-start-2026-08-31.md`).
-    //
-    // A fact about people, deciding one parameter of an output. It places no
-    // encoder: where an encoder works is the priority map's answer.
-    const earliest = earliestViewerSecondsOn(this.liveOutputs.familyOf(base));
-    const opened = Number(base.progress?.startPositionSeconds);
-    const from = earliest ?? (Number.isFinite(opened) ? opened : 0);
-    // One segment back, and that is not a margin: a cut grid places the
-    // soundtrack's own boundaries where it will, so the piece holding a moment
-    // of film begins at or before it.
-    return Math.max(0, from - this.segmentDurationSec);
-  }
 
 
   /**
@@ -8263,7 +8178,11 @@ export class HlsSessionManager {
       // who seeked since then is somewhere else entirely — so an old one is
       // ignored and the whole look-ahead is subtracted instead, which cannot
       // leave the run ahead of them.
-      startPositionSeconds: this.#audioStartSecondsFor(base),
+      startPositionSeconds: audioStartSecondsFor({
+        family: this.liveOutputs.familyOf(base),
+        openedAtSeconds: base.progress?.startPositionSeconds,
+        segmentSeconds: this.segmentDurationSec
+      }),
       segmentFormatId: base.segmentFormat.id,
       // Cut where the picture is cut. Two streams meant to be played together
       // have to be divided at the same times, and the grid is the base's — the

package/services/viewer/Viewer.js

@@ -40,15 +40,6 @@
  * 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
@@ -331,28 +322,31 @@ export class Viewer {
    * @returns {boolean}
    */
   /**
-   * What this viewer's link was last measured to carry, or null when nothing
-   * recent measures it.
+   * What this viewer's link was last measured to carry, or null when it has
+   * never been measured.
    *
-   * 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.
+   * IT DOES NOT EXPIRE, and the reasoning is the correction of 2026-09-14. A
+   * reading older than a chosen thirty seconds used to be discarded here, which
+   * put two facts under one number: how fast the link is, and whether we are
+   * still hearing from this page.
    *
-   * 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.
+   * The speed persists. A link does not stop being what it was measured to be
+   * because nobody measured it for a minute, and the page says as much by
+   * keeping its own last figure for ever rather than reporting nothing. It is
+   * measured once when the connection comes up and corrected by every transfer
+   * afterwards — one estimate, continuously refined, never a fact with a
+   * deadline.
+   *
+   * Whether the reading is still somebody's is PRESENCE, which has its own
+   * owner: a viewer who has gone is removed from the output, and the readings
+   * walked for a decision are only those of people still there. Answering both
+   * questions in 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;
+  linkReading() {
+    return this.netReport;
   }
 
   /**

package/services/viewer/audio-start.js

@@ -0,0 +1,45 @@
+/**
+ * @file Where a soundtrack must begin.
+ *
+ * ASKED OF THE PEOPLE, NOT OF A SESSION. Sound is produced for the same reason
+ * a picture is — somebody is going to hear it — so the question is where the
+ * earliest of them stands, across every rung of that picture: a track begun at
+ * the leader has nothing to give the viewer behind them, and two viewers of one
+ * film may be watching at different qualities.
+ *
+ * NO SUBTRACTION, and that is the whole of what this replaced: three position
+ * sources ranked by priority, a second function naming which had answered, a
+ * subtraction of the deepest reported buffer, and a special case for a session
+ * nobody had asked anything of. Each repaired a quantity that meant two things.
+ * A viewer's position is where their PICTURE is, so the sound belongs exactly
+ * there. Field 2026-08-31, what the subtraction cost: a page opened at 588 s
+ * started its sound at 460 s — 131 seconds nobody would hear
+ * (`research/cold-open-audio-start-2026-08-31.md`).
+ *
+ * It decides ONE PARAMETER of an output and places no encoder: where an encoder
+ * works is the priority map's answer. Pure over plain values — the outputs of
+ * one picture, where it was opened, and how long a piece is — so it knows
+ * nothing of ffmpeg, cut grids or the disk.
+ */
+
+import { earliestViewerSecondsOn } from "./positions.js";
+
+/**
+ * @param {object} params
+ * @param {Iterable<object>} params.family - Every output of one picture: the
+ *   picture itself and its quality steps. The viewers are spread across them.
+ * @param {number} params.openedAtSeconds - Where the picture was opened, which
+ *   is the answer while nobody has stated a position yet.
+ * @param {number} params.segmentSeconds - How long one piece is.
+ * @returns {number} Seconds, never negative.
+ */
+export function audioStartSecondsFor({ family, openedAtSeconds, segmentSeconds }) {
+  const earliest = earliestViewerSecondsOn(family);
+  const opened = Number(openedAtSeconds);
+  const from = earliest ?? (Number.isFinite(opened) ? opened : 0);
+  // ONE PIECE BACK, and that is not a margin: a cut grid places the
+  // soundtrack's own boundaries where it will, so the piece holding a moment of
+  // film begins at or before it.
+  const back = Number.isFinite(segmentSeconds) && segmentSeconds > 0 ? segmentSeconds : 0;
+  return Math.max(0, from - back);
+}

package/services/viewer/link-readings.js

@@ -0,0 +1,56 @@
+/**
+ * @file What the viewers of one output say about their links, as one reading.
+ *
+ * The budget asks one question — is anybody failing to keep up — so both terms
+ * are the worst case: the slowest link and the emptiest buffer, which may
+ * belong to different people. Taking the last report instead meant a session
+ * with two viewers acted on whichever of them happened to report most recently.
+ *
+ * NOTHING HERE EXPIRES, and that is the correction of 2026-09-14. A reading
+ * used to be discarded once it was older than a chosen thirty seconds, which
+ * conflated two facts under one number: how fast the link is, and whether we
+ * are still hearing from the page. The first persists — a link does not stop
+ * being what it was measured to be because nobody measured it for a minute,
+ * which is why the page itself keeps its last figure for ever. The second is
+ * PRESENCE, and presence has its own owner: a viewer who has gone is removed
+ * from the output, so what is walked here is only people who are still here.
+ *
+ * The reading is corrected continuously while material crosses the link, which
+ * is the whole shape: measured once when the connection comes up, corrected by
+ * every transfer after it.
+ */
+
+import { viewersOf } from "./Viewer.js";
+
+/**
+ * @param {object} output - The session whose viewers are asked.
+ * @returns {{ linkMbps: number, bufferedAheadSec: number, at: number, viewers: number } | null}
+ *   Null when nobody present has ever measured their link, which every caller
+ *   already treats as "no opinion either way".
+ */
+export function worstLinkReading(output) {
+  let worst = null;
+  for (const viewer of viewersOf(output).values()) {
+    if (!viewer.isPresent()) {
+      continue;
+    }
+    const reading = viewer.linkReading();
+    if (reading === null) {
+      continue;
+    }
+    if (worst === null) {
+      worst = {
+        linkMbps: reading.linkMbps,
+        bufferedAheadSec: reading.bufferedAheadSec,
+        at: reading.at,
+        viewers: 1
+      };
+      continue;
+    }
+    worst.linkMbps = Math.min(worst.linkMbps, reading.linkMbps);
+    worst.bufferedAheadSec = Math.min(worst.bufferedAheadSec, reading.bufferedAheadSec);
+    worst.at = Math.max(worst.at, reading.at);
+    worst.viewers += 1;
+  }
+  return worst;
+}

package/services/viewer/report-intake.js

@@ -2,9 +2,10 @@
  * @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.
+ * says where it is: the output the reporter has on screen is resolved, and the
+ * statement reaches the person it is about. Nothing expires here — a link
+ * reading is the last thing known about that link, and whether it is still
+ * somebody's is presence's answer (`Viewer.linkReading`).
  *
  * 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,

package/test/auto-quality-step.test.js

@@ -345,7 +345,7 @@ test("with two viewers the budget acts on the WORST link, not on whoever reporte
   );
 });
 
-test("a report from a viewer who has left stops counting", async (t) => {
+test("a reading stops counting when the person leaves, not when it gets old", async (t) => {
   const { manager, session, dirPath } = await managerWithSession({ transcodeVideo: false });
   t.after(async () => {
     await manager.disposeAll();
@@ -353,17 +353,15 @@ test("a report from a viewer who has left stops counting", async (t) => {
   });
 
   await produceSegments(session, 2_000_000);
-  // A reading describes a link at a moment, and one this old cannot decide for
-  // the viewers still here. ONLY THE READING EXPIRES: whether the person is
-  // still watching is a different question with its own answer — their
-  // connection — and answering both from this one place is what stopped a
-  // soundtrack's encoder on 2026-09-05, so silence no longer removes anybody.
-  viewerOf(session, "gone").netReport = {
-    linkMbps: 1.0,
-    bufferedAheadSec: 1.5,
-    positionSeconds: 40,
-    at: Date.now() - 120_000
-  };
+  // A LINK READING DOES NOT EXPIRE. It is the last thing known about that link,
+  // and how fast a link is does not change because nobody measured it for a
+  // minute — the page keeps its own last figure for the same reason. What ends
+  // a reading is the person leaving, which is presence, and presence is the
+  // connection: silence removes nobody (2026-09-05, a soundtrack's encoder
+  // stopped because those two questions had one answer).
+  const gone = viewerOf(session, "gone");
+  gone.report({ linkMbps: 1.0, bufferedAheadSec: 1.5, positionSeconds: 40, playing: true }, Date.now() - 120_000);
+  gone.gone = true;
   recordViewerReport({
     sessions: manager.sessionsById,
     viewers: manager.viewers,
@@ -375,13 +373,12 @@ test("a report from a viewer who has left stops counting", async (t) => {
   await manager.runQualityBudgetOnce();
 
   assert.equal(session.viewers.size, 2, "the viewer is still known — silence is not leaving");
-  // The reading is not deleted anywhere: how long one describes a link is a
-  // fact about the reading, answered when it is read. Nulling it on somebody
-  // else's report was a second owner of the same fact.
+  // Their reading is not deleted anywhere: it is simply not theirs to give any
+  // more, because they are not here. Nothing walks it for a decision.
   assert.equal(
-    viewerOf(session, "gone").linkReading(Date.now()),
-    null,
-    "and their reading has expired, so it decides nothing"
+    viewerOf(session, "gone").linkReading()?.linkMbps,
+    1.0,
+    "their last reading stands as the last thing known about that link"
   );
   assert.equal(session.qualityAsk, null, "the viewer who is here can carry the picture");
 });

package/test/viewer-states.test.js

@@ -144,16 +144,46 @@ test("the intake hands the statement to the viewer on the output they are watchi
   assert.equal(picture.viewers?.has("one") ?? false, false);
 });
 
-test("a reading decides nothing once it is older than the link it describes", () => {
+test("a link reading does not expire — presence is what decides whose it is", () => {
   const viewer = new Viewer("one", AT);
   viewer.report({ linkMbps: 8, bufferedAheadSec: 10, positionSeconds: 5, playing: true }, AT);
 
-  assert.equal(viewer.linkReading(AT)?.linkMbps, 8);
-  assert.equal(viewer.linkReading(AT + 29_000)?.linkMbps, 8);
-  assert.equal(viewer.linkReading(AT + 31_000), null);
-  // Nothing was deleted: the viewer is still here and still where they said.
+  // A link does not stop being what it was measured to be because nobody
+  // measured it for a while. The page says as much by keeping its own last
+  // figure rather than reporting nothing.
+  assert.equal(viewer.linkReading()?.linkMbps, 8);
+  assert.equal(viewer.linkReading()?.linkMbps, 8, "and an hour later it is still the last thing known");
+
+  // What ends it is the person leaving, which is a different fact with a
+  // different owner.
   assert.equal(viewer.isPresent(), true);
-  assert.equal(viewer.positionSeconds(AT + 31_000), 15);
+});
+
+test("the worst reading is taken across the people who are still here", async () => {
+  const { worstLinkReading } = await import("../services/viewer/link-readings.js");
+  const output = {};
+  const slow = new Viewer("slow", AT);
+  slow.outputs.add("out");
+  const fast = new Viewer("fast", AT);
+  fast.outputs.add("out");
+  output.viewers = new Map([
+    ["slow", slow],
+    ["fast", fast]
+  ]);
+  slow.report({ linkMbps: 2, bufferedAheadSec: 3, playing: true }, AT);
+  fast.report({ linkMbps: 40, bufferedAheadSec: 90, playing: true }, AT);
+
+  // The slowest link and the emptiest buffer, which may belong to two people.
+  const worst = worstLinkReading(output);
+  assert.equal(worst?.linkMbps, 2);
+  assert.equal(worst?.bufferedAheadSec, 3);
+  assert.equal(worst?.viewers, 2);
+
+  // The slow one leaves. Their reading goes with them, however recent it was.
+  slow.gone = true;
+  const left = worstLinkReading(output);
+  assert.equal(left?.linkMbps, 40);
+  assert.equal(left?.viewers, 1);
 });
 
 test("a report into a session that is gone is refused rather than invented", async () => {