@torrent-tv/proxy 2.83.8 → 2.85.0

package/services/viewer/Viewer.js

@@ -64,20 +64,30 @@ export class Viewer {
     /** A soundtrack being prepared for the same reason. @type {string | null} */
     this.warmingAudioId = null;
     /**
-     * Where they are.
+     * Where their picture stood when they last said so, and when they said it.
      *
-     * Set when they arrive, from the position their own request named, and
-     * moved by the segments they ask for and by the seeks they report. Never
-     * null for a viewer this process has met: "we do not know where they are"
-     * is not a state a viewer can be in, because a viewer arrives by asking for
+     * ONE FACT WITH ONE WRITER: the viewer. It is set when they arrive — from
+     * the position their own create request named — and moved only by what they
+     * state afterwards, a seek or a report carrying their playhead. Never null
+     * for a viewer this process has met, because a viewer arrives by asking for
      * a position.
      *
-     * `seeked` holds a position they STATED, for as long as they stay there,
-     * which is the distinction a cold open's soundtrack placement turns on: a
-     * request is evidence about where their player is reading, a seek is the
-     * viewer saying where they are.
+     * A REQUEST FOR A SEGMENT IS NOT A POSITION and never writes here. It says
+     * how far their buffer has reached, which is a different quantity and one
+     * nothing in the plan needs: a segment either exists and is served, or does
+     * not and is waited for.
      *
-     * @type {{ segment: number, seconds: number, at: number, seeked?: number | null } | null}
+     * Two writers is what this replaced, and the cost is measured. Until
+     * 2026-09-13 a seek wrote `seeked` while a request wrote `seconds`, and
+     * `positionSeconds` preferred whichever was set — so the two took turns and
+     * the priority map jumped back and forth by one or two segments several
+     * times a second. Field that day, one output over one second:
+     * `p100:#9..#10`, `p100:#18..#20`, `p100:#16..#18`, `p100:#18..#20`, with
+     * the second viewer stopped dead at 1673.6 s throughout. The encoder
+     * placement followed the map, as it must, and the machine spent six minutes
+     * on 77 starts and 141 stops against one normal end.
+     *
+     * @type {{ seconds: number, at: number } | null}
      */
     this.position = null;
     /**
@@ -139,13 +149,35 @@ export class Viewer {
      * @type {Set<string>}
      */
     this.wantsCuesFor = new Set();
-    // Whether the picture is moving. A viewer who has stopped it consumes
-    // nothing, so nothing in front of them ever becomes due — they have no
-    // deadline at all, and the work goes to whoever is watching. The page knows
-    // this exactly and says it outright; inferring it from a position that has
-    // not moved takes two reports and lies whenever a browser holding a full
-    // cushion goes quiet between segments, which it does.
-    this.playing = true;
+    // WHETHER THE PICTURE IS MOVING, and separately WHETHER THIS VIEWER IS
+    // BLOCKED ON US. Two booleans, because there are three states and one
+    // boolean cannot hold them:
+    //
+    //   playing        the picture advances, a second of film per second;
+    //   waiting        it does not advance because we have not delivered;
+    //   neither        the viewer stopped it themselves.
+    //
+    // Collapsed into one, the middle state read as the third: a viewer frozen
+    // for want of a segment counted as somebody who had chosen to stop, so
+    // nothing in front of them fell due and the work went to whoever was
+    // playing. That is backwards — a viewer waiting on us is the most urgent
+    // there is. The page tells the two apart exactly (its element says whether
+    // the picture advances, and the component owns the viewer's own pause) and
+    // states both.
+    //
+    // `playing` STARTS FALSE, and that is the whole of the fault of
+    // 2026-09-14. It used to start true, and the position is carried forward by
+    // the clock at that rate, so a viewer who had never said anything walked
+    // 146 seconds into a film they had not begun: the tab was hidden, the page
+    // deliberately held start-up until it was shown, and this end assumed the
+    // film was running the entire time. A statement about somebody else's
+    // machine is theirs to make. Until they make it the rate is zero.
+    //
+    // `waiting` STARTS TRUE, which is what a viewer arriving is: they have
+    // asked for a film and hold none of it. So their work is made first from
+    // the instant they arrive, without the position ever being invented.
+    this.playing = false;
+    this.waiting = true;
     // Whether the page carrying this viewer is ON SCREEN, and whether the
     // picture has been pulled out of it.
     //
@@ -161,7 +193,9 @@ export class Viewer {
     // before it could say otherwise.
     this.onScreen = true;
     this.inPictureInPicture = false;
-    // Seconds of film held ahead of the picture, as the page last said.
+    // Seconds of film held ahead of the picture, as the page last said. It is
+    // measured at the moment the position beside it was, which is what makes it
+    // the bound on carrying that position forward — see `positionSeconds`.
     this.bufferedSeconds = null;
   }
 
@@ -181,7 +215,14 @@ export class Viewer {
     if (!Number.isFinite(seconds) || seconds < 0) {
       return;
     }
-    this.position = { seconds, at: now, seeked: seconds };
+    this.position = { seconds, at: now };
+    // WHAT THEY HELD AT THE PLACE THEY LEFT SAYS NOTHING ABOUT THE PLACE THEY
+    // ARRIVED AT. A seek empties the buffer by construction — the player
+    // discards what it holds and fetches from the new position — so carrying
+    // the old cushion over would license the position to run forward again from
+    // material that no longer exists. Zero is the truthful floor until they say
+    // otherwise, and a viewer who has just seeked says so within a tick.
+    this.bufferedSeconds = 0;
     this.lastSeenAt = now;
   }
 
@@ -195,13 +236,18 @@ export class Viewer {
    * places, two of them on a session shared with other people.
    *
    * @param {object} report
-   * @param {number} report.linkMbps
+   * @param {number} [report.linkMbps] - What their link last measured. Absent
+   *   until something measurable has crossed it, and then the rest of the
+   *   report still stands: this is a statement about a viewer, not about a link.
    * @param {number} report.bufferedAheadSec
    * @param {number | null} [report.positionSeconds] - Null from a page that
    *   does not say; then the position stands as it was.
-   * @param {boolean} [report.playing] - Absent from a page that does not say;
-   *   then the viewer counts as playing, which is what every page meant before
-   *   it could say otherwise.
+   * @param {boolean} [report.playing] - Whether the picture is advancing.
+   *   Absent means it was not stated, and nothing may be assumed about somebody
+   *   else's machine: the rate is then zero.
+   * @param {boolean} [report.waiting] - Whether this viewer is blocked on
+   *   material we owe them. Absent from a page one release behind; then it is
+   *   derived from the two facts that page does state.
    * @param {boolean} [report.onScreen] - Whether the page is visible, or the
    *   picture is in picture-in-picture. Absent means on screen.
    * @param {boolean} [report.inPictureInPicture] - Whether the picture has been
@@ -214,87 +260,94 @@ export class Viewer {
       bufferedAheadSec,
       positionSeconds = null,
       playing,
+      waiting,
       onScreen,
       inPictureInPicture
     },
     now = Date.now()
   ) {
-    this.netReport = {
-      linkMbps,
-      bufferedAheadSec,
-      positionSeconds:
-        Number.isFinite(positionSeconds) && positionSeconds >= 0 ? positionSeconds : null,
-      at: now
-    };
-    this.bufferedSeconds = bufferedAheadSec;
-    this.playing = playing === undefined ? true : Boolean(playing);
-    this.inPictureInPicture = inPictureInPicture === undefined ? false : Boolean(inPictureInPicture);
-    this.onScreen = onScreen === undefined ? true : Boolean(onScreen);
+    const held = Number.isFinite(bufferedAheadSec) && bufferedAheadSec > 0 ? bufferedAheadSec : 0;
+    // A LINK FIGURE IS ONE FIELD OF THIS REPORT AND NOT ITS TICKET. A page that
+    // has transferred nothing measurable has nothing to say about its link and
+    // everything to say about its viewer, and that is the cold open exactly —
+    // the moment the position matters most. Held as a precondition, in three
+    // places at once, it silenced every statement of the session of 2026-09-14.
+    if (Number.isFinite(linkMbps) && linkMbps > 0) {
+      this.netReport = {
+        linkMbps,
+        bufferedAheadSec: held,
+        positionSeconds:
+          Number.isFinite(positionSeconds) && positionSeconds >= 0 ? positionSeconds : null,
+        at: now
+      };
+    }
+    // The position first, then the cushion: `moveTo` clears what was held at
+    // wherever they were before, and this report's own figure is measured at
+    // the position this report states.
     if (Number.isFinite(positionSeconds) && positionSeconds >= 0) {
       this.moveTo(/** @type {number} */ (positionSeconds), now);
     }
+    this.bufferedSeconds = held;
+    this.playing = playing === true;
+    // A page that states `playing` and not `waiting` is one release behind this
+    // proxy, which is the ordinary state of a rolling pool — the proxy ships
+    // first by rule. It says `false` for both a viewer who stopped the picture
+    // and a viewer starved of material, so the two are told apart by the one
+    // quantity it does state: a stopped viewer holding film chose to stop, a
+    // stopped viewer holding nothing is waiting on us. It errs toward making
+    // material, which is the direction that costs an encoder rather than a
+    // viewer.
+    this.waiting = waiting === undefined ? this.playing === false && held === 0 : waiting === true;
+    this.inPictureInPicture = inPictureInPicture === undefined ? false : Boolean(inPictureInPicture);
+    this.onScreen = onScreen === undefined ? true : Boolean(onScreen);
     this.seen(now);
   }
 
   /**
-   * When this viewer runs out of what they hold, in milliseconds.
-   *
-   * Film is consumed at one second per second while the picture moves, so the
-   * moment they run dry is now plus what they hold. Stopped, they consume
-   * nothing and there is no such moment — which is why a pause needs no rule of
-   * its own anywhere: it falls out of this as an absent deadline.
-   *
-   * @param {number} [now]
-   * @returns {number | null}
-   */
-  deadlineAt(now = Date.now()) {
-    if (!this.playing) {
-      return null;
-    }
-    const held = Number.isFinite(this.bufferedSeconds) ? Math.max(0, this.bufferedSeconds) : 0;
-    return now + held * 1000;
-  }
-
-  /**
-   * Whether this viewer is still watching.
+   * Whether this viewer is here.
    *
-   * Two ways to stop being present, and neither of them is "asked for nothing
-   * recently". Something must have SAID they are gone, or nothing at all must
-   * have been heard from them for longer than any silence a watching viewer can
-   * produce.
+   * PRESENCE IS THE CONNECTION, AND ONLY THE CONNECTION. They are here from the
+   * moment they are known until something SAYS they are gone: the browser
+   * releasing the session, or their connection closing. Nothing else, and in
+   * particular not silence.
    *
-   * The second half exists only because the connection cannot always say: an
-   * `onClosed` on a data channel does not always come, and a transport that is
-   * not a data channel at all may have nothing to say. It is a backstop for a
-   * missing statement, not the ordinary way a viewer leaves.
+   * Silence used to end it, after an interval longer than "any silence a
+   * watching viewer can produce" — and there is no such interval. A viewer who
+   * has paused, whose tab is hidden and whose timers the browser has throttled,
+   * or who holds two minutes of cushion, all say nothing for as long as they
+   * like and are all still watching. Deciding presence from that made it a
+   * guess with a threshold; deciding it from the connection makes it a fact
+   * with an owner.
    *
-   * @param {number} now
-   * @param {number} staleAfterMs - Longer than any silence a watching viewer
-   *   can produce. Derived from the cushion, never chosen here.
    * @returns {boolean}
    */
   /**
-   * Whether this viewer is CONSUMING film.
+   * Whether this viewer wants film NOW — either watching it or waiting for it.
    *
-   * Two ways of not consuming, and neither is absence: the picture is stopped,
-   * or the page is not on screen. Both mean nothing in front of them ever falls
-   * due, so the work goes to whoever is watching — and both leave them a place
-   * in the priority map, because they are still there and will want it again.
+   * The one predicate every reading about urgency asks, and it is a union of
+   * two states rather than the negation of a pause:
    *
+   *   playing        consuming, and will run dry when their cushion does;
+   *   waiting        consuming nothing only because we have delivered nothing;
+   *   neither        they stopped the picture themselves.
+   *
+   * A viewer who has stopped it keeps their place in the priority map — they
+   * are still there and will want the film in front of them again — but nothing
+   * of theirs falls due, so the work goes to whoever is watching or waiting.
+   *
+   * A page that is not on screen is not consuming: its timers are throttled and
+   * it asks for nothing, which is indistinguishable from a full cushion.
    * Picture-in-picture is watching with the tab hidden, and the page folds that
-   * into `onScreen` before it says it, so it needs no case of its own here.
+   * into `onScreen` before saying it, so it needs no case of its own here.
    *
    * @returns {boolean}
    */
-  consumesFilm() {
-    return this.playing !== false && this.onScreen !== false;
+  wantsFilmNow() {
+    return (this.playing === true || this.waiting === true) && this.onScreen !== false;
   }
 
-  isPresent(now, staleAfterMs) {
-    if (this.gone) {
-      return false;
-    }
-    return now - this.lastSeenAt <= staleAfterMs;
+  isPresent() {
+    return this.gone !== true;
   }
 
   /**
@@ -308,16 +361,59 @@ export class Viewer {
   }
 
   /**
-   * Where this viewer is, in seconds, or null when they have somehow never been
-   * placed — which for a viewer created through `Viewers.of` cannot happen.
+   * Where this viewer is NOW, in seconds of film.
+   *
+   * A FUNCTION OF TIME, not a stored number. A viewer whose picture is moving
+   * covers a second of film every second, so between the moments they speak
+   * their position is known exactly — it is where they last were plus the time
+   * since. A viewer whose picture is stopped covers nothing and stays where
+   * they are, which is the same formula with the rate at zero.
    *
-   * @returns {number | null}
+   *   position(now) = stated + rate * min(now - statedAt, held),
+   *                                              rate = playing ? 1 : 0
+   *
+   * **THE SECOND TERM IS BOUNDED BY WHAT THEY HELD**, and the bound is stated
+   * by the viewer rather than chosen here: nobody can play past the end of what
+   * they have. A viewer who said "I hold thirty seconds" and has said nothing
+   * for two minutes has played at most thirty of those seconds; the rest of the
+   * silence is a viewer who ran dry, or one we are no longer hearing from, and
+   * in both cases they are not where the clock alone would put them.
+   *
+   * Unbounded, it walks a viewer off the end of a film they never started. On
+   * 2026-09-14 the tab was hidden for 145 seconds while the page deliberately
+   * held start-up until it was shown, the rate was assumed to be one, and this
+   * end placed the viewer at 145.979 s — the exact `-ss` the soundtrack's
+   * encoder was given, while the browser was asking for segment #0 and getting
+   * 503 for sixty seconds. Their cushion was 0.0 s throughout, so this bound
+   * alone would have held them at zero whatever the rate said.
+   *
+   * The bound binds only where the clock has outrun the cushion — a report lost,
+   * or a viewer starving — and there it under-states the position. That is the
+   * safe direction and deliberately so: under-stating makes material a viewer
+   * has already passed, which costs an encoder; over-stating skips material
+   * they are about to need, which costs the viewer the picture.
+   *
+   * Held as a stored number instead, it was a staircase: flat for the ten
+   * seconds between reports and then a jump, so everything derived from it —
+   * the priority map, and through the map every encoder — changed in steps for
+   * a viewer who was moving smoothly. And because two writers were filling that
+   * number in turn, the steps went backwards as often as forwards.
+   *
+   * There is nothing to tune here and no state to keep: one reading, one clock,
+   * one rate the page itself states.
+   *
+   * @param {number} [now]
+   * @returns {number | null} Null only for a viewer never placed, which for one
+   *   created through `Viewers.of` cannot happen.
    */
-  positionSeconds() {
+  positionSeconds(now = Date.now()) {
     if (this.position === null) {
       return null;
     }
-    return Number.isFinite(this.position.seeked) ? this.position.seeked : this.position.seconds;
+    const rate = this.playing === true ? 1 : 0;
+    const elapsedSec = Math.max(0, (now - this.position.at) / 1000);
+    const held = Number.isFinite(this.bufferedSeconds) ? Math.max(0, this.bufferedSeconds) : 0;
+    return this.position.seconds + rate * Math.min(elapsedSec, held);
   }
 }
 

package/services/viewer/positions.js

@@ -1,48 +1,120 @@
-/**
- * @file Where the viewers of one output stand.
- *
- * Asked by whatever has to give disk back: what lies behind every viewer has
- * been played and will not be wanted again unless somebody seeks back, and what
- * lies ahead of the furthest will be wanted eventually. So an answer of "nobody"
- * is the strongest statement there is — everything that output holds is worth
- * less than anything anybody is on their way to.
- *
- * Pure: it is handed the sessions, the clock and a way to turn seconds into a
- * segment number, and it holds none of them.
- */
-
-import { viewersOf } from "./Viewer.js";
-
-/**
- * @param {object} params
- * @param {Iterable<{ outputKey?: string }>} params.sessions - Every live session.
- * @param {string} params.outputKey - The output being asked about.
- * @param {(session: object, seconds: number) => number} params.segmentAt - Which
- *   segment of THAT session's timeline a moment of film falls in.
- * @param {number} params.now
- * @param {number} params.staleAfterMs - Silence longer than any a watching
- *   viewer can produce.
- * @returns {number[]} A segment number per present viewer, unsorted.
- */
-export function viewerSegmentsOn({ sessions, outputKey, segmentAt, now, staleAfterMs }) {
-  const at = [];
-  for (const session of sessions) {
-    if (session.outputKey !== outputKey) {
-      continue;
-    }
-    for (const viewer of viewersOf(session).values()) {
-      if (!viewer.isPresent(now, staleAfterMs)) {
-        continue;
-      }
-      const seconds = viewer.positionSeconds();
-      if (!Number.isFinite(seconds)) {
-        continue;
-      }
-      const index = segmentAt(session, /** @type {number} */ (seconds));
-      if (Number.isInteger(index) && index >= 0) {
-        at.push(index);
-      }
-    }
-  }
-  return at;
-}
+/**
+ * @file Where the viewers of one output stand.
+ *
+ * Asked by whatever has to give disk back: what lies behind every viewer has
+ * been played and will not be wanted again unless somebody seeks back, and what
+ * lies ahead of the furthest will be wanted eventually. So an answer of "nobody"
+ * is the strongest statement there is — everything that output holds is worth
+ * less than anything anybody is on their way to.
+ *
+ * Pure: it is handed the sessions, the clock and a way to turn seconds into a
+ * segment number, and it holds none of them.
+ */
+
+import { viewersOf } from "./Viewer.js";
+
+/**
+ * @param {object} params
+ * @param {Iterable<{ outputKey?: string }>} params.sessions - Every live session.
+ * @param {string} params.outputKey - The output being asked about.
+ * @param {(session: object, seconds: number) => number} params.segmentAt - Which
+ *   segment of THAT session's timeline a moment of film falls in.
+ * @param {number} params.now
+ * @returns {number[]} A segment number per present viewer, unsorted.
+ */
+export function viewerSegmentsOn({ sessions, outputKey, segmentAt, now }) {
+  const at = [];
+  for (const session of sessions) {
+    if (session.outputKey !== outputKey) {
+      continue;
+    }
+    for (const viewer of viewersOf(session).values()) {
+      if (!viewer.isPresent()) {
+        continue;
+      }
+      const seconds = viewer.positionSeconds(now);
+      if (!Number.isFinite(seconds)) {
+        continue;
+      }
+      const index = segmentAt(session, /** @type {number} */ (seconds));
+      if (Number.isInteger(index) && index >= 0) {
+        at.push(index);
+      }
+    }
+  }
+  return at;
+}
+
+/**
+ * Where a viewer of one output is, in seconds of film, NOW.
+ *
+ * One reading with one owner, and a function of time rather than a stored
+ * number: a viewer states where their picture is, and the clock carries it
+ * forward between statements.
+ *
+ * Three readings ranked by priority used to answer this — a seek, the start of
+ * the last segment requested, the position the output was opened at — with a
+ * second function saying which had answered. They were three different
+ * quantities wearing one name, two of them written at different rates, so the
+ * answer alternated between them several times a second and every encoder
+ * followed it.
+ *
+ * Without a name, the FURTHEST viewer: what lies behind them has already been
+ * made, so that is what a reading about no particular person wants. With
+ * nobody present at all, where the output was opened.
+ *
+ * @param {object} session
+ * @param {string} [consumerId] - Whose position.
+ * @param {number} [now]
+ * @returns {number} Seconds, never negative.
+ */
+export function viewerSecondsOn(session, consumerId = "", now = Date.now()) {
+  const named = consumerId ? session?.viewers?.get(consumerId) ?? null : null;
+  if (named) {
+    return Math.max(0, named.positionSeconds(now) ?? 0);
+  }
+  let furthest = null;
+  for (const viewer of viewersOf(session).values()) {
+    if (!viewer.isPresent()) {
+      continue;
+    }
+    const seconds = viewer.positionSeconds(now);
+    if (Number.isFinite(seconds)) {
+      furthest = furthest === null ? seconds : Math.max(furthest, seconds);
+    }
+  }
+  const opened = Number(session?.progress?.startPositionSeconds);
+  return Math.max(0, furthest ?? (Number.isFinite(opened) ? opened : 0));
+}
+
+/**
+ * The earliest film anybody present is standing on, across several outputs.
+ *
+ * WHAT IT IS FOR: a soundtrack is created at a position, and a track begun
+ * where the leader stands has nothing to give the viewer behind them. So the
+ * earliest, and across every rung of the picture, because two viewers of one
+ * film may be on different ones.
+ *
+ * This is a fact about PEOPLE and it decides one parameter of an output. It
+ * does not place encoders: which encoder works where is the priority map's
+ * answer and nothing here is consulted for it.
+ *
+ * @param {Iterable<object>} sessions
+ * @param {number} [now]
+ * @returns {number | null} Seconds, or null when nobody is present.
+ */
+export function earliestViewerSecondsOn(sessions, now = Date.now()) {
+  let earliest = null;
+  for (const session of sessions ?? []) {
+    for (const viewer of viewersOf(session).values()) {
+      if (!viewer.isPresent()) {
+        continue;
+      }
+      const seconds = viewer.positionSeconds(now);
+      if (Number.isFinite(seconds)) {
+        earliest = earliest === null ? seconds : Math.min(earliest, seconds);
+      }
+    }
+  }
+  return earliest;
+}

package/services/viewer/report-intake.js

@@ -0,0 +1,63 @@
+/**
+ * @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;
+    }
+  }
+}

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

@@ -17,6 +17,7 @@ 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";
+import { viewerOf } from "../services/viewer/Viewer.js";
 
 const SESSION_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
 const SEGMENT_SECONDS = 4;
@@ -32,7 +33,7 @@ async function managerWithSession() {
     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
@@ -44,10 +45,12 @@ async function managerWithSession() {
     state: "ready",
     segmentFormat: fmp4Format,
     segmentCount: 200,
-    useSyntheticPlaylist: true,
-    // The viewer is at segment #25.
-    furthestViewerSeconds: 100
-  });
+    useSyntheticPlaylist: true
+  };
+  manager.sessionsById.set(SESSION_ID, session);
+  // The viewer is at segment #25, and says so themselves.
+  viewerOf(session, "").moveTo(25 * SEGMENT_SECONDS);
+  viewerOf(session, "").playing = false;
   return { manager, dirPath };
 }