@torrent-tv/proxy 2.76.3 → 2.76.5

package/services/hls-session-manager.js

@@ -20,7 +20,7 @@ import { logger } from "../utils/logger.js";
 import { ContainerFactory } from "./container/ContainerFactory.js";
 import { readMachineState, readProcessCpuSeconds, readProxyCpuSeconds, readSystemCpu, shareOfMachine } from "./host-load.js";
 import { speedFromReadings } from "./encoder-readings.js";
-import { availableShareFrom, correctForAvailability } from "./available-share.js";
+import { availableShareFrom } from "./available-share.js";
 import { contentionPenalty } from "./contention.js";
 import { minimumBufferFrom } from "./supply-margin.js";
 import { baseDrawFrom, costPerMegabyteFrom } from "./torrent-cost.js";
@@ -29,6 +29,8 @@ import {
   ENCODE_RUN_EVENT,
   ENCODE_RUN_STATE,
   INITIAL_RUN_STATE,
+  liveRunsOf,
+  runStateOf,
   processCanBeSignalled,
   wireState
 } from "./encode/encode-run-state.js";
@@ -42,7 +44,6 @@ import {
   chooseSoftwareEncodeSettings,
   pickSoftwarePreset,
   canSustainOutput,
-  speedBar,
   maxrateKbpsFor,
   nominalKbpsForHeight,
   nominalKbpsForMaxrate,
@@ -68,6 +69,8 @@ import { masterPlaylistText, mediaPlaylistText, segmentIndexForTime } from "./ou
 import { SourceFiles, sourceDecodeCharacteristics } from "./source/SourceFile.js";
 import { ProducedIndex } from "./produced-index.js";
 import { SegmentStore } from "./encode/SegmentStore.js";
+import { EncodeCost } from "./quality/EncodeCost.js";
+import { endOfRun } from "./encode/EncodeRun.js";
 import {
   buildRunCommand,
   ffmpegSeconds,
@@ -1338,72 +1341,6 @@ export function describeGridDrift(published, live) {
 
 
 
-/**
- * Every run this session has going, earliest first.
- *
- * A session holds as many as the machine affords, because one output can be
- * watched from more than one place: a viewer who jumps back gets a run of their
- * own rather than dragging the picture away from a viewer watching ahead.
- *
- * @param {{ runs?: Set<object> }} session
- * @returns {object[]}
- */
-function runsOf(session) {
-  const runs = session?.runs instanceof Set ? [...session.runs] : [];
-  return runs.sort((left, right) => left.from - right.from);
-}
-
-/**
- * The runs of this session that still have a process.
- *
- * @param {{ runs?: Set<object> }} session
- * @returns {object[]}
- */
-function liveRunsOf(session) {
-  return runsOf(session).filter((run) => run.isAlive);
-}
-
-/**
- * What this session's encoding is doing, as one state.
- *
- * The most advanced state among its live runs: a session with anything
- * producing IS producing, whatever else it has going. A session that has never
- * started a run, or whose runs have all ended, is at the table's own initial
- * state — which is what "nothing is encoding" means.
- *
- * @param {{ runs?: Set<object> }} session
- * @returns {string}
- */
-function runStateOf(session) {
-  let answer = INITIAL_RUN_STATE;
-  let rank = -1;
-  for (const run of runsOf(session)) {
-    const at = RUN_STATE_ORDER.indexOf(run.state);
-    if (at > rank) {
-      rank = at;
-      answer = run.state;
-    }
-  }
-  return answer;
-}
-
-/**
- * How advanced a run state is, for reducing several runs to one answer.
- *
- * Producing outranks starting, and both outrank a run that has ended: what a
- * caller asking "what is this session's encoding doing" wants to know is
- * whether anything is being made, not what the quietest of them is up to.
- */
-const RUN_STATE_ORDER = [
-  ENCODE_RUN_STATE.ENDED_FAILED,
-  ENCODE_RUN_STATE.ENDED_COMPLETE,
-  ENCODE_RUN_STATE.STOPPED,
-  ENCODE_RUN_STATE.IDLE,
-  ENCODE_RUN_STATE.RETRY_WAIT,
-  ENCODE_RUN_STATE.SUSPENDED,
-  ENCODE_RUN_STATE.STARTING,
-  ENCODE_RUN_STATE.PRODUCING
-];
 
 /**
  * Whether this output is cut at times we hand the muxer, rather than at a
@@ -1569,51 +1506,12 @@ export class HlsSessionManager {
    */
   #sessionCreateLatencies = [];
 
-  /**
-   * What decoding costs for a source this proxy has actually run, keyed by
-   * `sourceKey:fileIndex` — seconds of work per second of video, with a version
-   * that rises whenever a faster reading replaces the one held.
-   *
-   * The startup clips are H.264 and a source that has to be re-encoded usually
-   * is not, so their model is a first approximation. This is the file itself,
-   * measured by the encoder that is running on it, and it replaces the model
-   * for that file as soon as it exists. Held for the life of the process: it
-   * describes a source, and the same source is commonly opened again.
-   *
-   * @type {Map<string, { costSec: number, version: number }>}
-   */
-  #observedDecodeCost = new Map();
-  /**
-   * What copying costs, per source file, learned the same way: `key ->
-   * { costSec, readings, version }`. A copy is what runs BESIDE a rung being
-   * warmed, and pricing it at nothing is what let a host be told it had a whole
-   * machine for the rung.
-   *
-   * @type {Map<string, { costSec: number, readings: number[], version: number }>}
-   */
-  #observedCopyCost = new Map();
-
-  /**
-   * What encoding one audio TRACK of one file costs this host, in seconds of
-   * work per second of video. Keyed by source, file and track, because two
-   * tracks of one film are not the same encode: a 5.1 AC-3 dub and a stereo
-   * AAC original decode and mix differently.
-   *
-   * Measured exactly as the copy's price is — from an audio-only session's own
-   * reported speed, past its start, alone on the machine, and never while the
-   * torrent is what is short.
-   *
-   * @type {Map<string, { costSec: number, readings: number[], version: number }>}
-   */
-  #observedAudioCost = new Map();
-
-  /**
-   * The last "not offering" line written, so the same one is not written again.
-   * See the end of {@link HlsSessionManager##sustainableHeights}.
-   *
-   * @type {string}
-   */
-  #lastOfferLine = "";
+  // What an encoder taught this host — the cost of decoding a file, of
+  // copying its picture, of each of its soundtracks — is held by the object
+  // that reads it (`quality/EncodeCost.js`), together with the last refusal
+  // it printed. The three methods that LEARN those costs are still here and
+  // write into it; moving them is the next step, and until then there must
+  // not be two copies of one reading.
   /** The previous reading of the machine, to compare the next one against. */
   #hostLoadSample = null;
   /** The previous reading taken while nothing was encoding, for the torrent's own cost. */
@@ -1802,11 +1700,30 @@ export class HlsSessionManager {
     // What encoders there should be on each output, and where. Given the two
     // things only this class can answer: how many this machine can afford, and
     // how to make one.
+    // What encoding costs this machine, and which heights follow from it. Given
+    // what it cannot work out for itself: which sessions belong to one file, the
+    // host's own readings AT THE MOMENT OF THE QUESTION rather than copied, how
+    // a soundtrack is keyed, how many encoders are running, and what a file
+    // costs merely by being fetched.
+    this.encodeCost = new EncodeCost({
+      liveOutputs: this.liveOutputs,
+      host: () => ({
+        benchmark: this.softwarePresetBenchmark,
+        decodeModel: this.decodeCostModel,
+        contentionPenalties: this.contentionPenalties,
+        availability: this.hostAvailability
+      }),
+      audioCostKey: (session) => this.#audioCostKey(session),
+      runningEncoders: () => this.#runningEncoders(),
+      encodersRunningNow: () => this.#encodersRunningNow(),
+      torrentCostSecFor: (session) => this.#torrentCostSecFor(session)
+    });
     this.encodeOrchestrator = new EncodeOrchestrator({
       maxRunsFor: (address) => this.maxRunsForOutput(address),
       makeRun: ({ address, from }) => this.#makeRunAt(address, from),
       segmentSeconds: this.segmentDurationSec,
       restartCostSec: RUN_RESTART_COST_SEC,
+      lookaheadSegments: Math.ceil(this.lookaheadSeconds / this.segmentDurationSec),
       logger
     });
     // Where each file is cut, held once per file and grid rather than once per
@@ -2447,7 +2364,7 @@ export class HlsSessionManager {
       ? startAtLadderTop(chosenBudget, outputFps, this.softwarePresetBenchmark, {
           decodeModel: this.decodeCostModel,
           source: sourceDecode,
-          observedDecodeCostSec: this.#observedDecodeCost.get(SourceFiles.keyFor(sourceKey, fileIndex))?.costSec ?? null,
+          observedDecodeCostSec: this.encodeCost.decodeCost.get(SourceFiles.keyFor(sourceKey, fileIndex))?.costSec ?? null,
           requiredSpeed: this.#requiredSpeedFor(sourceKey, fileIndex)
         })
       : chosenBudget;
@@ -2584,7 +2501,7 @@ export class HlsSessionManager {
       // field can say what the prediction was worth once the step runs. Null
       // when the step was never judged — a copied stream needs no encoder and
       // is never predicted.
-      predictedSpeedWhenOffered: this.lastPredictedByHeight?.get(output.encodeHeight) ?? null,
+      predictedSpeedWhenOffered: this.encodeCost.lastPredictedByHeight?.get(output.encodeHeight) ?? null,
       lastPredictionRatio: null,
       // The NAME of this rung, fixed at the height that was asked for. It is
       // deliberately not the height being encoded: a viewer who picked 480p on
@@ -5495,7 +5412,7 @@ export class HlsSessionManager {
       // the honest extent of its claim, and it is a measured figure rather than
       // a chosen one — the same allowance the browser sizes its cushion from.
       const willReach = run.head + lookaheadSegments;
-      const allowed = Number.isInteger(run.to) && run.to >= run.from ? run.to : lastIndex;
+      const allowed = Number.isFinite(endOfRun(run)) ? run.to : lastIndex;
       claims.push({ from: run.from, to: Math.min(allowed, willReach) });
     }
     const takenAt = (index) =>
@@ -7260,7 +7177,7 @@ export class HlsSessionManager {
     // outlived the rung: a rung the host cannot hold went on being offered, and
     // went on passing every route guard, after the viewer had left it.
     // Everything else is fixed for the session's life.
-    const observed = this.#observedDecodeCost.get(owner.file.key) ?? null;
+    const observed = this.encodeCost.decodeCost.get(owner.file.key) ?? null;
     // Every rung a live viewer has on screen. One answer was enough while a
     // picture had one viewer; two of them can be on two rungs, and withdrawing
     // either is withdrawing a stream that is playing.
@@ -7276,14 +7193,14 @@ export class HlsSessionManager {
     // the menu would keep the answer computed before either was measured — on
     // a copied picture, which is the case they exist for, the decode version
     // never moves at all, so the cache would never be recomputed.
-    const copyVersion = this.#observedCopyCost.get(owner.file.key)?.version ?? 0;
+    const copyVersion = this.encodeCost.copyCost.get(owner.file.key)?.version ?? 0;
     const torrentCost = this.#observedTorrentCostPerMegabyte ?? 0;
     // The soundtrack's price is an input too, and so is how many encoders of
     // this family are running: both move the answer, and an answer cached
     // across them is the stale menu this key exists to prevent.
     const audioVersion = [...this.liveOutputs.familyOf(owner)]
       .filter((member) => member.audioOnly === true)
-      .map((member) => this.#observedAudioCost.get(this.#audioCostKey(member))?.version ?? 0)
+      .map((member) => this.encodeCost.audioCost.get(this.#audioCostKey(member))?.version ?? 0)
       .reduce((total, one) => total + one, 0);
     const running = [...this.liveOutputs.familyOf(owner)]
       .filter((member) => processCanBeSignalled(runStateOf(member))).length;
@@ -7345,13 +7262,13 @@ export class HlsSessionManager {
     // the rung that taught the lesson would be the first to be dropped, and
     // every route guard reads this list: its next segment would 404 on a stream
     // that is playing, with its own encoder still running.
-    const answer = this.#sustainableHeights({
+    const answer = this.encodeCost.sustainableHeights({
       heights: ordered,
       ownHeight: own,
       playingHeights,
       // What each rung was actually seen doing in this session, which is the
       // only thing a live reading may speak for.
-      measuredHeights: this.#measuredRungSpeeds(owner),
+      measuredHeights: this.encodeCost.measuredRungSpeeds(owner),
       // The speed this file's supply demands, measured by its own reader on
       // this swarm. A well-seeded film and a thin one ask different speeds of
       // the same machine, so the bar belongs to the pair, not to the host.
@@ -7359,10 +7276,10 @@ export class HlsSessionManager {
       // What the family is already spending while a rung is considered. The
       // picture being COPIED is the common case and used to be priced at
       // nothing; measured, it is about an eighth of the machine.
-      concurrentCostSec: this.#committedCostOf(owner),
+      concurrentCostSec: this.encodeCost.committedCostOf(owner),
       // So a height already being produced is not charged for itself when it is
-      // judged. See the subtraction in #sustainableHeights.
-      runningCostByHeight: this.#runningCostByHeight(owner),
+      // judged. See the subtraction in EncodeCost#sustainableHeights.
+      runningCostByHeight: this.encodeCost.runningCostByHeight(owner),
       sourceWidth: Number(owner.file.width) || 0,
       sourceHeight: Math.round(Number(owner.file.height) || 0),
       fps: Number(owner.output.outputFps) || TRANSCODE_FPS,
@@ -7402,7 +7319,7 @@ export class HlsSessionManager {
    * @returns {number | null}
    */
   #observedDecodeCostFor(session) {
-    const entry = this.#observedDecodeCost.get(session.file.key);
+    const entry = this.encodeCost.decodeCost.get(session.file.key);
     return entry ? entry.costSec : null;
   }
 
@@ -7550,7 +7467,7 @@ export class HlsSessionManager {
       if (kind !== "audio") {
         return;
       }
-      const others = this.#pricedConcurrentCost(session);
+      const others = this.encodeCost.pricedConcurrentCost(session);
       if (others === null) {
         return; // something running has no price; nothing can be attributed
       }
@@ -7639,14 +7556,14 @@ export class HlsSessionManager {
       return;
     }
     const key = session.file.key;
-    const known = this.#observedCopyCost.get(key);
+    const known = this.encodeCost.copyCost.get(key);
     const readings = [...(known?.readings ?? []), costSec].slice(-DECODE_LEARNING_READINGS);
     const median = medianOf(readings);
     if (!movedBeyondScatter(known?.costSec ?? null, median, readings)) {
-      this.#observedCopyCost.set(key, { ...known, readings });
+      this.encodeCost.copyCost.set(key, { ...known, readings });
       return;
     }
-    this.#observedCopyCost.set(key, { costSec: median, readings, version: (known?.version ?? 0) + 1 });
+    this.encodeCost.copyCost.set(key, { costSec: median, readings, version: (known?.version ?? 0) + 1 });
     logger.info(
       `transcode: ${session.file.name} copies at ${(1 / median).toFixed(2)}x on this host ` +
         `(median of ${readings.length}, latest ${speed.toFixed(2)}x)`
@@ -7680,20 +7597,46 @@ export class HlsSessionManager {
       return;
     }
     const key = this.#audioCostKey(session);
-    const known = this.#observedAudioCost.get(key);
+    const known = this.encodeCost.audioCost.get(key);
     const readings = [...(known?.readings ?? []), costSec].slice(-DECODE_LEARNING_READINGS);
     const median = medianOf(readings);
     if (!movedBeyondScatter(known?.costSec ?? null, median, readings)) {
-      this.#observedAudioCost.set(key, { ...known, readings });
+      this.encodeCost.audioCost.set(key, { ...known, readings });
       return;
     }
-    this.#observedAudioCost.set(key, { costSec: median, readings, version: (known?.version ?? 0) + 1 });
+    this.encodeCost.audioCost.set(key, { costSec: median, readings, version: (known?.version ?? 0) + 1 });
     logger.info(
       `transcode: ${session.file.name} encodes audio track ${session.audioTrackIndex ?? 0} at ` +
         `${(1 / median).toFixed(2)}x on this host (median of ${readings.length}, latest ${speed.toFixed(2)}x)`
     );
   }
 
+  /**
+   * What this file costs the machine merely by being fetched and delivered
+   * while it is watched, in seconds of work per second of video.
+   *
+   * A viewer consumes the file at its own byte rate, and every one of those
+   * bytes is downloaded, verified and pushed by this process. Priced per
+   * megabyte from readings taken while nothing was encoding, so the two
+   * measurements do not contain each other. Zero while either term is unmeasured
+   * — a guess here would refuse rungs on arithmetic nobody performed.
+   *
+   * @param {HlsSession} session
+   * @returns {number}
+   */
+  #torrentCostSecFor(session) {
+    const perMegabyte = this.#observedTorrentCostPerMegabyte;
+    const megabytesPerSecond = this.#torrentMegabytesPerSecond(
+      session.file.sourceKey,
+      session.file.fileIndex,
+      this.#fileLengthByKey.get(session.file.key) ?? null,
+      session.file.durationSeconds
+    );
+    return perMegabyte !== null && megabytesPerSecond !== null
+      ? perMegabyte * megabytesPerSecond
+      : 0;
+  }
+
   /**
    * @param {HlsSession} session
    * @returns {string}
@@ -7740,7 +7683,7 @@ export class HlsSessionManager {
       return;
     }
     const key = session.file.key;
-    const known = this.#observedDecodeCost.get(key);
+    const known = this.encodeCost.decodeCost.get(key);
     const readings = [...(known?.readings ?? []), decodeCostSec].slice(-DECODE_LEARNING_READINGS);
     const costSec = medianOf(readings);
     if (!movedBeyondScatter(known?.costSec ?? null, costSec, readings)) {
@@ -7748,10 +7691,10 @@ export class HlsSessionManager {
       // would bump the version and make every session recompute its offer,
       // which is asked for on the path that serves every playlist, init and
       // segment.
-      this.#observedDecodeCost.set(key, { ...known, readings });
+      this.encodeCost.decodeCost.set(key, { ...known, readings });
       return;
     }
-    this.#observedDecodeCost.set(key, { costSec, readings, version: (known?.version ?? 0) + 1 });
+    this.encodeCost.decodeCost.set(key, { costSec, readings, version: (known?.version ?? 0) + 1 });
     logger.info(
       `transcode: ${session.file.name} decodes at ${(1 / costSec).toFixed(2)}x on this host ` +
         `(median of ${readings.length}, latest ${(1 / decodeCostSec).toFixed(2)}x from ${height}p ` +
@@ -7811,7 +7754,7 @@ export class HlsSessionManager {
     // has run before. Without it a second open of a file answers from the
     // startup clips again, undoing the correction the first playback earned.
     const observedDecodeCostSec = mediaInfo?.sourceKey !== undefined
-      ? (this.#observedDecodeCost.get(`${mediaInfo.sourceKey}:${mediaInfo.fileIndex}`)?.costSec ?? null)
+      ? (this.encodeCost.decodeCost.get(`${mediaInfo.sourceKey}:${mediaInfo.fileIndex}`)?.costSec ?? null)
       : null;
     // What this file costs the machine merely by being fetched and delivered is
     // known before any session exists, so the FIRST offer — the one the viewer
@@ -7829,7 +7772,7 @@ export class HlsSessionManager {
       ? this.#observedTorrentCostPerMegabyte * movingMegabytesPerSec
       : 0;
     const forBranch = (transcodeVideo) =>
-      this.#sustainableHeights({
+      this.encodeCost.sustainableHeights({
         heights,
         concurrentCostSec: torrentCostSec,
         // What this file's swarm demanded the last time it was read. Absent on
@@ -7850,409 +7793,6 @@ export class HlsSessionManager {
     return { copy: forBranch(false), transcode: forBranch(true) };
   }
 
-  /**
-   * Drop the rungs this host cannot hold at realtime.
-   *
-   * Every rung below the source height is a full re-encode — decode the whole
-   * source, encode a smaller picture — and on a weak host that is dearer than
-   * the copy it replaces. Measured 2026-08-14: 1080p was copied at 7.8-8.9x
-   * while the offered 240p rung ran at 0.388-0.947x, its first segment took
-   * 30 s and later ones were held 22 s, so choosing a LOWER quality is what
-   * broke playback. A rung that cannot be produced faster than it is watched
-   * must not be offered at all.
-   *
-   * The session's OWN height always stays: an encoder is already producing it,
-   * and removing it would point the player at a rung nobody is encoding.
-   *
-   * @param {{ heights: number[], ownHeight: number, sourceWidth: number, sourceHeight: number, fps: number, source: { megapixelsPerSecond: number, megabitsPerSecond: number } | null, transcodeVideo: boolean }} params
-   * @returns {number[]}
-   */
-  /**
-   * What a running re-encode of the picture costs, in seconds of work per
-   * second of video.
-   *
-   * Measured first: `lastAloneSpeed` is what this very rung did with the
-   * machine to itself. Failing that, the encode model that decides every rung —
-   * the same benchmark, the same decode term — applied to this rung's own pixel
-   * rate. There is no third answer: a rung whose cost cannot be derived at all
-   * contributes nothing rather than a number somebody invented.
-   *
-   * @param {HlsSession} session
-   * @returns {number}
-   */
-  #pictureCostOf(session) {
-    if (Number.isFinite(session.lastAloneSpeed) && session.lastAloneSpeed > 0) {
-      return 1 / session.lastAloneSpeed;
-    }
-    const benchmark = this.softwarePresetBenchmark;
-    const width = Number(session.output.encodeWidth) || 0;
-    const height = Number(session.output.encodeHeight) || 0;
-    const fps = Number(session.output.outputFps) || TRANSCODE_FPS;
-    if (!Array.isArray(benchmark) || benchmark.length === 0 || width <= 0 || height <= 0) {
-      return 0;
-    }
-    const { speed } = canSustainOutput({
-      benchmark,
-      decodeModel: this.decodeCostModel,
-      source: session.file.decode ?? null,
-      outputPixelsPerSec: width * height * fps,
-      observedDecodeCostSec: null,
-      concurrentCostSec: 0
-    });
-    return Number.isFinite(speed) && speed > 0 ? 1 / speed : 0;
-  }
-
-  /**
-   * What everything OTHER than this session is costing right now, or null when
-   * any of it is unpriced.
-   *
-   * Used to recover a soundtrack's own share from a reading taken beside the
-   * picture — the only kind of reading a rendition ever gives, since it runs
-   * exactly as long as the picture does. Refusing to answer when something
-   * running has no price is the point: unpriced work would otherwise be
-   * attributed to the soundtrack, and an overpriced soundtrack refuses quality
-   * steps the host could actually hold.
-   *
-   * @param {HlsSession} session
-   * @returns {number | null}
-   */
-  #pricedConcurrentCost(session) {
-    let cost = 0;
-    for (const member of this.liveOutputs.familyOf(session)) {
-      if (member === session || !processCanBeSignalled(runStateOf(member))) {
-        continue;
-      }
-      if (member.audioOnly === true) {
-        const audio = this.#observedAudioCost.get(this.#audioCostKey(member));
-        if (!audio || !(audio.costSec > 0)) {
-          return null;
-        }
-        cost += audio.costSec;
-        continue;
-      }
-      if (member.transcodeVideo !== true) {
-        const copy = this.#observedCopyCost.get(member.file.key);
-        if (!copy || !(copy.costSec > 0)) {
-          return null;
-        }
-        cost += copy.costSec;
-        continue;
-      }
-      const picture = this.#pictureCostOf(member);
-      if (!(picture > 0)) {
-        return null;
-      }
-      cost += picture;
-    }
-    // Encoders outside this family are counted by number only — there is no
-    // price to look up for another film's session — so a reading taken while
-    // one is running cannot be attributed either.
-    return this.#runningEncoders() > this.liveOutputs.familyOf(session).filter(
-      (member) => processCanBeSignalled(runStateOf(member))
-    ).length
-      ? null
-      : cost;
-  }
-
-  /**
-   * What each height of this family is costing RIGHT NOW, for the heights an
-   * encoder is actually running at.
-   *
-   * Exists so a height can be judged against what the machine spends on
-   * everything else — a step being warmed is running while it is judged, and
-   * charged its own cost it refuses itself.
-   *
-   * @param {HlsSession} session
-   * @returns {Map<number, number>}
-   */
-  #runningCostByHeight(session) {
-    /** @type {Map<number, number>} */
-    const byHeight = new Map();
-    for (const member of this.liveOutputs.familyOf(session)) {
-      if (member.audioOnly === true || member.transcodeVideo !== true) {
-        continue;
-      }
-      if (!processCanBeSignalled(runStateOf(member))) {
-        continue;
-      }
-      const height = this.liveOutputs.variantHeightOf(member);
-      if (height > 0) {
-        byHeight.set(height, (byHeight.get(height) ?? 0) + this.#pictureCostOf(member));
-      }
-    }
-    return byHeight;
-  }
-
-  /**
-   * Seconds of work per second of video this family is ALREADY committed to,
-   * beside any rung being considered.
-   *
-   * Every encoder of the family that is actually running: the picture, whether
-   * it is copied or re-encoded, and each audio rendition. The rung the viewer
-   * is watching and the source's own copied height are never withdrawn by the
-   * caller, so charging for the encoder that serves them cannot strand anyone —
-   * what it does is stop the NEXT rung being offered as though the machine were
-   * idle, which is what the field disproved on 2026-08-15.
-   *
-   * Anything whose cost is neither measured nor derivable contributes nothing.
-   * A guess here would refuse rungs on arithmetic nobody performed.
-   *
-   * @param {HlsSession} session
-   * @returns {number}
-   */
-  #committedCostOf(session) {
-    let cost = 0;
-    for (const member of this.liveOutputs.familyOf(session)) {
-      // Only what still HAS an encoder. A quality step the viewer left keeps
-      // its session and its segments but not a process, and it produces nothing
-      // for anybody — charging the machine for it would refuse steps on work
-      // nobody is doing.
-      //
-      // A SUSPENDED encoder is charged, deliberately, and this is not the same
-      // question. The unit here is seconds of work per second of VIDEO, not per
-      // second of wall clock: a copy running at 8x costs 0.125 s/s whether it
-      // is producing right now or parked by the look-ahead cap, because over an
-      // hour of watching it still produces an hour of video. Suspension is how
-      // that cost is spread, not a discount on it — and pricing a parked
-      // encoder at zero would offer a step on the strength of a pause that ends
-      // the moment the viewer catches up.
-      if (!processCanBeSignalled(runStateOf(member))) {
-        continue;
-      }
-      if (member.audioOnly === true) {
-        // A soundtrack encoder, priced from its own measured speed. Nothing is
-        // charged for a track nobody has measured: a guess here refuses rungs
-        // on arithmetic no one performed.
-        const audio = this.#observedAudioCost.get(this.#audioCostKey(member));
-        cost += audio && audio.costSec > 0 ? audio.costSec : 0;
-        continue;
-      }
-      if (member.transcodeVideo !== true) {
-        const observed = this.#observedCopyCost.get(member.file.key);
-        cost += observed && observed.costSec > 0 ? observed.costSec : 0;
-        continue;
-      }
-      // A picture being RE-ENCODED beside the rung being judged — the warm-up
-      // that makes a quality switch seamless is two encoders by design, and
-      // that overlap is exactly where the field measured 0.504x on a rung
-      // predicted at 1.58x (2026-08-15). Priced by what it has been SEEN doing
-      // when it had the machine to itself, and otherwise by the same model that
-      // judges every rung — which is a prediction, not a guess.
-      cost += this.#pictureCostOf(member);
-    }
-    // And what the FILE costs simply by being fetched and delivered while it is
-    // watched: a viewer consumes it at its own byte rate, and every one of
-    // those bytes is downloaded, verified and pushed by this process. Priced
-    // per megabyte from readings taken while nothing was encoding, so the two
-    // measurements do not contain each other.
-    const perMegabyte = this.#observedTorrentCostPerMegabyte;
-    const megabytesPerSecond = this.#torrentMegabytesPerSecond(
-      session.file.sourceKey,
-      session.file.fileIndex,
-      this.#fileLengthByKey.get(session.file.key) ?? null,
-      session.file.durationSeconds
-    );
-    if (perMegabyte !== null && megabytesPerSecond !== null) {
-      cost += perMegabyte * megabytesPerSecond;
-    }
-    return cost;
-  }
-
-  /**
-   * The speed each rung of this family was last seen running at, when it was
-   * running alone.
-   *
-   * A rung that has been watched failing is refused on that evidence; a rung
-   * nobody has run says nothing about itself and is judged by the startup
-   * measurement like any other.
-   *
-   * @param {HlsSession} base
-   * @returns {Map<number, number>}
-   */
-  #measuredRungSpeeds(base) {
-    /** @type {Map<number, number>} */
-    const speeds = new Map();
-    for (const session of this.liveOutputs.familyOf(base)) {
-      if (session.transcodeVideo !== true || !Number.isFinite(session.lastAloneSpeed)) {
-        continue;
-      }
-      const height = this.liveOutputs.variantHeightOf(session);
-      if (height > 0) {
-        speeds.set(height, session.lastAloneSpeed);
-      }
-    }
-    return speeds;
-  }
-
-  #sustainableHeights({
-    heights,
-    ownHeight,
-    // Every height a viewer has on screen, not one: two viewers of one picture
-    // can be on two rungs, and a rung is never withdrawn while somebody is
-    // watching it — their next segment would 404 on a stream that is playing.
-    playingHeights = new Set(),
-    sourceWidth,
-    sourceHeight,
-    fps,
-    source,
-    transcodeVideo,
-    observedDecodeCostSec = null,
-    concurrentCostSec = 0,
-    runningCostByHeight = null,
-    measuredHeights = null,
-    requiredSpeed = null
-  }) {
-    // What this file's own supply demands, measured by its reader — and
-    // realtime while it has not been measured. Read once here so the line that
-    // reports a refusal names the figure it refused against.
-    const bar = speedBar(requiredSpeed);
-    const benchmark = this.softwarePresetBenchmark;
-    if (!Array.isArray(benchmark) || benchmark.length === 0 || sourceHeight <= 0 || sourceWidth <= 0) {
-      return heights;
-    }
-    /** @type {number[]} */
-    const kept = [];
-    /** @type {string[]} */
-    const dropped = [];
-    // What each height was predicted to do on THIS machine, kept so a session
-    // started at that height can be compared against it once it runs. The
-    // manager holds the last answer, because the offer is computed on the path
-    // that serves every request while a session is created elsewhere.
-    /** @type {Map<number, number | null>} */
-    const predictedByHeight = new Map();
-    for (const height of heights) {
-      // A rung this session has actually been seen running below realtime is
-      // withdrawn on that evidence, whatever the prediction says. This is the
-      // one thing a live reading is authority on: itself. It is asked before
-      // any exemption so a rung measured failing while on screen does not stay
-      // offered because it was on screen when measured — otherwise a step
-      // would ask for the one rung this machine has been measured failing at,
-      // then fail again, then step down, for ever. A copied source height
-      // cannot reach this: `#measuredRungSpeeds` records only sessions that
-      // re-encode, so a copy has no reading to be withdrawn on, which is right
-      // — it costs no encoder.
-      const measured = measuredHeights?.get(height) ?? null;
-      if (measured !== null && measured < 1) {
-        // Even the rung on screen is withdrawn on measured failure: keeping it
-        // would 404 the next segment, but keeping a rung measured at 0.007x
-        // (field 2026-08-31, 4K HEVC on CM4) stalls the viewer for minutes with
-        // 0.04s buffered and no way to downgrade because every other rung is
-        // also dropped. Withdrawing it lets the offer become empty, which the
-        // caller turns into an error the viewer can act on (try another proxy
-        // or a lower source) instead of an endless spinner.
-        dropped.push(`${height}p=${measured.toFixed(2)}x measured`);
-        continue;
-      }
-      // The rung ON SCREEN is kept only when it has not been measured failing
-      // above. Keeping a rung measured at 0.007x would stall the viewer with
-      // no path to a faster rung, which is what the field showed.
-      if (playingHeights.has(height)) {
-        kept.push(height);
-        continue;
-      }
-      // The height an encoder is ALREADY producing, and the source's own height
-      // when the FAMILY serves it by copy — neither has to be predicted,
-      // because it is happening. A copied rung costs no encoder at all, so no
-      // measurement of this host can ever be a reason to withdraw it, and the
-      // whole point of it is that it is where a viewer on a rung the machine
-      // cannot hold goes back to. `transcodeVideo` here is the base's, not the
-      // asking session's: a 240p rung re-encodes, and reading its own flag is
-      // what withdrew a copied 1080p in the field on 2026-08-15.
-      //
-      // A source height that would have to be RE-ENCODED is a prediction like
-      // any other: on a session whose budget stepped down to 480p, the source's
-      // 1080p is neither copied nor being produced, and keeping it unpriced
-      // would offer exactly the kind of rung this refuses. Likewise, a rung
-      // this session is already producing at 0.007x (field 2026-08-31, 4K HEVC
-      // on CM4, 0.1x at 23:45 and 0.007x at 06:57) is not sustainable just
-      // because it is running — keeping it offered no path to a faster rung
-      // and left the viewer at 0.04s buffered with no downgrade.
-      if (
-        (height === ownHeight && !transcodeVideo) ||
-        (height === sourceHeight && !transcodeVideo)
-      ) {
-        kept.push(height);
-        continue;
-      }
-      const width = Math.round(((sourceWidth / sourceHeight) * height) / 2) * 2;
-      // What the machine is spending on everything EXCEPT this height. A step
-      // being warmed for a switch is already running while it is judged, so its
-      // own cost is inside the committed total — and charged against itself it
-      // is counted twice. Measured against the field figures of 2026-08-15
-      // that is 1.83x against 1.03x: below the margin, so the step the viewer
-      // had just asked for was dropped from the offer by the act of warming it,
-      // and its next segment answered 404 on a stream that was playing.
-      const concurrentBesideThis = Math.max(
-        0,
-        concurrentCostSec - (runningCostByHeight?.get(height) ?? 0)
-      );
-      const { speed } = canSustainOutput({
-        benchmark,
-        decodeModel: this.decodeCostModel,
-        source,
-        outputPixelsPerSec: width * height * fps,
-        observedDecodeCostSec,
-        concurrentCostSec: concurrentBesideThis
-      });
-      // The benchmark behind that figure was taken on a QUIET host — one
-      // ffmpeg and nothing else. The machine a step will actually run on is
-      // also running the kernel, the container and whatever else its owner
-      // does, and on the addon host that was measured at 99 % busy with a
-      // quarter of it unattributed. Only the unattributed part is charged
-      // here: our own encoders are already in `concurrentBesideThis` and the
-      // proxy's own work is already priced per megabyte moved.
-      // Two corrections, and they are different facts about the machine. The
-      // availability share removes work nobody has been charged for; the
-      // contention penalty says what OUR OWN second job costs, because the
-      // budget adds independent prices and this host does not behave that way
-      // — the same work measured 2.6× dearer beside one encoder and 3.7×
-      // beside two (2026-08-18). `concurrentBesideThis` already counts what is
-      // committed; this multiplies by how badly running at all together goes.
-      const othersRunning = concurrentBesideThis > 0 ? this.#encodersRunningNow() : 0;
-      const { penalty } = contentionPenalty(othersRunning, this.contentionPenalties);
-      const onThisMachine = correctForAvailability(
-        speed === null ? null : speed / penalty,
-        this.hostAvailability
-      );
-      // Kept against the step's own session, so that when it runs the field
-      // says what the prediction was worth. Without this the only comparison
-      // available is between two figures written minutes apart in different
-      // lines of the log.
-      predictedByHeight.set(height, onThisMachine);
-      if (onThisMachine !== null && onThisMachine >= bar) {
-        kept.push(height);
-        continue;
-      }
-      dropped.push(`${height}p=${onThisMachine === null ? "n/a" : `${onThisMachine.toFixed(2)}x`}`);
-    }
-    // Written when the ANSWER changes, not when the answer is recomputed. This
-    // is asked on the path that serves every playlist, init and segment, and
-    // the figures behind it move every five seconds — so an unconditional line
-    // here is roughly seven hundred identical lines an hour into a forwarder
-    // that holds five hundred, which buries whatever is worth reading.
-    if (dropped.length > 0) {
-      const line =
-        `transcode: not offering ${dropped.join(" ")} — below ${bar.toFixed(2)}x ` +
-        (Number.isFinite(requiredSpeed) && requiredSpeed > 1
-          ? "(the speed this file's own interruptions demand) "
-          : "(realtime, this file's supply not measured yet) ") +
-        // Said with the figures, because a step refused on a busy machine and
-        // one refused on an idle machine are different facts about the host.
-        (this.hostAvailability?.known
-          ? `on a machine with ${Math.round(this.hostAvailability.share * 100)}% to spare `
-          : "") +
-        `(offering ${kept.map((height) => `${height}p`).join(" ")})`;
-      if (line !== this.#lastOfferLine) {
-        this.#lastOfferLine = line;
-        logger.info(line);
-      }
-      this.lastPredictedByHeight = predictedByHeight;
-    } else {
-      this.lastPredictedByHeight = predictedByHeight;
-      this.#lastOfferLine = "";
-    }
-    return kept;
-  }
 
   /**
    * The height this proxy is asking the player to move to, or 0.