@torrent-tv/proxy 2.101.3 → 2.101.5

package/package.json

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

package/server.js

@@ -1159,7 +1159,9 @@ export async function startProxyServer({
         film: Number(run.progress?.processedSeconds) - Number(run.progress?.startPositionSeconds ?? 0)
       })))
       .filter((run) => Number.isInteger(run.pid)),
-    detailed: () => startupProfile.active()
+    detailed: () => startupProfile.active(),
+    // What the pause rule judges from (torrent-tv/meta#180, phase 4).
+    onRunSeconds: (seconds) => outputParts.encodeOrchestrator?.noteRunSeconds(seconds)
   });
   // What the last life of this process left on the disk. The kernel kills this
   // one often enough for that to be an ordinary state rather than an odd one —

package/services/encode/EncodeOrchestrator.js

@@ -24,7 +24,8 @@
  */
 
 import { CoverageMap } from "./CoverageMap.js";
-import { firstUnmetWant, planEncoders } from "./EncodePlan.js";
+import { deadlineReaderFor, firstUnmetWant, planEncoders } from "./EncodePlan.js";
+import { PauseRule } from "./PauseRule.js";
 import { endOfRun } from "./EncodeRun.js";
 import { ENCODE_EXIT } from "./encode-exit.js";
 import { affordableRuns } from "./run-budget.js";
@@ -138,13 +139,19 @@ export class EncodeOrchestrator {
    * viewer was stopped for waited 59 s behind a picture that had long left
    * the urgent band (Home Assistant 2026-10-12, torrent-tv/meta#178).
    *
-   * @type {Map<string, { urgent: boolean, priority: number }>}
+   * @type {Map<string, { urgent: boolean, priority: number, from: number }>}
    */
   #heldBack = new Map();
 
   /** What a stop and a start have cost on this host. */
   #costs = new RunCosts();
 
+  /**
+   * Whether a less urgent encoder runs beside the leading one, from what
+   * running it was measured to do (torrent-tv/meta#180, phase 4).
+   */
+  #pauseRule = new PauseRule();
+
   /**
    * What starting and stopping an encoder was measured to cost on this host,
    * before any viewer existed. Told once; real runs replace it as they end.
@@ -228,6 +235,9 @@ export class EncodeOrchestrator {
    *   this one may be asked about encoders with no ledger, no clock and no
    *   viewer anywhere. Absent, the line simply does not carry it.
    * @param {SegmentCoverage | null} [params.segmentCoverage]
+   * @param {{ freeCores: () => number | null, otherCores: () => number | null } | null} [params.processor] -
+   *   The processor left free and the processor other work takes, in cores
+   *   (`ProcessorBudget`); absent, both are unknown.
    */
   constructor({
     maxRunsFor,
@@ -242,6 +252,7 @@ export class EncodeOrchestrator {
     inputsUnplaced = null,
     describeWaits = null,
     admission = null,
+    processor = null,
     logger,
     now
   }) {
@@ -250,6 +261,7 @@ export class EncodeOrchestrator {
     // encoder that would slow everybody below realtime. Absent in a check that
     // is about one output, and then only the per-output limit binds.
     this.admission = admission && typeof admission.placesFor === "function" ? admission : null;
+    this.processor = processor && typeof processor.freeCores === "function" ? processor : null;
     this.#describeWaits = typeof describeWaits === "function" ? describeWaits : () => "";
     // Only the segment facts and operations this planner needs cross the
     // storage boundary; the concrete storage remains in the server assembly.
@@ -665,7 +677,7 @@ export class EncodeOrchestrator {
   /**
    * The most urgent band a live encoder stands in, over every output.
    *
-   * @returns {{ urgent: boolean, priority: number, address: string, index: number } | null}
+   * @returns {{ urgent: boolean, priority: number, address: string, index: number, run: object } | null}
    */
   #leadingBand() {
     let leading = null;
@@ -673,7 +685,7 @@ export class EncodeOrchestrator {
       for (const run of runs) {
         if (!run.isAlive || run.isStopping) continue;
         const band = this.#bandAt(address, run.head);
-        if (!leading || compareUrgency(band, leading) < 0) leading = { ...band, address, index: run.head };
+        if (!leading || compareUrgency(band, leading) < 0) leading = { ...band, address, index: run.head, run };
       }
     }
     return leading;
@@ -696,6 +708,13 @@ export class EncodeOrchestrator {
    * Paused rather than lowered in priority: a lowered priority cannot be raised
    * again without `CAP_SYS_NICE`, which the add-on's container does not have
    * (Home Assistant 2026-10-10: `renice 0` after `renice 19` left 19).
+   *
+   * AND PAUSED ONLY WHERE RUNNING IT WAS MEASURED TO COST THE LEADER
+   * (torrent-tv/meta#180, phase 4). Behind the leader is the condition, not
+   * the verdict: `PauseRule` lets a less urgent encoder run while the leader
+   * still makes what its deadlines need, and pauses it once the leader's own
+   * readings say it does not. Without readings to judge from, behind is paused
+   * as before.
    */
   shareTheMachine() {
     const leading = this.#leadingBand();
@@ -704,21 +723,125 @@ export class EncodeOrchestrator {
       this.#placeHeldBack(null);
       return;
     }
+    const now = this.now();
+    const running = this.#runningNow();
+    const need = this.#needOf(leading);
+    const free = this.#processorReading("freeCores");
+    const others = this.#processorReading("otherCores");
     for (const [address, runs] of this.#runs) {
       for (const run of runs) {
         if (!run.isAlive || run.isStopping || typeof run.pause !== "function") continue;
         const behind = compareUrgency(this.#bandAt(address, run.head), leading) > 0;
-        if (behind && run.isSuspended !== true) {
-          run.pause(`#${run.head} of ${address} is wanted less urgently than #${leading.index} of ${leading.address}, ` +
-            `which is being made`);
-        } else if (!behind && run.isSuspended === true) {
-          run.resume(`nothing more urgent than #${run.head} of ${address} is being made`);
+        if (!behind) {
+          if (run.isSuspended === true) run.resume(`nothing more urgent than #${run.head} of ${address} is being made`);
+          continue;
+        }
+        const urgency = `#${run.head} of ${address} is wanted less urgently than #${leading.index} of ${leading.address}`;
+        const verdict = this.#pauseRule.judge({
+          leader: leading.run, band: leading, run, address, need, remainingFilm: this.#remainingFilm(run), free, others, running, now
+        });
+        if (verdict === null) {
+          if (run.isSuspended !== true) run.pause(`${urgency}, which is being made`);
+        } else if (verdict.runs && run.isSuspended === true) {
+          run.resume(`${urgency}, and runs beside it: ${verdict.because}`);
+        } else if (!verdict.runs && run.isSuspended !== true) {
+          run.pause(`${urgency}, which is being made: ${verdict.because}`);
         }
       }
     }
     this.#placeHeldBack(leading);
   }
 
+  /**
+   * One second of each encoder's processor and speed, by process
+   * (`storage/processor-report.js`): what `PauseRule` judges from. Who has the
+   * processor is decided again after it.
+   *
+   * @param {Map<number, { cores: number, speed: number | null }>} seconds
+   * @param {number} [at]
+   */
+  noteRunSeconds(seconds, at = this.now()) {
+    if (!(seconds instanceof Map) || seconds.size === 0) return;
+    const running = this.#runningNow();
+    let noted = false;
+    for (const runs of this.#runs.values()) {
+      for (const run of runs) {
+        const reading = seconds.get(run.process?.pid);
+        // A paused process draws nothing and makes nothing: its second says
+        // nothing about what it costs when it runs.
+        if (!reading || !run.isAlive || run.isSuspended === true) continue;
+        this.#pauseRule.noteSecond(run, { at, cores: reading.cores, speed: reading.speed }, running, run.isWaitingForInput === true);
+        noted = true;
+      }
+    }
+    if (noted) this.shareTheMachine();
+  }
+
+  /** @returns {Set<object>} Every encoder running now, not paused. */
+  #runningNow() {
+    const running = new Set();
+    for (const runs of this.#runs.values()) {
+      for (const run of runs) if (run.isAlive && !run.isStopping && run.isSuspended !== true) running.add(run);
+    }
+    return running;
+  }
+
+  /**
+   * The speed the leading run's deadlines ask for: over every number it has
+   * left, the film up to it over the time until it is needed. Infinite where a
+   * viewer already waits for one of them; 0 where none is due.
+   *
+   * @param {{ address: string, run: object }} leading
+   * @returns {number}
+   */
+  #needOf({ address, run }) {
+    const seconds = this.segmentSeconds;
+    if (!(seconds > 0)) return Number.POSITIVE_INFINITY;
+    const dueIn = deadlineReaderFor(this.#demand.mapOn(address), seconds);
+    let need = 0;
+    for (let index = run.head; index <= run.to; index += 1) {
+      const due = dueIn(index);
+      if (!Number.isFinite(due)) break;
+      if (due <= 0) return Number.POSITIVE_INFINITY;
+      need = Math.max(need, ((index - run.head + 1) * seconds) / due);
+    }
+    return need;
+  }
+
+  /**
+   * @param {object} run
+   * @returns {number} Film seconds it has left to make; infinite with no end.
+   */
+  #remainingFilm(run) {
+    return Number.isFinite(run.to) ? Math.max(0, run.to - run.head + 1) * this.segmentSeconds : Number.POSITIVE_INFINITY;
+  }
+
+  /**
+   * @param {"freeCores" | "otherCores"} name
+   * @returns {number | null}
+   */
+  #processorReading(name) {
+    const value = this.processor?.[name]?.();
+    return Number.isFinite(value) ? value : null;
+  }
+
+  /**
+   * Why a start at `from` on `address` would be paused the moment it exists,
+   * or null: behind the leader, and not let go by `PauseRule`.
+   *
+   * @param {string} address
+   * @param {number} from
+   * @returns {string | null}
+   */
+  #holdReason(address, from) {
+    const leading = this.#leading;
+    if (!leading?.run || compareUrgency(this.#bandAt(address, from), leading) <= 0) return null;
+    const verdict = this.#pauseRule.wouldStart({
+      leader: leading.run, address, need: this.#needOf(leading), free: this.#processorReading("freeCores")
+    });
+    return verdict.runs ? null : verdict.because;
+  }
+
   /**
    * Plan again every output whose start was held back behind what is no
    * longer more urgent than it: the start is placed now, by the same plan,
@@ -728,7 +851,7 @@ export class EncodeOrchestrator {
    */
   #placeHeldBack(leading) {
     for (const [address, band] of [...this.#heldBack]) {
-      if (leading && compareUrgency(band, leading) > 0) continue;
+      if (leading && compareUrgency(band, leading) > 0 && this.#holdReason(address, band.from) !== null) continue;
       this.#heldBack.delete(address);
       this.#reconcileOne(address);
     }
@@ -824,7 +947,11 @@ export class EncodeOrchestrator {
       // was measured it holds the largest reading rather than continuing a curve
       // nothing observed.
       contentionPenaltyFor: (others) => contentionPenalty(others, this.contentionPenalties).penalty,
-      speedX
+      speedX,
+      // A START THE PAUSE RULE WOULD PAUSE AT ONCE IS NOT MADE: the encoder
+      // would hold a process and its input for nothing. The plan returns it as
+      // `hold`, and it is placed when the rule lets it go (`#placeHeldBack`).
+      holdStart: (from) => this.#holdReason(address, from)
     });
 
     // A move is the plan taking a running encoder away from where it already
@@ -869,13 +996,10 @@ export class EncodeOrchestrator {
         `live=${JSON.stringify(live.map((run) => ({ from: run.from, to: run.to, head: run.head, speedX: run.speedX })))}`
       );
     }
-    // A START BEHIND WHAT IS BEING MADE ELSEWHERE IS NOT MADE: the encoder would
-    // be paused the moment it exists (`shareTheMachine`), holding a process and
-    // its input for nothing. It is placed when nothing more urgent is in hand.
+    // A start held by the plan is placed when the pause rule lets it go.
     let heldBack = null;
     for (const action of actions) {
-      if (action.type === "start" && this.#leading &&
-          compareUrgency(this.#bandAt(address, action.from), this.#leading) > 0) {
+      if (action.type === "hold") {
         heldBack = action;
         continue;
       }
@@ -946,7 +1070,7 @@ export class EncodeOrchestrator {
     // a 159 090-line file, 31 % of the log, all of one wedge.
     const wanting = firstUnmetWant(coverage, windows);
     const stillRunning = this.runsOn(address).filter((run) => run.isAlive);
-    if (heldBack) this.#heldBack.set(address, this.#bandAt(address, heldBack.from));
+    if (heldBack) this.#heldBack.set(address, { ...this.#bandAt(address, heldBack.from), from: heldBack.from });
     else this.#heldBack.delete(address);
     if (wanting === null || stillRunning.length > 0) {
       this.#lastUnmet.delete(address);
@@ -956,7 +1080,7 @@ export class EncodeOrchestrator {
         this.#lastUnmet.set(address, said);
         this.logger.info(
           `encode: #${heldBack.from} of ${address} waits — #${this.#leading?.index} of ` +
-          `${this.#leading?.address} is wanted more urgently and is being made`
+          `${this.#leading?.address} is wanted more urgently and is being made (${heldBack.because})`
         );
       }
     } else if (this.#lastUnmet.get(address) !== wanting) {
@@ -1184,6 +1308,7 @@ export class EncodeOrchestrator {
       this.#lastProgress.set(ended.address, progress);
     }
     this.#costs.note(ended);
+    if (ended.run) this.#pauseRule.forget(ended.run, ended.address);
     // Exactly one ending is normal — the run reached the end of the stretch it
     // was given and closed its last file. Every other leaves a piece open, and
     // that piece is under this run's OWN working name, so clearing up after it

package/services/encode/EncodePlan.js

@@ -84,7 +84,8 @@
  * @typedef {{ type: "start", from: number, to: number, because: string }
  *   | { type: "move", run: object, from: number, to: number, because: string }
  *   | { type: "stop", run: object, because: string }
- *   | { type: "keep", run: object, from: number, to: number }} PlanAction
+ *   | { type: "keep", run: object, from: number, to: number }
+ *   | { type: "hold", from: number, to: number, because: string }} PlanAction
  */
 
 /**
@@ -116,6 +117,11 @@
  *   encoder per piece: at exactly realtime each next piece is marginally late
  *   however many are running, so another one always seemed to help a little.
  *   Unmeasured is 1, and then the budget is the only thing bounding the count.
+ * @param {(from: number) => string | null} [params.holdStart] - Why a start at
+ *   `from` would be paused the moment it exists (`PauseRule`), or null. Such a
+ *   start comes back as `hold` with that reason: the encoder would hold a
+ *   process and its input for nothing, and one place decides a start
+ *   (torrent-tv/meta#180).
  * @returns {PlanAction[]} Stops first, then moves, then starts, so that a plan
  *   carried out in order never holds two encoders where it means to hold one.
  */
@@ -130,7 +136,8 @@ export function planEncoders({
   now = Date.now(),
   refetchSecPerFilmSecond = 0,
   contentionPenaltyFor = () => 1,
-  speedX = 0
+  speedX = 0,
+  holdStart = () => null
 }) {
   /** @type {PlanAction[]} */
   const stops = [];
@@ -686,7 +693,11 @@ export function planEncoders({
     });
   }
 
-  return [...stops, ...moves, ...starts, ...keeps];
+  const startsOrHeld = starts.map((start) => {
+    const because = holdStart(start.from);
+    return because ? { type: "hold", from: start.from, to: start.to, because } : start;
+  });
+  return [...stops, ...moves, ...startsOrHeld, ...keeps];
 }
 
 
@@ -1010,7 +1021,7 @@ function lastOf(windows) {
   return Math.max(...windows.map((span) => span.to));
 }
 
-function deadlineReaderFor(windows, segmentSeconds) {
+export function deadlineReaderFor(windows, segmentSeconds) {
   const perSegment = segmentSeconds > 0 ? segmentSeconds : 0;
   // A TABLE BY SEGMENT, filled once per plan. Read for every segment of every
   // arrangement the plan weighs, a search of every window for each index was

package/services/encode/EncodeRun.js

@@ -454,6 +454,11 @@ export class EncodeRun {
     this.clock.inputWaitEnds();
   }
 
+  /** @returns {boolean} Whether an input read of this run is waiting for bytes now. */
+  get isWaitingForInput() {
+    return this.clock.waitingForInput;
+  }
+
   /** @returns {boolean} Whether it is stopped where it stands, producing nothing. */
   get isSuspended() {
     return this.#state === ENCODE_RUN_STATE.SUSPENDED;

package/services/encode/PauseRule.js

@@ -0,0 +1,334 @@
+/**
+ * @file Whether an encoder making something less urgent runs beside the most
+ * urgent one, from what running it was measured to do (torrent-tv/meta#180,
+ * phase 4).
+ *
+ * Until this, everything less urgent than the leading band was stopped,
+ * whatever the leader did with the processor and whatever it needed by its
+ * deadline (`EncodeOrchestrator.shareTheMachine`). On a machine where the
+ * leader does not take all the processor — libx264 thread scaling, a hardware
+ * encoder whose work is on the device, a leader ahead of its deadline — the
+ * paused work waited for nothing; and a one-piece soundtrack copy at 150x was
+ * paused behind a picture it could not have slowed (Home Assistant r73).
+ *
+ * THE RULE. `L` is the leading run, `r` a less urgent one.
+ *
+ * 1. `L`'s need `s*` is the speed its deadlines ask for (film seconds per
+ *    second); infinite where a viewer already waits for what `L` is making.
+ * 2. `r` keeps running when, over the seconds it ran beside `L`, `L` still made
+ *    at least `s*` (finite need), or neither `L`'s speed nor its cores fell
+ *    below what they were without `r` by more than their own scatter (infinite
+ *    need). Otherwise `r` is paused. Both are read: memory-bandwidth contention
+ *    lowers the speed and not the cores, and on Home Assistant (r78, r79) a
+ *    short run's speed scattered by as much as its median from second to second
+ *    while its cores scattered by 0.02-0.2, so a slowdown is often visible in
+ *    the cores first. No number of cores enters: a fraction of a core can be
+ *    enough, and a free core does not cap what a new ffmpeg takes.
+ * 3. A paused `r` is tried when the processor left free (`F`, cores) is
+ *    unknown or exceeds what `r` drew when it last ran, or when `L` makes more
+ *    than `s*` by more than its scatter. With an infinite need it is tried only
+ *    once `L` has seconds without it to be compared against.
+ * 4. A run whose whole remaining stretch costs less processor than `L`'s
+ *    scatter over one second cannot be measured against `L` and is never
+ *    paused.
+ *
+ * NO ALTERNATION UNDER UNCHANGED LOAD. A pause for a measured slowdown is
+ * remembered for the pair with what it was measured under: `L`'s output and
+ * band, the other runs running, and the processor other work took. `r` is not
+ * tried beside `L` again until one of these changes — the others' draw by more
+ * than `r`'s own — so under constant load there is at most one try and one
+ * pause.
+ *
+ * WITHOUT READINGS NOTHING CHANGES. Where `L` has no per-second readings (no
+ * `/proc` to read an ffmpeg's processor from), or `r` has run beside `L` since
+ * before anything could be compared, the answer is null and the caller keeps
+ * the urgency rule it had.
+ *
+ * Readings are the per-second ones of `storage/processor-report.js`: each
+ * run's cores and the film it made per second of wall clock. Seconds in which
+ * `L` waited for its input say nothing about `r` and are left out.
+ */
+
+/**
+ * How many seconds of readings a run keeps. Enough for a baseline before a try
+ * and the seconds beside after it; `L`'s cost changes from piece to piece, so
+ * older seconds describe other pieces.
+ */
+const KEPT_SECONDS = 30;
+
+/**
+ * The fewest seconds a median and its scatter are taken from: with fewer,
+ * the scatter of one or two values says nothing.
+ */
+const LEAST_SECONDS = 3;
+
+/**
+ * @typedef {object} RunSecond
+ * @property {number} at - When the second ended, in milliseconds.
+ * @property {number} cores - What the run's ffmpeg used over it.
+ * @property {number | null} speed - Film made per second of wall clock.
+ * @property {Set<object>} running - The runs running (not paused) beside it.
+ * @property {boolean} waiting - Whether its input waited at the end of it.
+ */
+
+/**
+ * @typedef {object} PairConditions
+ * @property {string} address - `L`'s output.
+ * @property {boolean} urgent - `L`'s band.
+ * @property {number} priority
+ * @property {Set<object>} running - The other runs running, `L` and `r` aside.
+ * @property {number | null} others - Cores other work took.
+ */
+
+export class PauseRule {
+  /** @type {Map<object, RunSecond[]>} */
+  #seconds = new Map();
+
+  /** When the rule last let each run go. @type {Map<object, number>} */
+  #triedAt = new Map();
+
+  /** What the last run on each output drew, for the next run there. @type {Map<string, number>} */
+  #lastDrawOn = new Map();
+
+  /** Pauses for a measured slowdown, by leader, then by run. @type {Map<object, Map<object, PairConditions>>} */
+  #pairs = new Map();
+
+  /**
+   * One second of one run.
+   *
+   * @param {object} run
+   * @param {{ at: number, cores: number, speed: number | null }} reading
+   * @param {Iterable<object>} running - Every run running at the time.
+   * @param {boolean} [waiting]
+   */
+  noteSecond(run, { at, cores, speed }, running, waiting = false) {
+    if (!Number.isFinite(cores)) return;
+    const kept = this.#seconds.get(run) ?? [];
+    kept.push({ at, cores, speed: Number.isFinite(speed) ? speed : null, running: new Set(running), waiting: waiting === true });
+    while (kept.length > 0 && kept[0].at <= at - KEPT_SECONDS * 1000) kept.shift();
+    this.#seconds.set(run, kept);
+  }
+
+  /**
+   * A run that has ended: what it drew is kept for the next run on its output.
+   *
+   * @param {object} run
+   * @param {string} address
+   */
+  forget(run, address) {
+    const draw = this.#drawOf(run);
+    if (draw !== null && typeof address === "string") this.#lastDrawOn.set(address, draw);
+    this.#seconds.delete(run);
+    this.#triedAt.delete(run);
+    this.#pairs.delete(run);
+    for (const pairs of this.#pairs.values()) pairs.delete(run);
+  }
+
+  /**
+   * Whether `run` runs beside `leader` now.
+   *
+   * @param {object} params
+   * @param {object} params.leader - The leading run.
+   * @param {{ address: string, urgent: boolean, priority: number }} params.band - Where it leads.
+   * @param {object} params.run - A run less urgent than it.
+   * @param {string} params.address - `run`'s output.
+   * @param {number} params.need - `L`'s `s*`: film seconds per second, `Infinity`
+   *   where a viewer waits for what it is making, 0 where nothing is due.
+   * @param {number} params.remainingFilm - Film seconds `run` has left to make.
+   * @param {number | null} params.free - `F`: cores left free, or null.
+   * @param {number | null} params.others - Cores other work took, or null.
+   * @param {Iterable<object>} params.running - Every run running now.
+   * @param {number} params.now
+   * @returns {{ runs: boolean, because: string } | null} Null where nothing
+   *   was measured to decide from.
+   */
+  judge({ leader, band, run, address, need, remainingFilm, free, others, running, now }) {
+    const lead = (this.#seconds.get(leader) ?? []).filter((second) => !second.waiting && second.speed !== null);
+    if (lead.length === 0) return null;
+    const leadCores = middleAndScatter(lead.map((second) => second.cores));
+    const draw = this.#drawOf(run) ?? this.#lastDrawOn.get(address) ?? null;
+    const perFilm = this.#costPerFilm(run);
+    if (perFilm !== null && Number.isFinite(remainingFilm) && remainingFilm * perFilm < leadCores.scatter) {
+      return { runs: true, because: `its remaining ${remainingFilm.toFixed(1)}s of film cost ${(remainingFilm * perFilm).toFixed(3)} ` +
+        `CPU-s, less than the leader's scatter of ${leadCores.scatter.toFixed(3)} cores over one second` };
+    }
+    const without = lead.filter((second) => !second.running.has(run));
+    const otherRunning = new Set([...running].filter((other) => other !== leader && other !== run));
+    if (run.isSuspended === true) {
+      return this.#whetherToTry({ leader, band, run, need, lead, without, draw, free, others, otherRunning, now });
+    }
+    const since = this.#triedAt.get(run) ?? Number.NEGATIVE_INFINITY;
+    const beside = lead.filter((second) => second.running.has(run) && second.at > since);
+    if (beside.length < LEAST_SECONDS) {
+      // Let go by this rule and not measured yet: it runs until it is.
+      // Running since before anything could be compared: the urgency rule.
+      return this.#triedAt.has(run) ? { runs: true, because: `being measured beside the leader (${beside.length}s so far)` } : null;
+    }
+    const besideSpeed = middleAndScatter(beside.map((second) => second.speed));
+    if (Number.isFinite(need)) {
+      if (besideSpeed.middle >= need) {
+        return { runs: true, because: `the leader made ${besideSpeed.middle.toFixed(2)}x beside it over ${beside.length}s, ` +
+          `needing ${need.toFixed(2)}x` };
+      }
+      this.#remember(leader, run, { band, otherRunning, others });
+      return { runs: false, because: `the leader made ${besideSpeed.middle.toFixed(2)}x beside it over ${beside.length}s, ` +
+        `below the ${need.toFixed(2)}x its deadlines need` };
+    }
+    if (without.length < LEAST_SECONDS) {
+      return this.#triedAt.has(run) ? { runs: true, because: "nothing to compare the leader's speed with" } : null;
+    }
+    const alone = middleAndScatter(without.map((second) => second.speed));
+    const besideCores = middleAndScatter(beside.map((second) => second.cores));
+    const aloneCores = middleAndScatter(without.map((second) => second.cores));
+    const measured = `the leader made ${besideSpeed.middle.toFixed(2)}x on ${besideCores.middle.toFixed(2)} cores beside it ` +
+      `over ${beside.length}s, ${alone.middle.toFixed(2)}x (scatter ${alone.scatter.toFixed(2)}) on ` +
+      `${aloneCores.middle.toFixed(2)} cores (scatter ${aloneCores.scatter.toFixed(2)}) without it over ${without.length}s, ` +
+      "and a viewer waits for it";
+    if (alone.middle - besideSpeed.middle > alone.scatter || aloneCores.middle - besideCores.middle > aloneCores.scatter) {
+      this.#remember(leader, run, { band, otherRunning, others });
+      return { runs: false, because: measured };
+    }
+    return { runs: true, because: measured };
+  }
+
+  /**
+   * Whether a run not started yet, on `address` and less urgent than
+   * `leader`, would be let go at once: a start the rule would pause is not
+   * made (`EncodePlan` holds it). Without readings of the leader, it would.
+   *
+   * @param {object} params
+   * @param {object} params.leader
+   * @param {string} params.address
+   * @param {number} params.need
+   * @param {number | null} params.free
+   * @returns {{ runs: boolean, because: string }}
+   */
+  wouldStart({ leader, address, need, free }) {
+    const lead = (this.#seconds.get(leader) ?? []).filter((second) => !second.waiting && second.speed !== null);
+    if (lead.length === 0) {
+      return { runs: false, because: "nothing has measured what the leader does" };
+    }
+    const draw = this.#lastDrawOn.get(address) ?? null;
+    return this.#tryCondition({ need, lead, without: lead, draw, free });
+  }
+
+  /**
+   * Whether a paused run is let go to be measured beside the leader.
+   *
+   * @param {object} params
+   * @returns {{ runs: boolean, because: string }}
+   */
+  #whetherToTry({ leader, band, run, need, lead, without, draw, free, others, otherRunning, now }) {
+    const remembered = this.#pairs.get(leader)?.get(run);
+    const changed = remembered ? changeOf(remembered, { band, otherRunning, others, draw }) : null;
+    if (remembered) {
+      if (changed === null) {
+        return { runs: false, because: "it slowed the leader when last tried, and nothing it was tried under has changed" };
+      }
+      this.#pairs.get(leader)?.delete(run);
+    }
+    const verdict = this.#tryCondition({ need, lead, without, draw, free });
+    if (!verdict.runs) return verdict;
+    this.#triedAt.set(run, now);
+    return { runs: true, because: `tried beside the leader: ${verdict.because}` +
+      (remembered ? ` (${changed} changed since it was paused)` : "") };
+  }
+
+  /**
+   * Rule 3: the conditions under which a run not running is let go.
+   *
+   * @param {{ need: number, lead: RunSecond[], without: RunSecond[], draw: number | null, free: number | null }} params
+   * @returns {{ runs: boolean, because: string }}
+   */
+  #tryCondition({ need, lead, without, draw, free }) {
+    if (!Number.isFinite(need) && without.length < LEAST_SECONDS) {
+      return { runs: false, because: `a viewer waits for the leader, and it has run ${without.length}s without this one ` +
+        "to be compared with" };
+    }
+    const leadSpeed = middleAndScatter(lead.map((second) => second.speed));
+    if (free === null || !Number.isFinite(free)) {
+      return { runs: true, because: "the processor left free is unknown" };
+    }
+    if (free > (draw ?? 0)) {
+      return { runs: true, because: `${free.toFixed(2)} cores are free, more than the ` +
+        `${draw === null ? "unmeasured draw" : `${draw.toFixed(2)} cores`} it draws` };
+    }
+    if (Number.isFinite(need) && leadSpeed.middle - need > leadSpeed.scatter) {
+      return { runs: true, because: `the leader makes ${leadSpeed.middle.toFixed(2)}x, needing ${need.toFixed(2)}x` };
+    }
+    return { runs: false, because: `${free.toFixed(2)} cores are free, not more than the ` +
+      `${draw === null ? "?" : draw.toFixed(2)} cores it draws, and the leader makes ${leadSpeed.middle.toFixed(2)}x` +
+      (Number.isFinite(need) ? `, needing ${need.toFixed(2)}x` : " with a viewer waiting") };
+  }
+
+  /**
+   * @param {object} leader
+   * @param {object} run
+   * @param {{ band: { address: string, urgent: boolean, priority: number }, otherRunning: Set<object>, others: number | null }} under
+   */
+  #remember(leader, run, { band, otherRunning, others }) {
+    const pairs = this.#pairs.get(leader) ?? new Map();
+    pairs.set(run, { address: band.address, urgent: band.urgent === true, priority: band.priority, running: otherRunning,
+      others: Number.isFinite(others) ? others : null });
+    this.#pairs.set(leader, pairs);
+    this.#triedAt.delete(run);
+  }
+
+  /**
+   * The cores a run drew while it ran: the median of its seconds.
+   *
+   * @param {object} run
+   * @returns {number | null}
+   */
+  #drawOf(run) {
+    const seconds = this.#seconds.get(run) ?? [];
+    return seconds.length === 0 ? null : middleAndScatter(seconds.map((second) => second.cores)).middle;
+  }
+
+  /**
+   * CPU seconds per second of film, over the seconds in which it made film.
+   *
+   * @param {object} run
+   * @returns {number | null}
+   */
+  #costPerFilm(run) {
+    const costs = (this.#seconds.get(run) ?? []).filter((second) => second.speed > 0).map((second) => second.cores / second.speed);
+    return costs.length === 0 ? null : middleAndScatter(costs).middle;
+  }
+}
+
+/**
+ * What has changed since a pause for a slowdown, or null.
+ *
+ * @param {PairConditions} remembered
+ * @param {{ band: { address: string, urgent: boolean, priority: number }, otherRunning: Set<object>, others: number | null, draw: number | null }} now
+ * @returns {string | null}
+ */
+function changeOf(remembered, { band, otherRunning, others, draw }) {
+  if (remembered.address !== band.address || remembered.urgent !== (band.urgent === true) || remembered.priority !== band.priority) {
+    return "the leader's band";
+  }
+  if (remembered.running.size !== otherRunning.size || [...otherRunning].some((other) => !remembered.running.has(other))) {
+    return "the runs running";
+  }
+  if (remembered.others !== null && Number.isFinite(others) && draw !== null && remembered.others - others > draw) {
+    return "the processor other work takes";
+  }
+  return null;
+}
+
+/**
+ * The median and the median distance to it.
+ *
+ * @param {number[]} values
+ * @returns {{ middle: number, scatter: number }}
+ */
+function middleAndScatter(values) {
+  const median = (list) => {
+    const sorted = [...list].sort((left, right) => left - right);
+    const half = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 0 ? (sorted[half - 1] + sorted[half]) / 2 : sorted[half];
+  };
+  const middle = median(values);
+  return { middle, scatter: median(values.map((value) => Math.abs(value - middle))) };
+}

package/services/encode/ProcessorBudget.js

@@ -23,7 +23,7 @@ import { correctForAvailability, leftForEncoders } from "./available-share.js";
 import { contentionPenalty } from "./contention.js";
 
 export class ProcessorBudget {
-  /** @type {() => ({ share: number, forEncoders?: number, known: boolean } | null | undefined)} */
+  /** @type {() => ({ share: number, forEncoders?: number, known: boolean, freeCores?: number | null, otherCores?: number | null } | null | undefined)} */
   #reading;
 
   /** @type {import("./contention.js").ContentionPenalties | null} */
@@ -74,6 +74,27 @@ export class ProcessorBudget {
     return correctForAvailability(aloneSpeed, this.availability());
   }
 
+  /**
+   * The processor left free over the latest reading, in cores, or null where
+   * it was not read (torrent-tv/meta#180, phase 4).
+   *
+   * @returns {number | null}
+   */
+  freeCores() {
+    const free = this.availability()?.freeCores;
+    return Number.isFinite(free) ? free : null;
+  }
+
+  /**
+   * The processor other work took over the latest reading, in cores, or null.
+   *
+   * @returns {number | null}
+   */
+  otherCores() {
+    const others = this.availability()?.otherCores;
+    return Number.isFinite(others) ? others : null;
+  }
+
   /**
    * The measured penalties, as the plan and the runs read them.
    *

package/services/encode/RunClock.js

@@ -91,6 +91,16 @@ export class RunClock {
     }
   }
 
+  /**
+   * Whether an input read of this run is waiting for bytes now, whether or
+   * not the process is also stopped.
+   *
+   * @returns {boolean}
+   */
+  get waitingForInput() {
+    return this.#idleCauses - (this.#isStopped ? 1 : 0) > 0;
+  }
+
   /**
    * Milliseconds the process has been stopped so far.
    *

package/services/encode/quality/HostLoad.js

@@ -685,13 +685,25 @@ export class HostLoad {
       : null;
     // Of the cores this process may use where that is fewer than the host's
     // (torrent-tv/meta#180, phase 3).
-    this.hostAvailability = availableShareFrom({
+    const availability = availableShareFrom({
       systemBusy: share.systemShare,
       encoderShare: share.processShare,
       proxyShare,
       hostCores: cores,
       boundCores: sample.processor?.bound?.cores ?? null
     });
+    // The processor left free and what other work takes, in cores, for the
+    // pause rule (torrent-tv/meta#180, phase 4). Unknown stays null.
+    const ourShare = Number.isFinite(proxyShare) && Number.isFinite(share.processShare) ? proxyShare + share.processShare : null;
+    const reading = typeof this.#host.processorBetween === "function"
+      ? this.#host.processorBetween(previous.processor ?? null, sample.processor ?? null,
+        { systemShare: share.systemShare, ourShare, hostCores: cores })
+      : null;
+    this.hostAvailability = {
+      ...availability,
+      freeCores: Number.isFinite(reading?.freeCores) ? reading.freeCores : null,
+      otherCores: availability.known ? availability.unattributed * cores : null
+    };
     return proxyShare;
   }
 

package/services/server/ViewerRequests.js

@@ -828,7 +828,9 @@ export class ViewerRequests {
     logger.info(`playback held ${session.id} consumer=${consumerId}: delay ${seconds(delay)}s by ` +
       (holding.kind === "position-not-held" ? "the position, which nothing buffered covers" :
         `the ${holding.kind} of ${holding.track} #${holding.segment} in ${seconds(holding.atSeconds)}s against ` +
-        `${seconds(holding.aheadSeconds)}s of media before it${holding.requiresSource ? ", its input still downloading" : ""}`) +
+        `${seconds(holding.aheadSeconds)}s of media before it${holding.requiresSource ? ", its input still downloading" : ""}` +
+        (Number.isFinite(holding.sourceArrivalSeconds) ? ` until ${seconds(holding.sourceArrivalSeconds)}s by ` +
+          (holding.sourcePlanned ? "the torrent's queues" : "the measured download rate") : "")) +
       `; buffered ${seconds(forecast.bufferedSeconds)}s; rates ${rates.join(", ") || "none"}; download ${downloads.join(", ") || "none"}`);
   }
 

package/services/server/wire-outputs.js

@@ -1076,6 +1076,9 @@ export function wireOutputs({
     makeRun: ({ address, from, to, because }) => parts.encodeRuns.makeRunAt(address, from, to, because),
     segmentSeconds: parts.segmentDurationSec,
     contentionPenalties: parts.processor.penalties,
+    // The processor left free and what other work takes, for the pause rule
+    // (torrent-tv/meta#180, phase 4).
+    processor: parts.processor,
     startingSpeedFor: (address) => parts.encodeCost.speedForOutput(address),
     segmentCoverage,
     // HOW IT ASKS TO DECIDE AGAIN. A plan that refuses to place anything

package/services/storage/processor-report.js

@@ -286,11 +286,14 @@ function middleAndScatter(values) {
  * @param {(line: string) => void} params.log
  * @param {() => Array<{ pid: number, label: string, film: number | null }>} params.ffmpegRuns - The encoders running now, with the film each has made.
  * @param {() => boolean} [params.detailed]
+ * @param {(seconds: Map<number, { label: string, cores: number, speed: number | null }>) => void} [params.onRunSeconds] -
+ *   Each second's readings of every run, by process, for whoever decides
+ *   from them (`EncodeOrchestrator.noteRunSeconds`, torrent-tv/meta#180).
  * @param {number} [params.everyMs]
  * @param {number} [params.sayEveryMs]
  * @returns {{ stop: () => void }}
  */
-export function startProcessorReport({ log, ffmpegRuns, detailed = () => false, everyMs = 1000, sayEveryMs = 60_000 }) {
+export function startProcessorReport({ log, ffmpegRuns, detailed = () => false, onRunSeconds = () => {}, everyMs = 1000, sayEveryMs = 60_000 }) {
   let previous = null;
   let series = [];
   /** @type {Map<number, { label: string, cores: number[], speed: number[] }>} */
@@ -305,6 +308,15 @@ export function startProcessorReport({ log, ffmpegRuns, detailed = () => false,
     const shares = previous ? sharesBetween(previous, now) : null;
     const perRun = previous ? runSecondsBetween(previous, now) : new Map();
     previous = now;
+    if (perRun.size > 0) {
+      // A fault in whoever decides from the readings must not end the
+      // readings, nor reach the timer as an uncaught exception.
+      try {
+        onRunSeconds(perRun);
+      } catch (error) {
+        log(`processor: run seconds not handled: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
     if (!shares) return;
     series.push(shares);
     for (const [pid, second] of perRun) {

package/services/torrent/download/FutureDownload.js

@@ -1,27 +1,25 @@
 import { setImmediate as nextTurn } from "node:timers/promises";
 import { piecesOf } from "../demand/pieces.js";
 import { pieceStoreOf } from "../piece-store-of.js";
-import { compareBands } from "./bands.js";
 
 const BLOCK_BYTES = 16 * 1024;
 
-/** Estimate completion from observed queues and the public selection bands.
- * The native picker takes a band's pieces from its first up (the `sequential`
- * strategy), so an unqueued piece arrives after the band's pieces before it.
- * A piece whose every missing block is asked for arrives when its queues say,
- * and is not the band's to share out. A supplier is a peer that can be asked
- * for the piece now. Pieces without a measured supplier remain unknown. No
- * requests are changed.
+/** When the pieces whose every missing block is asked for arrive, from the
+ * queues that hold them. A block is reserved to the wire it was asked of, so a
+ * faster peer elsewhere does not bring it sooner (WebTorrent 2.8.5 `_request`,
+ * torrent.js:1758). Every other missing piece is left unknown: the start
+ * forecast brings those at the source's measured service, in its own media
+ * order (`viewer/playback-readiness.js`), one model of supply rather than a
+ * second one here (torrent-tv/meta#185). No requests are changed.
  * Times are conditional on the measured rate and successful verification.
  */
 export async function futureDownload(entries, { now = Date.now(), findStore = pieceStoreOf, isCurrent = () => true } = {}) {
   if (!isCurrent()) return new Map();
   const forecasts = new Map();
-  const pending = [];
   let steps = 0;
-  for (const { torrent, register, limit = null } of entries) {
+  for (const { torrent, register } of entries) {
     if (torrent.destroyed || torrent.ready === false) continue;
-    const wanted = new Map();
+    const wanted = new Set();
     for (const window of register.windows()) {
       const file = torrent.files?.[window.fileIndex];
       if (!file) continue;
@@ -29,10 +27,7 @@ export async function futureDownload(entries, { now = Date.now(), findStore = pi
         byteEnd: Math.min(window.byteEnd, file.length - 1), pieceLength: torrent.pieceLength });
       if (!range) continue;
       for (let piece = range.from; piece <= range.to; piece++) {
-        const previous = wanted.get(piece);
-        if (!previous || compareBands(window, previous) < 0) {
-          wanted.set(piece, { urgency: window.urgency, priority: window.priority, deadlineAt: window.deadlineAt });
-        }
+        wanted.add(piece);
         if (++steps % 256 === 0) {
           await nextTurn();
           if (!isCurrent()) return new Map();
@@ -63,7 +58,7 @@ export async function futureDownload(entries, { now = Date.now(), findStore = pi
     }
     const store = findStore(torrent);
     const arrivals = new Map();
-    for (const [index, band] of wanted) {
+    for (const index of wanted) {
       const present = store?.locationOf ? store.locationOf(index) !== "missing" : torrent.bitfield?.get(index);
       if (present) {
         arrivals.set(index, now);
@@ -81,33 +76,6 @@ export async function futureDownload(entries, { now = Date.now(), findStore = pi
         at = Math.max(at, arrival);
       }
       arrivals.set(index, at);
-      // EVERY MISSING BLOCK ASKED FOR: the queues holding them say when it
-      // arrives. Each block is reserved to the wire it was asked of, so a faster
-      // peer elsewhere does not bring it sooner, and its bytes are not the
-      // band's to share out (torrent-tv/meta#178 review, WebTorrent 2.8.5
-      // `_request`, torrent.js:1758).
-      if (at !== null) {
-        if (++steps % 256 === 0) {
-          await nextTurn();
-          if (!isCurrent()) return new Map();
-        }
-        continue;
-      }
-      const remaining = piece?.missing;
-      const holders = [];
-      for (const wire of torrent.wires ?? []) {
-        // Only a peer that can be asked for it now: one choking us is asked for
-        // nothing outside the pieces it allows, whatever it carried before.
-        if (wire.destroyed || !wire.peerPieces?.get(index) || !mayAsk(wire, index)) continue;
-        // What it carried with its queue kept full, where it has been seen so:
-        // its speed while our selection gave it little measures our asking
-        // (`SelectionLimit`, torrent-tv/meta#178).
-        const rate = Number(limit?.capacityOf?.(wire) ?? wire.downloadSpeed?.());
-        if (Number.isFinite(rate) && rate > 0) holders.push({ wire, rate });
-      }
-      pending.push({ arrivals, index, ...band, holders, remaining:
-        Number.isSafeInteger(remaining) && remaining > 0 && remaining <= piece.length && holders.length > 0
-          ? remaining : null });
       if (++steps % 256 === 0) {
         await nextTurn();
         if (!isCurrent()) return new Map();
@@ -115,77 +83,5 @@ export async function futureDownload(entries, { now = Date.now(), findStore = pi
     }
     forecasts.set(torrent, { measuredAt: now, arrivals });
   }
-  // WITHIN A BAND, IN THE ORDER THE PIECES COME. The picker walks each
-  // selection from its first piece up (WebTorrent 2.8.5's default `sequential`
-  // strategy, which this proxy keeps), so a piece of a band arrives once those
-  // before it have. Charged the whole band's end instead, a band of many
-  // segments — the map states one per stretch of a level since 2.97.27 — would
-  // put its nearest piece at its farthest piece's time (torrent-tv/meta#178).
-  //
-  // AND IN PARALLEL WHERE THE PEERS DIFFER. A piece is brought by the peers
-  // holding it, each from when it has brought what was asked of it before, and
-  // no sooner than the measured supply of every peer that holds a piece still
-  // to come carries all the bytes ahead of it. Summed one piece after another
-  // at its own holders' speed, a two-hour film whose far pieces each had a few
-  // unchoked holders was forecast to arrive in 127 838 s at 2.33 MB/s, and a
-  // seek was held for 39 s on it (r49, torrent-tv/meta#178). One holder for
-  // every piece gives the sum it was; a piece nobody can be asked for still
-  // leaves every piece after it unknown.
-  pending.sort((left, right) => compareBands(left, right) || left.index - right.index);
-  const supply = new Map();
-  for (const { holders } of pending) for (const { wire, rate } of holders) supply.set(wire, rate);
-  const total = [...supply.values()].reduce((sum, rate) => sum + rate, 0);
-  const freeAt = new Map();
-  let ahead = 0;
-  let known = true;
-  for (const { arrivals, index, holders, remaining } of pending) {
-    if (!known || remaining === null || !(total > 0)) {
-      known = false;
-      continue;
-    }
-    ahead += remaining;
-    const finish = Math.max(sharedFinish(holders, freeAt, remaining, now), now + ahead / total * 1000);
-    for (const { wire } of holders) freeAt.set(wire, Math.max(freeAt.get(wire) ?? now, finish));
-    arrivals.set(index, finish);
-  }
   return isCurrent() ? forecasts : new Map();
 }
-
-/**
- * When peers bringing `bytes` together finish: each starts when it is free
- * and brings at its own rate, so the finish is where their combined bytes
- * reach `bytes` (the earliest of them working alone at first, more joining as
- * they come free).
- *
- * @param {Array<{ wire: object, rate: number }>} holders - Bytes per second.
- * @param {Map<object, number>} freeAt - Milliseconds.
- * @param {number} bytes
- * @param {number} now - Milliseconds.
- * @returns {number} Milliseconds.
- */
-function sharedFinish(holders, freeAt, bytes, now) {
-  const starts = holders.map(({ wire, rate }) => ({ at: Math.max(now, freeAt.get(wire) ?? now), rate }))
-    .sort((left, right) => left.at - right.at);
-  let rate = 0;
-  let weighted = 0;
-  for (let index = 0; index < starts.length; index++) {
-    rate += starts[index].rate;
-    weighted += starts[index].rate * starts[index].at;
-    const finish = (bytes * 1000 + weighted) / rate;
-    if (index === starts.length - 1 || finish <= starts[index + 1].at) return finish;
-  }
-  return now;
-}
-
-/**
- * Whether this peer can be asked for this piece now: it is not choking us, or
- * it allows this piece while it does (BEP 6, WebTorrent 2.8.5 `_updateWire`).
- *
- * @param {{ peerChoking?: boolean, hasFast?: boolean, peerAllowedFastSet?: number[] }} wire
- * @param {number} index
- * @returns {boolean}
- */
-function mayAsk(wire, index) {
-  if (wire.peerChoking !== true) return true;
-  return wire.hasFast === true && Array.isArray(wire.peerAllowedFastSet) && wire.peerAllowedFastSet.includes(index);
-}

package/services/viewer/playback-readiness.js

@@ -380,7 +380,7 @@ export function predictPlaybackReadiness(input = {}) {
         const arrival = (range.availableAt - now) / 1000;
         // The entire protocol piece becomes readable after verification;
         // bytes inside it never arrive proportionally to their file address.
-        sourceByteService.get(id).push({ start: range.start, end: range.end, begin: arrival, finish: arrival });
+        sourceByteService.get(id).push({ start: range.start, end: range.end, begin: arrival, finish: arrival, planned: true });
       }
     }
   }
@@ -409,6 +409,7 @@ export function predictPlaybackReadiness(input = {}) {
   for (const job of jobs) {
     const { track, trackIndex, segment, sizeBits, encodeWork, sourceByteIntervals } = job;
     let sourceArrivalAt = 0;
+    const plan = { finish: 0 };
     for (const [sourceId, ranges] of sourceByteIntervals) {
       const source = sourceState.get(sourceId);
       if (!source) {
@@ -417,7 +418,7 @@ export function predictPlaybackReadiness(input = {}) {
       for (const interval of ranges) {
         const missing = uncoveredIntervals(interval, sourceByteCoverage.get(sourceId) ?? []);
         if (missing.length === 0) {
-          sourceArrivalAt = Math.max(sourceArrivalAt, latestArrival(interval, sourceArrivals.get(sourceId)));
+          sourceArrivalAt = Math.max(sourceArrivalAt, latestArrival(interval, sourceArrivals.get(sourceId), plan));
           continue;
         }
 
@@ -468,10 +469,13 @@ export function predictPlaybackReadiness(input = {}) {
     }
     const producedAt = job.produced || encodeWork === 0 ? 0 : processing.finish(encodeWork, admittedAt);
     trackFinish[trackIndex] = Math.max(trackFinish[trackIndex], producedAt);
-    productions.push({ at: producedAt, trackIndex, segment, requiresSource: sourceArrivalAt > 0 });
+    const sourcePlanned = sourceArrivalAt > 0 && plan.finish >= sourceArrivalAt;
+    productions.push({ at: producedAt, trackIndex, segment, requiresSource: sourceArrivalAt > 0, sourceArrivalAt,
+      sourcePlanned });
     const deliveryAt = link.finish(sizeBits, Math.max(transferFinish, producedAt));
     transferFinish = deliveryAt;
-    completions.push({ at: deliveryAt + finiteNonNegative(track.appendSeconds), trackIndex, segment });
+    completions.push({ at: deliveryAt + finiteNonNegative(track.appendSeconds), trackIndex, segment, sourceArrivalAt,
+      sourcePlanned });
   }
 
   const constraints = [];
@@ -479,10 +483,12 @@ export function predictPlaybackReadiness(input = {}) {
   // largest of thousands, and the log could only say that some term was
   // positive while the picture stood for 17 s (torrent-tv/meta#178).
   let holding = null;
-  const constrain = (value, kind, trackIndex, segment, atSeconds, aheadSeconds, requiresSource) => {
+  const constrain = (value, kind, trackIndex, segment, atSeconds, aheadSeconds, requiresSource,
+    sourceArrivalAt = 0, sourcePlanned = false) => {
     constraints.push(value);
     if (value > 0 && (holding === null || value > holding.value)) {
-      holding = { value, kind, trackIndex, segment, atSeconds, aheadSeconds, requiresSource };
+      holding = { value, kind, trackIndex, segment, atSeconds, aheadSeconds, requiresSource, sourceArrivalAt,
+        sourcePlanned };
     }
   };
   const end = rescale(fromSeconds(duration), unit);
@@ -501,7 +507,8 @@ export function predictPlaybackReadiness(input = {}) {
       for (const range of completion.segment.ranges) addMediaRange(delivered, range);
       after = contiguousEnd(delivered, at);
       const ahead = secondsAhead(earliest(before, trackEnd), at);
-      constrain(completion.at - ahead, "delivery", trackIndex, completion.segment.index, completion.at, ahead, false);
+      constrain(completion.at - ahead, "delivery", trackIndex, completion.segment.index, completion.at, ahead, false,
+        completion.sourceArrivalAt, completion.sourcePlanned);
       if (compare(after, before) <= 0 && completion.segment.ranges.some(({ start }) => compare(start, before) > 0)) {
         // A timestamp hole cannot be repaired by waiting longer. Keep it
         // distinct from an unavailable rate or a slow but finite service.
@@ -524,7 +531,7 @@ export function predictPlaybackReadiness(input = {}) {
         : Math.max(0, state.tailEndSeconds - toSeconds(before));
       const ahead = Math.max(0, secondsAhead(before, at) - Math.min(reserve, left) * Number(production.requiresSource));
       constrain(production.at - ahead, "production", trackIndex, production.segment.index, production.at, ahead,
-        production.requiresSource);
+        production.requiresSource, production.sourceArrivalAt, production.sourcePlanned);
     }
   }
   if (trackState.some(({ tail }) => tail.length > 0)) {
@@ -548,7 +555,11 @@ export function predictPlaybackReadiness(input = {}) {
     holdingBy: ready ? null : holding === null ? (originReady ? null : { kind: "position-not-held" })
       : { kind: holding.kind, track: tracks[holding.trackIndex]?.id ?? holding.trackIndex,
         segment: holding.segment, atSeconds: holding.atSeconds, aheadSeconds: holding.aheadSeconds,
-        requiresSource: holding.requiresSource },
+        requiresSource: holding.requiresSource,
+        // When its input's last bytes come, and whether the torrent thread's
+        // queues say so rather than the source's measured service.
+        ...(holding.sourceArrivalAt > 0 ? { sourceArrivalSeconds: holding.sourceArrivalAt,
+          sourcePlanned: holding.sourcePlanned } : {}) },
     preparedUntilSeconds: Math.min(duration, ...trackState.map((state, index) => {
       const ranges = state.clientRanges.map((range) => ({ ...range }));
       for (const item of productions.filter((item) => item.trackIndex === index && item.at <= delay)) {
@@ -600,6 +611,7 @@ function scheduleTail({ trackState, sourceState, sourceByteCoverage, sourceArriv
     return state;
   };
   const next = trackState.map(() => 0);
+  const plan = { finish: 0 };
   let delivered = transferFinish;
   for (;;) {
     // The next piece in media order across the tracks, as the near window orders them.
@@ -635,6 +647,7 @@ function scheduleTail({ trackState, sourceState, sourceByteCoverage, sourceArriv
       work = Math.max(0, work);
     }
     let sourceArrivalAt = 0;
+    plan.finish = 0;
     if (work > 0) {
       if (!state.curve) return { reason: "encode-rate-unavailable" };
       const trackSources = Array.isArray(track.sourceIds) ? track.sourceIds : [];
@@ -653,7 +666,7 @@ function scheduleTail({ trackState, sourceState, sourceByteCoverage, sourceArriv
         let order = 0;
         for (const range of ranges) {
           // Bytes the torrent thread planned, or the near window brought, come when they were to come.
-          sourceArrivalAt = Math.max(sourceArrivalAt, latestArrival(range, sourceArrivals.get(sourceId)));
+          sourceArrivalAt = Math.max(sourceArrivalAt, latestArrival(range, sourceArrivals.get(sourceId), plan));
           const after = missingBefore(bytes, range.end);
           if (after > missingBefore(bytes, range.start)) order = Math.max(order, after);
         }
@@ -703,10 +716,13 @@ function scheduleTail({ trackState, sourceState, sourceByteCoverage, sourceArriv
     // hole stops the media is decided in the near window, in exact time.
     const ahead = Math.max(0, startsAt - position);
     const requiresSource = sourceArrivalAt > 0;
-    constrain(completedAt - ahead, "delivery", trackIndex, segment.index, completedAt, ahead, false);
+    const sourcePlanned = requiresSource && plan.finish >= sourceArrivalAt;
+    constrain(completedAt - ahead, "delivery", trackIndex, segment.index, completedAt, ahead, false, sourceArrivalAt,
+      sourcePlanned);
     const covered = Math.max(0, ahead - Math.min(reserve, Math.max(0, state.tailEndSeconds - startsAt)) *
       Number(requiresSource));
-    constrain(producedAt - covered, "production", trackIndex, segment.index, producedAt, covered, requiresSource);
+    constrain(producedAt - covered, "production", trackIndex, segment.index, producedAt, covered, requiresSource,
+      sourceArrivalAt, sourcePlanned);
   }
 }
 
@@ -1023,7 +1039,16 @@ function indexedArrivals(ranges) {
     .map(range => ({ ...range, maximumEnd: maximumEnd = Math.max(maximumEnd, range.end) }));
 }
 
-function latestArrival(interval, ranges = []) {
+/**
+ * When the last of an interval's bytes arrives, by the arrivals indexed; with
+ * `plan`, the latest of those the torrent thread's queues gave is kept in it.
+ *
+ * @param {{ start: number, end: number }} interval
+ * @param {Array<{ start: number, end: number, finish: number, maximumEnd: number, planned?: boolean }>} [ranges]
+ * @param {{ finish: number } | null} [plan]
+ * @returns {number}
+ */
+function latestArrival(interval, ranges = [], plan = null) {
   let low = 0, high = ranges.length;
   while (low < high) {
     const middle = (low + high) >>> 1;
@@ -1032,7 +1057,10 @@ function latestArrival(interval, ranges = []) {
   }
   let finish = 0;
   for (let index = low; index < ranges.length && ranges[index].start < interval.end; index++) {
-    if (ranges[index].end > interval.start) finish = Math.max(finish, ranges[index].finish);
+    if (ranges[index].end > interval.start) {
+      finish = Math.max(finish, ranges[index].finish);
+      if (plan && ranges[index].planned) plan.finish = Math.max(plan.finish, ranges[index].finish);
+    }
   }
   return finish;
 }