@torrent-tv/proxy 2.80.14 → 2.80.15

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 2.80.15
+
+- **Fix**: THE SPINNER CARAVAN, and its cause was one coercion. The priority map states `withinSeconds: null` for the film BEHIND the viewers — nobody is waiting there — and `deadlineReaderFor` read it through `Number()`, where `null` is 0. So the film a viewer had already passed 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 it did so again on every pass. Field 2026-09-08: 39 moves in one session, 24 of them between three adjacent numbers about 0.8 s apart, one viewer on a host affording three runs got three, and the picture stood still for 116.7 s in three interruptions, the worst 91.8 s. The map has said it plainly in every session's log; this line turned it into its opposite. Fourth time in this repository that the input to a calculation was not what the calculation assumed.
+- **Fix**: The objective is the map's OWN rank order, as a vector compared position by position — one pair per rank the map states, most urgent first: how long anybody waits at that rank, then when the last number of it is made. It was three seconds-valued terms with the ten ranks collapsed into two buckets, and "never" for the film behind is the film's own length — 2024 s on a 48-minute file — which outvotes everything above it. No weights, and none possible: a weight would let seconds at one rank buy seconds at another and would be a number nobody measured. The map is the source of truth about what matters and it already says so.
+- **Fix**: Residual work takes only spare capacity. A zone stating no deadline has nobody waiting in it, so a live run already standing in front of a viewer is never taken for it — taking it there means killing it, and the viewer waits out a cold start for film nobody asked for.
+- **Fix**: An act must pay for itself. Where an arrangement is only reachable by killing a running encoder, a gain smaller than what that killing costs is not a gain. The field numbers are that close: driving from #58 to #59 means making two pieces, 1.89 s at 4.45x on a 4.2 s grid, against a cold start and one piece, 1.88 s — the move was faster by ten milliseconds, and every one of the 39 was individually correct. The margin is the measured cost of the act, never a chosen figure.
+- **Fix**: The plan remembers what it is already carrying out. A staying run was priced as producing instantly however recently it had started; it is now priced at what it still has to go — the measured time to a first piece less the time it has been alive. A run 0.8 s old has 0.14 s left against 0.94 s to move it. One measured figure minus elapsed time, no state to keep.
+- **Fix**: What a move costs is `Infinity` until something has been measured, because a move is irreversible and leaving the encoder alone is always available; placing one where there is none takes the unknown the other way, since the film gets made or it does not. And 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, since every run in one is killed before it finishes anything.
+- **Fix**: The average bitrate declared in the master came from a field that does not exist on a source file, so every variant was declared at the 400 kbit/s floor in 2.80.14 — nine times worse than the rule of thumb it replaced. It is read from where it is known: the torrent's own report of the file's length, with the probe's reading of the video stream covering the gap before that arrives.
+- **New**: The piece store's own line names its holders, and `AHEAD` no longer reaches memory.
+- **Chore**: `hls-session-manager.js` grew by four lines of wiring in its constructor, which the rule for that file does not allow. Stated rather than shuffled: the thing itself moved to `output/`, and what is left is two accessors handed over where wiring belongs.
+
 ## 2.80.14
 
 - **Fix**: What the master playlist declares a variant carries is MEASURED. It was `height * height * 3.2` — for 1080 exactly the 3 732 480 the field declared for a file carrying 18.4 Mbit/s, five times more — and the comment justifying it said no measurement existed before encoding starts. Both do: the average is the file's own length over its duration, exact at session creation, and the peak is the biggest piece produced over the span it covers, equal to the average until one exists. A re-encoded height is declared at the cap we impose; a smaller height at the pixel share of the source's rate. `BANDWIDTH` and `AVERAGE-BANDWIDTH` are both emitted, as the specification names them. This is not cosmetic: the browser sizes its cushion in BYTES from `BANDWIDTH`, so 120 s asked bought 56 MB — 26 s of that film — and the deepest it ever held was 17.1 s. One expression, no case analysis: absent measurements and absent caps are written as the identity of the operation that consumes them (`services/output/rates.js`, eight checks).

package/docs/encode-architecture.md

@@ -188,6 +188,71 @@ was 17.1 s. Inflating it is not the answer either: hls.js compares it against
 its own estimate of the link to decide a level is unplayable, and its recovery
 then moves level by itself, which does not honour our pinning.
 
+## The objective is the map's own rank order
+
+Not three terms in seconds. One pair per rank the map states, most urgent rank
+first, compared position by position:
+
+```
+[ late(100), done(100), late(99), done(99), … late(1), done(1) ], bodies, wasted
+```
+
+`late(r)` is how long anybody waits past a deadline at rank `r`; `done(r)` is
+when the last number of that rank is made. A difference at a higher rank settles
+it and nothing lower can reopen it — which is the stated order: nobody stares at
+a spinner; then the film in front is encoded as fast as it can be, band by band
+as the map ranks them; then, with what is left over and only then, the film
+behind, in case somebody seeks back.
+
+**No weights, and none possible.** A weight would let seconds at one rank buy
+seconds at another, and it would be a figure nobody measured. The map is the
+source of truth about what matters and it already says so — ten ranks on a film,
+p100 at the number a viewer is stopped on, doubling zones down to p91 for the far
+tail, p1 for what lies behind them.
+
+`bodies` ranks below every rank of the map, so spare capacity cannot buy an
+encoder where the map is indifferent. `wasted` is the swarm's bill for anything
+fetched twice.
+
+## Three rules that stop an encoder being moved for nothing
+
+**A zone with no deadline never takes a live run.** Residual work — the film
+behind the viewers, kept in case somebody seeks back — is done with capacity
+that is left over, and a run already standing in front of a viewer is not left
+over.
+
+**An act must pay for itself.** Where an arrangement is only reachable by killing
+a running encoder, a gain smaller than what the killing costs is not a gain. The
+margin is the measured cost of the act.
+
+**The plan remembers what it is already carrying out.** A staying run is priced
+at what it still has to go — the measured time to a first piece less the time it
+has been alive — not at zero. A run 0.8 s old has 0.14 s left against 0.94 s to
+move it; one working half a minute has nothing left, and a move then happens
+exactly when the film it would reach sooner is worth the restart.
+
+And what a move costs is `Infinity` until something has been measured: a move is
+irreversible and leaving the encoder alone is always available. Placing one where
+there is none takes the unknown the other way, because the film gets made or it
+does not.
+
+### What all three were for
+
+Field 2026-09-08. The map states `withinSeconds: null` for the film behind the
+viewers; `deadlineReaderFor` read it through `Number()`, where `null` is 0, so
+that film 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 — 39 moves in one session, 24 of them between
+three adjacent numbers about 0.8 s apart. One viewer on a host affording three
+runs got three. The picture stood still for 116.7 s in three interruptions, the
+worst of them 91.8 s.
+
+The numbers are worth keeping because they are so close: driving from #58 to #59
+means making TWO pieces, 1.89 s at 4.45x on a 4.2 s grid, against a cold start
+and ONE piece, 0.94 + 0.94 = 1.88 s. Every one of those 39 moves was
+individually the cheapest arrangement it was offered. That is the signature of an
+optimiser with no memory, and the three rules above are what give it one.
+
 ## What is checked
 
 `test/one-authority.test.js` holds the shape: one caller of `#startEncodeRun`,

package/package.json

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

package/services/encode/EncodePlan.js

@@ -102,6 +102,11 @@
  *   measured on this host from its own runs. Zero until something has measured
  *   it, which makes moving one look cheaper than it is and is said here so the
  *   bias is known.
+ * @param {number} [params.moveCostSec] - What moving a running encoder costs on
+ *   this host, measured. `Infinity` until something has been measured, because a
+ *   move is irreversible and leaving the encoder alone is always available.
+ * @param {number} [params.now] - The clock, injected. This layer is arithmetic
+ *   and reads no clock of its own; how old a run is is one of its inputs.
  * @param {number} [params.firstByteWaitSec] - How long a fresh encoder takes to
  *   produce anything: process start, opening the input, and the first piece.
  *   Measured the same way. It replaced a constant of 0.12 s taken from one
@@ -123,6 +128,8 @@ export function planEncoders({
   segmentSeconds,
   killCostSec = 0,
   firstByteWaitSec = 0,
+  moveCostSec = Number.POSITIVE_INFINITY,
+  now = Date.now(),
   refetchSecPerFilmSecond = 0,
   contentionPenaltyFor = () => 1,
   speedX = 0
@@ -164,7 +171,38 @@ export function planEncoders({
   // its death, the start of another, and the wait for the first bytes there.
   // Taking an encoder somewhere else is stopping this one and waiting for the
   // next to produce. Both halves are measured on this host.
-  const moveSec = killCostSec + firstByteWaitSec;
+  // WHAT A MOVE COSTS. Killing an encoder and waiting for a fresh one's first
+  // piece is the price; until something has produced anything on this host that
+  // price is unknown, and a move is then refused rather than priced at zero.
+  // Placing one where there is none is the other question and takes the unknown
+  // the other way — see `run-costs.js`.
+  const moveSec = Number.isFinite(moveCostSec) ? moveCostSec : killCostSec + firstByteWaitSec;
+
+  // WHAT A RUN STILL HAS TO GO BEFORE IT PRODUCES ANYTHING — the measured time
+  // to a first piece, less the time it has already been alive.
+  //
+  // This is the memory the score was missing. It is computed afresh whenever
+  // anything changes, and every arrangement used to be priced as though it were
+  // the last decision anybody would take: a run that started 10 ms ago was
+  // assumed to produce instantly, so killing it and starting another looked like
+  // a straight gain. A move is justified by a benefit that arrives when the
+  // moved run produces something; taken again before it has, the benefit is
+  // never collected and the cost is paid twice, three times, forty times.
+  //
+  // A run 0.8 s old has 0.14 s left to go against 0.94 s to move it, so it is
+  // left alone; one working for half a minute has nothing left, and a move
+  // happens exactly when the film it would reach sooner is worth the restart. No
+  // state to keep and nothing to choose: one measured figure minus elapsed time.
+  const remainingWarmOf = (run) => {
+    if (Number(run.head) !== Number(run.from)) {
+      return 0; // it has produced something, so its warm-up is spent
+    }
+    const startedAt = Number(run.startedAt);
+    if (!Number.isFinite(startedAt) || startedAt <= 0) {
+      return firstByteWaitSec; // not started yet, so all of it is ahead
+    }
+    return Math.max(0, firstByteWaitSec - (now - startedAt) / 1000);
+  };
 
   // ------------------------------------------------------------------ WHERE
   //
@@ -228,6 +266,28 @@ export function planEncoders({
         if (arrangement.used.has(run)) {
           continue;
         }
+        // A LIVE RUN IS NEVER TAKEN FOR RESIDUAL WORK.
+        //
+        // A zone that states no deadline has nobody waiting in it: it is the
+        // film behind the viewers, kept in case somebody seeks back, and it is
+        // done with capacity that is left over. A run already standing in front
+        // of a viewer is not left over — taking it there means killing it, and
+        // the viewer it was serving waits out a cold start for film nobody had
+        // asked for.
+        //
+        // Field 2026-09-08: on a host affording three runs, one viewer got
+        // three. Two of them came from this residual capacity, and the third was
+        // the run serving the viewer, taken to #30 in the middle of the film
+        // they had already watched. Reaching that film took the third term from
+        // "never" — the film's own length, 2024 s — to a real figure, which
+        // outvotes any price a move can carry. It must not be able to outvote
+        // it, and the reason is not arithmetic: nobody is waiting there.
+        //
+        // Read off the map, which is the one thing that states it. Nothing here
+        // knows that a viewer exists.
+        if (!Number.isFinite(untilNeeded(positions[index]))) {
+          continue;
+        }
         next.push({
           fill: [...arrangement.fill, run],
           used: new Set([...arrangement.used, run]),
@@ -254,7 +314,7 @@ export function planEncoders({
       const head = Number(filler.head);
       bodies.push({
         at: positions[index],
-        delaySec: head === positions[index] ? 0 : moveSec
+        delaySec: head === positions[index] ? remainingWarmOf(filler) : moveSec
       });
     }
     // Bodies nobody was given a position for go on working where they stand,
@@ -273,10 +333,20 @@ export function planEncoders({
       const cutInFront = arrangement.fill.some((filler, index) =>
         filler !== null && positions[index] > head
         && (endless || positions[index] <= Number(run.to)));
-      bodies.push({ at: head, delaySec: cutInFront ? moveSec : 0 });
+      bodies.push({ at: head, delaySec: cutInFront ? moveSec : remainingWarmOf(run) });
     }
     const scored = latenessOf(bodies, coverage, wanted, untilNeeded, rate / contentionPenaltyFor(Math.max(0, bodies.length - 1)), refetchPerSegment, segmentSeconds);
-    if (bestScore === null || cheaperThan(scored, bestScore)) {
+    // WHETHER THIS ARRANGEMENT KILLS A RUNNING ENCODER, which is what has to pay
+    // for itself. An arrangement that leaves every live run where it stands owes
+    // nothing; one that takes a run somewhere else has to be better by what the
+    // taking costs.
+    const disturbs = live.some((run) => {
+      const at = arrangement.used.has(run)
+        ? positions[arrangement.fill.indexOf(run)]
+        : Number(run.head);
+      return at !== Number(run.head);
+    });
+    if (bestScore === null || cheaperThan(scored, bestScore, disturbs ? moveSec : 0)) {
       bestScore = scored;
       best = arrangement;
     }
@@ -309,7 +379,7 @@ export function planEncoders({
       }
       const at = override.has(run) ? override.get(run) : (placement.get(run) ?? Number(run.head));
       const head = Number(run.head);
-      bodies.push({ at, delaySec: at === head ? 0 : moveSec });
+      bodies.push({ at, delaySec: at === head ? remainingWarmOf(run) : moveSec });
     }
     for (let index = 0; index < positions.length; index += 1) {
       if ((best ? best.fill[index] : null) === "new") {
@@ -333,7 +403,7 @@ export function planEncoders({
     }
     const asIs = scoreOf(new Map());
     const moved = scoreOf(new Map([[run, gap]]));
-    if (cheaperThan(moved, asIs)) {
+    if (cheaperThan(moved, asIs, moveSec)) {
       placement.set(run, gap);
     }
   }
@@ -566,19 +636,33 @@ function latenessOf(bodies, coverage, wanted, untilNeeded, rate, refetchSecPerSe
   // had nothing to compare, and the encoder was free to wander to the start of
   // the file. Which side a stretch is on and how soon it is wanted are two
   // different facts, and the map states both.
-  const isBehind = (at) => {
-    let behind = false;
+  // WHAT RANK THE MAP GIVES THIS NUMBER — the highest, where zones overlap,
+  // because a number two viewers want is wanted as much as the more urgent of
+  // them wants it.
+  //
+  // This replaced a boolean, "is it behind everybody", and the boolean was the
+  // whole of what the objective knew about the map's own order. The map states
+  // ten ranks on a film — p100 at the number a viewer is stopped on, doubling
+  // zones down to p91 for the far tail, p1 for what lies behind them — and all
+  // of that was collapsed into two buckets and then converted to seconds, where
+  // "never" for the film behind is the film's own length. On a 48-minute file
+  // that is 2024 s, which outvotes everything: field 2026-09-08, one viewer got
+  // three encoders, two of them on film behind them, and the run serving them
+  // was killed to make room for one.
+  const rankAt = (at) => {
+    let rank = 0;
     for (const span of wanted) {
-      if (at < span.from || at > span.to) {
-        continue;
-      }
-      if (span.behind !== true) {
-        return false;
+      if (at >= span.from && at <= span.to) {
+        rank = Math.max(rank, Number(span.priority) || 0);
       }
-      behind = true;
     }
-    return behind;
+    return rank;
   };
+  // The ranks the map actually states, most urgent first. The comparison is over
+  // these and nothing else, so a rank can never be outvoted by a lower one
+  // however many seconds are at stake there.
+  const ranks = [...new Set(wanted.map((span) => Number(span.priority) || 0))]
+    .sort((left, right) => right - left);
 
   // EVERY COUNT IS OVER THE FILM, NOT OVER THE ENCODERS. When a piece is made
   // depends on which encoder reaches it soonest, and the encoder that reaches
@@ -604,10 +688,11 @@ function latenessOf(bodies, coverage, wanted, untilNeeded, rate, refetchSecPerSe
   // clock forward makes that trade impossible: abandoning the near film delays
   // the far film by at least as much.
   let stalled = 0;
-  let tardiness = 0;
-  let aheadDone = 0;
-  let behindDone = 0;
   let wastedSwarm = 0;
+  /** Seconds anybody waits past a deadline, per rank. @type {Map<number, number>} */
+  const lateAt = new Map(ranks.map((rank) => [rank, 0]));
+  /** When the last number of a rank is made, per rank. @type {Map<number, number>} */
+  const doneAt = new Map(ranks.map((rank) => [rank, 0]));
   for (let index = first; index <= last; index += 1) {
     // Which encoder gets to this piece first, and when. One standing on it is
     // already there; one behind it must work its way up, re-making anything
@@ -643,30 +728,39 @@ function latenessOf(bodies, coverage, wanted, untilNeeded, rate, refetchSecPerSe
     // total on a host whose startup measured nothing at all, where every arrival
     // is beyond reckoning and every arrangement is therefore equally hopeless.
     const when = byWhom === null ? never : Math.min(soonest, never);
-    if (isBehind(index)) {
-      behindDone = Math.max(behindDone, when);
-    } else {
-      aheadDone = Math.max(aheadDone, when);
-    }
+    const rank = rankAt(index);
+    doneAt.set(rank, Math.max(doneAt.get(rank) ?? 0, when));
     const deadline = untilNeeded(index);
     if (Number.isFinite(deadline)) {
       const due = deadline + stalled;
       const waited = Math.max(0, when - due);
-      tardiness += waited;
+      lateAt.set(rank, (lateAt.get(rank) ?? 0) + waited);
       stalled += waited;
     }
   }
 
   return {
-    // 1. SECONDS ANYBODY SPENDS LOOKING AT A SPINNER. Nothing outranks it.
-    stall: tardiness,
-    // 2. WHEN THE FILM IN FRONT OF THEM IS DONE — the last piece of it to be
-    //    made, whichever encoder makes it. Film nobody reaches counts as never,
-    //    which is what stops the front being abandoned.
-    ahead: aheadDone,
-    // 3. WHEN THE WHOLE FILE IS DONE — the film behind included, and the swarm's
-    //    price for anything fetched twice, which delays everything.
-    whole: Math.max(aheadDone, behindDone) + wastedSwarm
+    // THE MAP'S OWN ORDER, AS A VECTOR. One pair per rank the map states, most
+    // urgent rank first: how long anybody waits at that rank, then when the last
+    // number of it is made.
+    //
+    // Compared position by position, so a rank is never outvoted by a lower one
+    // — which is the whole of what was asked for: nobody stares at a spinner;
+    // then the film in front of the viewers is encoded as fast as it can be, band
+    // by band as the map ranks them; then, with whatever is left over and only
+    // then, the film behind them, in case somebody seeks back.
+    //
+    // No weights, and none possible: a weight would let seconds at one rank buy
+    // seconds at another, and it would be a number nobody measured. The map is
+    // the source of truth about what matters, and it already says so.
+    byRank: ranks.flatMap((rank) => [lateAt.get(rank) ?? 0, doneAt.get(rank) ?? 0]),
+    // HOW MANY ENCODERS IT TAKES. Ranked below every rank of the map and above
+    // the swarm's bill, so it cannot buy one where the map is indifferent — and
+    // the map IS indifferent about spare capacity, which is what bought an
+    // encoder for film nobody waits for.
+    bodies: bodies.length,
+    // WHAT THE SWARM PAYS for anything fetched twice, which delays everything.
+    wasted: wastedSwarm
   };
 }
 
@@ -686,14 +780,44 @@ function latenessOf(bodies, coverage, wanted, untilNeeded, rate, refetchSecPerSe
  * @param {{ stall: number, ahead: number, whole: number }} right
  * @returns {boolean}
  */
-function cheaperThan(left, right) {
-  if (left.stall !== right.stall) {
-    return left.stall < right.stall;
+function cheaperThan(left, right, byAtLeast = 0) {
+  // POSITION BY POSITION, in the map's own order of ranks. A difference at a
+  // higher rank settles it, and nothing at a lower one can reopen it.
+  //
+  // `byAtLeast` is what an ACT has to pay for itself. Where the left side is
+  // only reachable by killing a running encoder, a gain smaller than what that
+  // killing costs is not a gain: the arithmetic says the film arrives sooner,
+  // and the machine says a process died for it.
+  //
+  // Field 2026-09-08, and it is worth the exact numbers because they are so
+  // close. A run standing at #58 with the viewer's zone at #59..#60: driving
+  // there means making TWO pieces, 1.89 s at 4.45x on a 4.2 s grid, while
+  // moving means a cold start and ONE piece, 0.94 + 0.94 = 1.88 s. The move is
+  // faster — by ten milliseconds. Every one of 39 moves in that session was
+  // individually correct by this arithmetic, 24 of them between three adjacent
+  // numbers, and the viewer's picture stood still for 116.7 s.
+  //
+  // The margin is measured, never chosen: it is the cost of the act itself, and
+  // an act that does not repay its own cost is not worth taking. It is also
+  // wider than the spread of the figures the comparison is made of, which are
+  // medians of recent runs — so a difference smaller than it is not a difference
+  // this model can see.
+  const size = Math.max(left.byRank.length, right.byRank.length);
+  for (let index = 0; index < size; index += 1) {
+    const here = left.byRank[index] ?? 0;
+    const there = right.byRank[index] ?? 0;
+    if (here !== there) {
+      return here + byAtLeast < there;
+    }
   }
-  if (left.ahead !== right.ahead) {
-    return left.ahead < right.ahead;
+  // Where every rank is served identically, fewer encoders. This is what stops
+  // spare capacity buying one: the map is indifferent, so the machine decides,
+  // and a process, a reader of the piece store and the swarm's bandwidth are all
+  // paid by the viewers the ranks above are about.
+  if (left.bodies !== right.bodies) {
+    return left.bodies < right.bodies;
   }
-  return left.whole < right.whole;
+  return left.wasted < right.wasted;
 }
 
 /**
@@ -742,7 +866,24 @@ function deadlineReaderFor(windows, segmentSeconds) {
       // same as a stated one — read as due all at once instead, a window as wide
       // as a viewer's cushion demanded its far end instantly and bought an
       // encoder to stand beside one already working.
-      const within = stated === undefined ? 0 : Number(stated);
+      // `null` IS A STATEMENT AND IT SAYS NOBODY IS COMING. `undefined` is the
+      // absence of one, and a caller that knows only a position is somebody
+      // waiting at it.
+      //
+      // Read through `Number()`, `null` becomes 0 — due NOW — so the film BEHIND
+      // the viewers, which the map marks with exactly that, was the most urgent
+      // material in the file. Everything followed from it: it bought encoders,
+      // it took the run standing in front of the viewer because that run was the
+      // nearest body to it, and it did so again on every pass. Field 2026-09-08:
+      // 39 moves in one session, 24 between three adjacent numbers, one viewer
+      // on three encoders, and the picture stood still for 116.7 s in three
+      // interruptions, the worst of them 91.8 s.
+      //
+      // The map has always said it plainly — `{"from":0,"to":57,"priority":1,
+      // "withinSeconds":null,"behind":true}` is in the log of every session — and
+      // this line turned it into its opposite. Fourth time in this repository
+      // that the input to a calculation was not what the calculation assumed.
+      const within = stated === undefined ? 0 : (stated === null ? Number.NaN : Number(stated));
       if (!Number.isFinite(within)) {
         // Stated as no time at all: nobody is coming here.
         continue;

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,138 @@
+/**
+ * @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.
+ *
+ * FOUR THINGS, and the first is the one that mattered.
+ *
+ * 1. The map states `withinSeconds: null` for the film BEHIND the viewers —
+ *    nobody is waiting there. `deadlineReaderFor` read it through `Number()`,
+ *    where `null` is 0, so that film was due NOW 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.
+ * 2. Residual work took a live run. A zone with no deadline is done with
+ *    capacity that is left over, and a run already serving a viewer is not left
+ *    over.
+ * 3. `moveSec` was 0 until measured, so a move was free in the arithmetic — and
+ *    the blindness sustained itself, because the first-output figure takes a
+ *    reading only from a run that produced something and every run in a thrash
+ *    is killed before it finishes anything.
+ * 4. A staying run was priced as though it would produce instantly, however
+ *    recently it had started, so the score had no memory of a decision it was
+ *    still carrying out.
+ */
+
+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");
+});