@torrent-tv/proxy 2.88.2 → 2.88.4

package/services/viewer/active-output.js

@@ -1,37 +1,37 @@
-/**
- * @file Which output a viewer has on screen.
- *
- * The browser addresses the picture output for the whole film. After a quality
- * change, the viewer's record identifies the selected output. Keeping this per
- * viewer prevents one viewer's quality change from changing another viewer's
- * selection.
- *
- * A request that names nobody has the picture itself on screen. This module
- * stores no output, viewer or encoder state.
- */
-
-/**
- * @param {object} params
- * @param {object} params.base - The picture output.
- * @param {string} [params.consumerId] - Whose screen. Empty names nobody, and
- *   the answer is the picture.
- * @param {{ get: (id: string) => object | undefined }} params.outputs - Every live output, by id.
- * @param {{ getForOutput: (output: object, consumerId: string) => object | null }} params.viewers
- * @returns {object} A live output, never a disposed one.
- */
-export function activeOutputFor({ base, consumerId = "", outputs, viewers }) {
-  const viewer = viewers.getForOutput(base, consumerId);
-  const activeId = viewer?.activeVariantId ?? null;
-  if (!activeId || activeId === base.id) {
-    return base;
-  }
-  const active = outputs.get(activeId);
-  if (!active) {
-    // The rung is gone, so the viewer is watching the picture again.
-    if (viewer) {
-      viewer.activeVariantId = null;
-    }
-    return base;
-  }
-  return active;
-}
+/**
+ * @file Which output a viewer has on screen.
+ *
+ * The browser addresses the picture output for the whole film. After a quality
+ * change, the viewer's record identifies the selected output. Keeping this per
+ * viewer prevents one viewer's quality change from changing another viewer's
+ * selection.
+ *
+ * A request that names nobody has the picture itself on screen. This module
+ * stores no output, viewer or encoder state.
+ */
+
+/**
+ * @param {object} params
+ * @param {object} params.base - The picture output.
+ * @param {string} [params.consumerId] - Whose screen. Empty names nobody, and
+ *   the answer is the picture.
+ * @param {{ get: (id: string) => object | undefined }} params.outputs - Every live output, by id.
+ * @param {{ getForOutput: (output: object, consumerId: string) => object | null }} params.viewers
+ * @returns {object} A live output, never a disposed one.
+ */
+export function activeOutputFor({ base, consumerId = "", outputs, viewers }) {
+  const viewer = viewers.getForOutput(base, consumerId);
+  const activeId = viewer?.activeVariantId ?? null;
+  if (!activeId || activeId === base.id) {
+    return base;
+  }
+  const active = outputs.get(activeId);
+  if (!active) {
+    // The rung is gone, so the viewer is watching the picture again.
+    if (viewer) {
+      viewer.activeVariantId = null;
+    }
+    return base;
+  }
+  return active;
+}

package/services/viewer/audio-start.js

@@ -1,46 +1,46 @@
-/**
- * @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, the viewer registry, 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.
- * @param {{ forOutput: (output: object) => Map<string, object> }} params.viewers - The registry.
- * @returns {number} Seconds, never negative.
- */
-export function audioStartSecondsFor({ family, openedAtSeconds, segmentSeconds, viewers }) {
-  const earliest = earliestViewerSecondsOn(viewers, family, Date.now());
-  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);
-}
+/**
+ * @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, the viewer registry, 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.
+ * @param {{ forOutput: (output: object) => Map<string, object> }} params.viewers - The registry.
+ * @returns {number} Seconds, never negative.
+ */
+export function audioStartSecondsFor({ family, openedAtSeconds, segmentSeconds, viewers }) {
+  const earliest = earliestViewerSecondsOn(viewers, family, Date.now());
+  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/buffer-trend.js

@@ -1,81 +1,81 @@
-/**
- * @file Which way a viewer's buffer is going, from what their page said about
- * it (roadmap item 98).
- *
- * The buffer does not move smoothly: it rises a whole segment at a time when a
- * segment arrives and falls a second per second while the picture plays. So one
- * reading against the next says nothing — it catches either the rise or the
- * fall. The trend is taken over the SHORTEST run of recent readings that spans
- * at least one segment's duration, which is the period of that rise and fall,
- * and fitted by least squares. Nothing here is chosen: the span is the segment
- * duration of the output the viewer watches, and the caller supplies it.
- *
- * Fewer than two readings, or readings that do not yet span one segment, say
- * nothing, and the answer is null.
- */
-
-/**
- * @typedef {{ at: number, seconds: number }} BufferReading - When the page said
- *   it (ms) and the seconds of film it held.
- */
-
-/**
- * The index of the oldest reading of the shortest run, ending at the newest,
- * whose time span is at least `spanSec`; -1 when no run spans it.
- *
- * @param {BufferReading[]} readings - Oldest first.
- * @param {number} spanSec
- * @returns {number}
- */
-export function trendRunStart(readings, spanSec) {
-  if (!Array.isArray(readings) || readings.length < 2 || !(spanSec > 0)) {
-    return -1;
-  }
-  const newest = readings[readings.length - 1].at;
-  for (let index = readings.length - 2; index >= 0; index -= 1) {
-    if ((newest - readings[index].at) / 1000 >= spanSec) {
-      return index;
-    }
-  }
-  return -1;
-}
-
-/**
- * The buffer's trend in seconds of film per second of time — negative while it
- * is draining — and the interval between the viewer's last two reports, which
- * is how long it will be before this viewer is heard from again.
- *
- * @param {BufferReading[]} readings - Oldest first.
- * @param {number} spanSec - The segment duration of the output they watch.
- * @returns {{ slope: number, reportGapSec: number } | null}
- */
-export function bufferTrend(readings, spanSec) {
-  const start = trendRunStart(readings, spanSec);
-  if (start < 0) {
-    return null;
-  }
-  const run = readings.slice(start);
-  const origin = run[0].at;
-  const count = run.length;
-  let sumT = 0;
-  let sumB = 0;
-  for (const reading of run) {
-    sumT += (reading.at - origin) / 1000;
-    sumB += reading.seconds;
-  }
-  const meanT = sumT / count;
-  const meanB = sumB / count;
-  let numerator = 0;
-  let denominator = 0;
-  for (const reading of run) {
-    const t = (reading.at - origin) / 1000 - meanT;
-    numerator += t * (reading.seconds - meanB);
-    denominator += t * t;
-  }
-  if (!(denominator > 0)) {
-    return null;
-  }
-  const last = readings[readings.length - 1].at;
-  const beforeLast = readings[readings.length - 2].at;
-  return { slope: numerator / denominator, reportGapSec: Math.max(0, (last - beforeLast) / 1000) };
-}
+/**
+ * @file Which way a viewer's buffer is going, from what their page said about
+ * it (roadmap item 98).
+ *
+ * The buffer does not move smoothly: it rises a whole segment at a time when a
+ * segment arrives and falls a second per second while the picture plays. So one
+ * reading against the next says nothing — it catches either the rise or the
+ * fall. The trend is taken over the SHORTEST run of recent readings that spans
+ * at least one segment's duration, which is the period of that rise and fall,
+ * and fitted by least squares. Nothing here is chosen: the span is the segment
+ * duration of the output the viewer watches, and the caller supplies it.
+ *
+ * Fewer than two readings, or readings that do not yet span one segment, say
+ * nothing, and the answer is null.
+ */
+
+/**
+ * @typedef {{ at: number, seconds: number }} BufferReading - When the page said
+ *   it (ms) and the seconds of film it held.
+ */
+
+/**
+ * The index of the oldest reading of the shortest run, ending at the newest,
+ * whose time span is at least `spanSec`; -1 when no run spans it.
+ *
+ * @param {BufferReading[]} readings - Oldest first.
+ * @param {number} spanSec
+ * @returns {number}
+ */
+export function trendRunStart(readings, spanSec) {
+  if (!Array.isArray(readings) || readings.length < 2 || !(spanSec > 0)) {
+    return -1;
+  }
+  const newest = readings[readings.length - 1].at;
+  for (let index = readings.length - 2; index >= 0; index -= 1) {
+    if ((newest - readings[index].at) / 1000 >= spanSec) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+/**
+ * The buffer's trend in seconds of film per second of time — negative while it
+ * is draining — and the interval between the viewer's last two reports, which
+ * is how long it will be before this viewer is heard from again.
+ *
+ * @param {BufferReading[]} readings - Oldest first.
+ * @param {number} spanSec - The segment duration of the output they watch.
+ * @returns {{ slope: number, reportGapSec: number } | null}
+ */
+export function bufferTrend(readings, spanSec) {
+  const start = trendRunStart(readings, spanSec);
+  if (start < 0) {
+    return null;
+  }
+  const run = readings.slice(start);
+  const origin = run[0].at;
+  const count = run.length;
+  let sumT = 0;
+  let sumB = 0;
+  for (const reading of run) {
+    sumT += (reading.at - origin) / 1000;
+    sumB += reading.seconds;
+  }
+  const meanT = sumT / count;
+  const meanB = sumB / count;
+  let numerator = 0;
+  let denominator = 0;
+  for (const reading of run) {
+    const t = (reading.at - origin) / 1000 - meanT;
+    numerator += t * (reading.seconds - meanB);
+    denominator += t * t;
+  }
+  if (!(denominator > 0)) {
+    return null;
+  }
+  const last = readings[readings.length - 1].at;
+  const beforeLast = readings[readings.length - 2].at;
+  return { slope: numerator / denominator, reportGapSec: Math.max(0, (last - beforeLast) / 1000) };
+}