@torrent-tv/proxy 2.80.14 → 2.80.16

package/services/encode/run-costs.js

@@ -53,9 +53,22 @@ export class RunCosts {
    * that was never told to stop did not die on command, and one that produced
    * nothing has no first output — and an absent reading is not a zero.
    *
-   * @param {{ dyingMs?: number | null, firstOutputMs?: number | null }} ended
+   * @param {{ dyingMs?: number | null, firstOutputMs?: number | null,
+   *   livedMs?: number | null }} ended - `livedMs` is how long a run that
+   *   produced NOTHING was alive, which is a lower bound on the first output.
    */
   note(ended) {
+    // A RUN THAT PRODUCED NOTHING IS A MEASUREMENT TOO — of a lower bound. It
+    // says the first output takes at least as long as this run lived, which is
+    // a fact and not an estimate, and it is the only reading a thrash can
+    // supply: every run in one is killed before it finishes anything.
+    //
+    // Without it the figure that prices a move could only ever be learned from
+    // runs that survived, so the state in which moves are ruinous was exactly
+    // the state in which their cost stayed unknown.
+    if (!Number.isFinite(ended?.firstOutputMs) && Number.isFinite(ended?.livedMs) && ended.livedMs > 0) {
+      RunCosts.#keep(this.#firstOutput, /** @type {number} */ (ended.livedMs));
+    }
     if (Number.isFinite(ended?.dyingMs)) {
       RunCosts.#keep(this.#dying, /** @type {number} */ (ended.dyingMs));
     }
@@ -85,9 +98,47 @@ export class RunCosts {
    * @returns {{ killCostSec: number, firstByteWaitSec: number, samples: number }}
    */
   seconds() {
+    const dying = middleOf(this.#dying);
+    const first = middleOf(this.#firstOutput);
     return {
-      killCostSec: (middleOf(this.#dying) ?? 0) / 1000,
-      firstByteWaitSec: (middleOf(this.#firstOutput) ?? 0) / 1000,
+      // UNKNOWN IS NOT ZERO, and for a cost it is not a small number either: it
+      // is the figure that makes the act it prices never worth doing. Reported
+      // as 0, an unmeasured move was FREE in the plan's arithmetic, so any gain
+      // however small justified it — and moving an encoder is irreversible,
+      // because the process it kills cannot be un-killed.
+      //
+      // The blindness was self-sustaining: `#firstOutput` only takes a reading
+      // from a run that produced something, and a run killed 0.8 s after
+      // starting produces nothing. So a thrash prevented the measurement that
+      // would have stopped it. Field 2026-09-08: 39 moves in one session, 24 of
+      // them between three adjacent numbers — #58 to #59, #59 to #58, #58 to
+      // #60, #60 to #58, six times each — while the picture stood still for
+      // 116.7 s.
+      //
+      // TWO QUESTIONS, NOT ONE, and they take the unknown differently.
+      //
+      // PLACING an encoder where there is none has no alternative: the film gets
+      // made or it does not. So an unmeasured cost must not stand in the way,
+      // and the honest figure is what has been measured or nothing.
+      //
+      // MOVING one has an alternative — leave it alone — and it is
+      // irreversible, because the process it kills cannot be un-killed. There
+      // an unmeasured cost must not license the act, and `Infinity` is the
+      // identity of the comparison that consumes it: "nobody has measured what
+      // this costs" and "never worth doing" are the same statement about an
+      // action whose price is unknown.
+      //
+      // Reported as 0 for both, an unmeasured move was FREE in the plan's
+      // arithmetic, so a gain of a fraction of a second justified it. And the
+      // blindness was self-sustaining: `#firstOutput` takes a reading only from
+      // a run that produced something, and every run in a thrash is killed
+      // before it finishes anything.
+      killCostSec: (dying ?? 0) / 1000,
+      firstByteWaitSec: (first ?? 0) / 1000,
+      moveCostSec:
+        first === null
+          ? Number.POSITIVE_INFINITY
+          : ((dying ?? 0) + first) / 1000,
       samples: Math.min(this.#dying.length, this.#firstOutput.length)
     };
   }

package/services/hls-session-manager.js

@@ -1510,7 +1510,11 @@ export class HlsSessionManager {
     // picture a step belongs to, the steps, the soundtracks, the height a
     // session is named by. Read-only over the register above, and the layer the
     // quality budget and the serving path both stand on.
-    this.liveOutputs = new LiveOutputs({ sessionsById: this.sessionsById });
+    this.liveOutputs = new LiveOutputs({
+      sessionsById: this.sessionsById,
+      fileLengthOf: (session) => this.#fileLengthByKey.get(session.file.key) ?? 0,
+      largestPieceOf: (address) => this.segmentStore.largestPiece(address)
+    });
     // What this host learned last time it ran. Without it every restart shows
     // the first viewer a figure with no measurement behind it.
     this.#loadHostTimings();
@@ -8317,7 +8321,7 @@ export class HlsSessionManager {
       // the live judgement travels in `offeredHeights` and in every progress
       // report, and letting it decide the master's existence made a live session
       // answer 404 to its own published address.
-      ...this.liveOutputs.masterFactsOf(session, (address) => this.segmentStore.largestPiece(address)),
+      ...this.liveOutputs.masterFactsOf(session),
       renditions,
       playlistFileName: PLAYLIST_FILE_NAME
     });

package/services/output/LiveOutputs.js

@@ -24,8 +24,14 @@ export class LiveOutputs {
    * @param {Map<string, object>} params.sessionsById - The live sessions. Read,
    *   never written.
    */
-  constructor({ sessionsById }) {
+  constructor({ sessionsById, fileLengthOf = () => 0, largestPieceOf = () => ({ index: -1, size: 0 }) }) {
     this.sessionsById = sessionsById;
+    // Two facts this layer needs and does not own: how many bytes a source file
+    // is, which the torrent reports, and the biggest piece an output has made,
+    // which the disk knows. Taken as plain functions, so nothing of either layer
+    // is held here.
+    this.fileLengthOf = fileLengthOf;
+    this.largestPieceOf = largestPieceOf;
   }
 
   /**
@@ -278,21 +284,25 @@ export class LiveOutputs {
    * the asking VIEWER'S business, and that belongs to whoever holds viewers.
    *
    * @param {object} session
-   * @param {(address: string) => { index: number, size: number }} largestPiece -
-   *   The biggest piece an output has made, asked of whoever owns the disk. A
-   *   plain function, so this layer holds no store.
    * @returns {object}
    */
-  masterFactsOf(session, largestPiece) {
+  masterFactsOf(session) {
     return {
       playlistVersion: session.segmentFormat.playlistVersion,
       heights: this.splicableHeights(session),
       sourceWidth: Number(session.file?.width) || 0,
       sourceHeight: Number(session.file?.height) || 0,
       ...masterRateArgs({
-        fileLength: Number(session.file?.length) || 0,
+        // FROM WHOEVER KNOWS IT. A source file does not carry its own byte
+        // length — the torrent reports it — and reading a field that does not
+        // exist is what declared every variant at the floor in 2.80.14.
+        fileLength: Number(this.fileLengthOf(session)) || 0,
         durationSeconds: Number(session.file?.durationSeconds) || 0,
-        largest: largestPiece(session.outputKey ?? ""),
+        // The probe's own reading of the video stream, which is known from the
+        // moment the session exists and covers the gap before the torrent has
+        // reported a length.
+        streamBitsPerSecond: (Number(session.file?.decode?.megabitsPerSecond) || 0) * 1_000_000,
+        largest: this.largestPieceOf(session.outputKey ?? ""),
         boundaries: session.timeline?.published ?? session.timeline?.boundaries ?? null,
         producedHeight: this.producedHeightOf(session),
         capKbps: Number(session.rateCapKbps) || 0

package/services/output/rates.js

@@ -21,21 +21,49 @@
  * The two rates to declare, from what has been measured of this file.
  *
  * @param {object} params
- * @param {number} params.fileLength - Bytes of the source file.
+ * @param {number} params.fileLength - Bytes of the source file, 0 until the
+ *   torrent has said. Counts every track and every byte of container, so it is
+ *   the better figure of the two.
  * @param {number} params.durationSeconds
+ * @param {number} [params.streamBitsPerSecond] - What a probe read off the
+ *   video stream, known from session creation. Lower than the whole file's rate
+ *   because it is one track of it, and used while the length is not known.
  * @param {{ index: number, size: number }} [params.largest] - The biggest piece
  *   produced so far, with its number. An index of `-1` means none yet.
  * @param {number[]} [params.boundaries] - Where the file is cut, so the biggest
  *   piece's own span is known. Bytes alone cannot give a rate.
  * @returns {{ averageBitsPerSecond: number, peakOverAverage: number }}
  */
-export function declaredRates({ fileLength, durationSeconds, largest = null, boundaries = null }) {
+export function declaredRates({
+  fileLength,
+  durationSeconds,
+  streamBitsPerSecond = 0,
+  largest = null,
+  boundaries = null
+}) {
   const length = Number(fileLength);
   const duration = Number(durationSeconds);
-  if (!(length > 0) || !(duration > 0)) {
+  // TWO SOURCES, AND THE LARGER OF THEM, because each is measured and each can
+  // be absent — and absent is 0, so the larger is whichever was measured.
+  //
+  //  - the whole file's length over its duration: the best figure, since it
+  //    counts every track and every byte of container. Known only once the
+  //    torrent has reported the file's size;
+  //  - what the probe read off the video stream: known when the session is
+  //    created, and lower, because it is one track of several.
+  //
+  // The first alone was what shipped in 2.80.14, read from a field that does
+  // not exist on a source file. It came back 0 on every session, so every
+  // variant was declared at the 400 kbit/s floor — nine times WORSE than the
+  // rule of thumb it replaced — and the browser, which sizes its cushion in
+  // bytes from this figure, held 0.1 s of film against 120 s asked. The picture
+  // stood still for 116.7 s of one viewing. Assuming a field instead of
+  // checking it is the whole of that fault.
+  const fromLength = length > 0 && duration > 0 ? (length * 8) / duration : 0;
+  const averageBitsPerSecond = Math.max(fromLength, Number(streamBitsPerSecond) || 0);
+  if (!(averageBitsPerSecond > 0)) {
     return { averageBitsPerSecond: 0, peakOverAverage: 1 };
   }
-  const averageBitsPerSecond = (length * 8) / duration;
   const index = Number(largest?.index);
   const size = Number(largest?.size);
   if (!Number.isInteger(index) || index < 0 || !(size > 0) || !Array.isArray(boundaries)) {
@@ -73,6 +101,7 @@ export function declaredRates({ fileLength, durationSeconds, largest = null, bou
  * @param {object} params
  * @param {number} params.fileLength
  * @param {number} params.durationSeconds
+ * @param {number} [params.streamBitsPerSecond]
  * @param {{ index: number, size: number } | null} [params.largest]
  * @param {number[] | null} [params.boundaries]
  * @param {number} [params.producedHeight] - The height this output encodes at.
@@ -83,13 +112,14 @@ export function declaredRates({ fileLength, durationSeconds, largest = null, bou
 export function masterRateArgs({
   fileLength,
   durationSeconds,
+  streamBitsPerSecond = 0,
   largest = null,
   boundaries = null,
   producedHeight = 0,
   capKbps = 0
 }) {
   return {
-    ...declaredRates({ fileLength, durationSeconds, largest, boundaries }),
+    ...declaredRates({ fileLength, durationSeconds, streamBitsPerSecond, largest, boundaries }),
     capKbpsFor: (height) => (height === producedHeight ? capKbps : 0)
   };
 }

package/test/encode-plan.test.js

@@ -367,9 +367,15 @@ test("the one machine goes to whoever is due soonest, not to the smallest number
     ...HOST,
     maxRuns: 2
   });
-  const started = actions.filter((action) => action.type === "start").map((action) => action.from);
-
-  assert.deepEqual(started, [500], "the one machine goes where somebody is stopped");
+  // WHERE the machine ends up, not how it got there. A run standing at #900
+  // reaches nothing anybody wants, so it is taken to #500 rather than killed and
+  // replaced — one process instead of a death and a cold start, which is
+  // strictly better and is what the plan now answers.
+  const placed = actions
+    .filter((action) => action.type === "start" || action.type === "move")
+    .map((action) => action.from);
+
+  assert.deepEqual(placed, [500], "the one machine goes where somebody is stopped");
 });
 
 test("two viewers far apart are both served, by however many encoders serve them soonest", () => {

package/test/move-cost.test.js

@@ -0,0 +1,145 @@
+/**
+ * @file What moving a running encoder costs, and what the plan does while
+ * nobody has measured it.
+ *
+ * Field 2026-09-08: 39 moves in one session, 24 of them between three adjacent
+ * numbers — #58 to #59, #59 to #58, #58 to #60, #60 to #58, six times each,
+ * about 0.8 s apart — while the viewer's picture stood still for 116.7 s in
+ * three interruptions, the worst of them 91.8 s. The zone the viewer's own
+ * position defines slides forward one number at a time, and every slide made
+ * standing one number behind it score worse than standing in it.
+ *
+ * THREE FAULTS IN THE ARITHMETIC, and no threshold anywhere. There was one for
+ * a while — "a move must beat staying by at least what moving costs" — and it
+ * was a prop under a comparison that was wrong rather than indifferent. It is
+ * gone.
+ *
+ * 1. **A body was charged a whole piece for the one it was already making.**
+ *    `arrival = delay + (index - at + 1) / rate` is right for a body that does
+ *    not exist yet and wrong for a run 0.8 s into a 0.9 s piece. `delaySec` is
+ *    now when the body finishes the piece it STANDS ON, so from #58 reaching #59
+ *    costs 0.14 + 0.94 = 1.08 s against 1.88 s for a kill and a cold start — a
+ *    decision by eight hundred milliseconds, where the double charge had made it
+ *    a coin flip lost by ten.
+ * 2. **The piece was priced at the unpenalised rate** while arrivals used the
+ *    penalised one, so every extra body looked cheaper than it is and the plan
+ *    bought a second encoder where one served. One rate, the one in force.
+ * 3. **`withinSeconds: null` was read through `Number()`**, where it is 0, so
+ *    the film BEHIND the viewers was due immediately and was the most urgent
+ *    material in the file. It bought encoders and it took the run standing in
+ *    front of the viewer, because that run was the nearest body to it.
+ *
+ * And what a move costs is `Infinity` until something has been measured, because
+ * a move is irreversible while leaving the encoder alone is always available. A
+ * run killed before producing anything is a measurement too — a lower bound on
+ * the first output — which is the only reading a thrash can supply.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { RunCosts } from "../services/encode/run-costs.js";
+import { planEncoders } from "../services/encode/EncodePlan.js";
+import { CoverageMap } from "../services/encode/CoverageMap.js";
+
+test("nothing measured means a move is refused, not priced at zero", () => {
+  const costs = new RunCosts();
+
+  const { moveCostSec, firstByteWaitSec, killCostSec } = costs.seconds();
+  assert.equal(moveCostSec, Number.POSITIVE_INFINITY, "moving is not free while unpriced");
+  // Placing one where there is none is the OTHER question, and it has no
+  // alternative: the film gets made or it does not.
+  assert.equal(firstByteWaitSec, 0, "placing an encoder is not blocked by an unknown price");
+  assert.equal(killCostSec, 0);
+});
+
+test("a run killed before producing anything is a lower bound on the first output", () => {
+  const costs = new RunCosts();
+
+  // Exactly what a thrash supplies: a run that lived 800 ms and finished
+  // nothing. It says the first output takes AT LEAST that long, which is a fact.
+  costs.note({ livedMs: 800, dyingMs: 40 });
+
+  const { moveCostSec } = costs.seconds();
+  assert.ok(Number.isFinite(moveCostSec), "one killed run is enough to stop the blindness");
+  assert.ok(Math.abs(moveCostSec - 0.84) < 0.001, `got ${moveCostSec}`);
+});
+
+test("a run that produced something is measured by its first output, not its life", () => {
+  const costs = new RunCosts();
+
+  costs.note({ livedMs: 60_000, firstOutputMs: 900, dyingMs: 100 });
+
+  const { moveCostSec, firstByteWaitSec } = costs.seconds();
+  assert.ok(Math.abs(firstByteWaitSec - 0.9) < 0.001, `got ${firstByteWaitSec}`);
+  assert.ok(Math.abs(moveCostSec - 1.0) < 0.001, `got ${moveCostSec}`);
+});
+
+test("the zone sliding one number does not move an encoder that is already reaching it", () => {
+  // The field shape exactly: a run standing at #58 with the viewer's urgent zone
+  // sliding #58..#59 → #59..#60. Driving through one segment costs the encoder a
+  // fraction of a second; moving costs a kill and a cold start.
+  const coverage = new CoverageMap();
+  coverage.setSegmentCount(482);
+  const run = { from: 58, to: 481, head: 58, speedX: 4.45, isAlive: true };
+  coverage.claim(run, 58, 481);
+
+  const actions = planEncoders({
+    coverage,
+    windows: [
+      { from: 0, to: 57, priority: 1, withinSeconds: null, behind: true },
+      { from: 59, to: 60, priority: 100, withinSeconds: 0, behind: false }
+    ],
+    runs: [run],
+    maxRuns: 3,
+    segmentSeconds: 4.2,
+    speedX: 4.45,
+    // Measured on this host: killing takes 40 ms, a fresh encoder's first piece
+    // 900 ms. Against that, driving one segment at 4.45x costs 0.94 s — so the
+    // two are close, and what settles it is that the move ALSO has to encode
+    // the same segment afterwards.
+    killCostSec: 0.04,
+    firstByteWaitSec: 0.9,
+    moveCostSec: 0.94,
+    refetchSecPerFilmSecond: 0,
+    contentionPenaltyFor: () => 1
+  });
+
+  assert.deepEqual(
+    actions.filter((one) => one.type === "move"),
+    [],
+    "a run one number behind the zone is already on its way into it"
+  );
+});
+
+test("a move that genuinely saves the viewer time still happens", () => {
+  // The other half: the viewer jumped fourteen segments ahead, and driving there
+  // at 4.45x would take 13 s while a cold start takes 0.94 s. Refusing this
+  // would be the opposite fault.
+  const coverage = new CoverageMap();
+  coverage.setSegmentCount(482);
+  const run = { from: 0, to: 481, head: 44, speedX: 4.45, isAlive: true };
+  coverage.claim(run, 0, 481);
+
+  const actions = planEncoders({
+    coverage,
+    windows: [{ from: 58, to: 59, priority: 100, withinSeconds: 0, behind: false }],
+    runs: [run],
+    maxRuns: 3,
+    segmentSeconds: 4.2,
+    speedX: 4.45,
+    killCostSec: 0.04,
+    firstByteWaitSec: 0.9,
+    moveCostSec: 0.94,
+    refetchSecPerFilmSecond: 0,
+    contentionPenaltyFor: () => 1
+  });
+
+  // WHERE the encoder ends up, not how it got there: the run at #44 reaches
+  // nothing anybody waits for, so the plan may either take it to #58 or stop it
+  // and start one there. Both are one process at #58, and which is cheaper is
+  // the measured difference between a kill and a cold start.
+  const placed = actions
+    .filter((one) => one.type === "move" || one.type === "start")
+    .map((one) => one.from);
+  assert.deepEqual(placed, [58], "fourteen segments of driving is worth a cold start");
+});