@torrent-tv/proxy 2.94.2 → 2.95.0

package/services/encode/quality/EncodeCost.js

@@ -79,15 +79,97 @@ export class EncodeCost {
   #decodeCost = new Map();
 
   /**
-   * What each height was last predicted to do, kept so a session started at
-   * that height can be compared against the prediction once it runs.
+   * What this output is predicted to do on this machine, in the mode it is
+   * actually encoded in, kept on the output so that once it runs the field says
+   * what the prediction was worth (torrent-tv/meta#3).
    *
-   * @type {Map<number, number | null> | null}
+   * Computed here, for this output, and not taken from the last offer. Two
+   * faults came from taking it from there, both read from the field log of
+   * 2026-10-07. The offer prices a height at the CHEAPEST mode, because a
+   * height may be offered when any mode can hold it, while the budget then
+   * encodes at the best mode that clears the bar: an XviD 360p step was
+   * predicted 7.27x at `ultrafast` and measured 1.2-3.4x at `fast`, a ratio of
+   * 0.16-0.47 that said nothing about the arithmetic. And the last offer is one
+   * answer for the whole process, so an output could be given the figure of
+   * another film's offer.
+   *
+   * The offer's own figure for the height is kept beside it, so the line says
+   * both what the offer decided on and what this run was expected to do.
+   *
+   * @param {object} session
+   * @returns {void}
    */
-  lastPredictedByHeight = null;
+  notePredictionFor(session) {
+    const state = qualityStateOf(session);
+    state.predictedSpeedWhenOffered = null;
+    state.predictedMode = null;
+    state.offeredSpeedAtCheapestMode = null;
+    const encode = session?.spec?.video?.encode ?? null;
+    const benchmark = this.#host().benchmark;
+    if (!session?.spec?.transcodesVideo || !encode || !Array.isArray(benchmark) || benchmark.length === 0) {
+      return;
+    }
+    const entry = modeEntryFor(benchmark, encode.preset);
+    const priced = {
+      source: session.file?.decode ?? null,
+      width: encode.width,
+      height: encode.height,
+      fps: Number(encode.fps) || TRANSCODE_FPS,
+      observedDecodeCostSec: null,
+      // Everything else this output's family has running. The output itself has
+      // no process yet, so it is not in the total.
+      concurrentCostSec: this.committedCostOf(session)
+    };
+    state.offeredSpeedAtCheapestMode = this.#speedOnThisMachine({ ...priced, benchmark });
+    if (entry !== null) {
+      state.predictedMode = entry.preset;
+      state.predictedSpeedWhenOffered = this.#speedOnThisMachine({ ...priced, benchmark: [entry] });
+    }
+  }
 
-  notePredictionFor(session, height) {
-    qualityStateOf(session).predictedSpeedWhenOffered = this.lastPredictedByHeight?.get(height) ?? null;
+  /**
+   * The speed an encode is predicted to run at on this machine: the startup
+   * measurement of the cheapest mode in `benchmark` at this size, the decode of
+   * this source, the work already running beside it, how badly running together
+   * goes here, and the share of the machine nobody has been charged for.
+   *
+   * The one calculation both the offer and the per-output prediction use, so
+   * that a ratio between a run and its prediction measures the arithmetic and
+   * not a difference between two copies of it.
+   *
+   * @param {{ benchmark: object[], source: object | null, width: number, height: number, fps: number, observedDecodeCostSec: number | null, concurrentCostSec: number }} params
+   * @returns {number | null}
+   */
+  #speedOnThisMachine({ benchmark, source, width, height, fps, observedDecodeCostSec, concurrentCostSec }) {
+    const { speed } = canSustainOutput({
+      benchmark,
+      decodeModel: this.#host().decodeModel,
+      source,
+      outputPixelsPerSec: width * height * fps,
+      observedDecodeCostSec,
+      concurrentCostSec,
+      frame: { width, height }
+    });
+    // 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 `concurrentCostSec` 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). `concurrentCostSec` already counts what is
+    // committed; this multiplies by how badly running at all together goes.
+    const othersRunning = concurrentCostSec > 0 ? this.#encodersRunningNow() : 0;
+    const { penalty } = contentionPenalty(othersRunning, this.#host().contentionPenalties);
+    return correctForAvailability(
+      speed === null ? null : speed / penalty,
+      this.#host().availability
+    );
   }
 
   // The last refusal printed. The offer is recomputed on the path that serves
@@ -635,12 +717,6 @@ export class EncodeCost {
     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
@@ -707,40 +783,15 @@ export class EncodeCost {
         0,
         concurrentCostSec - (runningCostByHeight?.get(height) ?? 0)
       );
-      const { speed } = canSustainOutput({
+      const onThisMachine = this.#speedOnThisMachine({
         benchmark,
-        decodeModel: this.#host().decodeModel,
         source,
-        outputPixelsPerSec: width * height * fps,
+        width,
+        height,
+        fps,
         observedDecodeCostSec,
-        concurrentCostSec: concurrentBesideThis,
-        frame: { width, height }
+        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.#host().contentionPenalties);
-      const onThisMachine = correctForAvailability(
-        speed === null ? null : speed / penalty,
-        this.#host().availability
-      );
-      // 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;
@@ -768,9 +819,7 @@ export class EncodeCost {
         this.#lastOfferLine = line;
         logger.info(line);
       }
-      this.lastPredictedByHeight = predictedByHeight;
     } else {
-      this.lastPredictedByHeight = predictedByHeight;
       this.#lastOfferLine = "";
     }
     return kept;
@@ -859,9 +908,12 @@ export class EncodeCost {
       if (!Number.isFinite(lastSaid) || Math.abs(ratio - lastSaid) > 0.1) {
         state.lastPredictionRatio = ratio;
         logger.info(
-          `prediction ${session.id.slice(0, 8)} ${session.output.encodeHeight || "source"}p: ` +
-          `predicted ${state.predictedSpeedWhenOffered.toFixed(2)}x, measured ${speed.toFixed(2)}x ` +
-          `(ratio ${ratio.toFixed(2)}; 1.00 would mean the arithmetic describes this machine)`
+          `prediction ${session.id.slice(0, 8)} ${session.output.encodeHeight || "source"}p ` +
+          `"${state.predictedMode}": predicted ${state.predictedSpeedWhenOffered.toFixed(2)}x, measured ${speed.toFixed(2)}x ` +
+          `(ratio ${ratio.toFixed(2)}; 1.00 would mean the arithmetic describes this machine)` +
+          (Number.isFinite(state.offeredSpeedAtCheapestMode)
+            ? `; offered on ${state.offeredSpeedAtCheapestMode.toFixed(2)}x at the cheapest mode`
+            : "")
         );
       }
     }
@@ -1041,3 +1093,23 @@ export class EncodeCost {
     );
   }
 }
+
+/**
+ * The startup measurement of the mode an output is encoded in.
+ *
+ * A mode is filed under its setting, or under the encoder's own name where the
+ * encoder has one setting (`calibration.js`), so an output that names no setting
+ * is matched to the one mode there is. Null when the output's setting was not
+ * measured: its prediction is then unknown rather than borrowed from another
+ * mode.
+ *
+ * @param {Array<{ preset: string }>} benchmark
+ * @param {string | null | undefined} preset
+ * @returns {{ preset: string } | null}
+ */
+export function modeEntryFor(benchmark, preset) {
+  if (typeof preset === "string" && preset.length > 0) {
+    return benchmark.find((entry) => entry.preset === preset) ?? null;
+  }
+  return benchmark.length === 1 ? benchmark[0] : null;
+}

package/services/encode/quality/OutputQualityState.js

@@ -12,6 +12,8 @@ export function qualityStateOf(output) {
   if (!state) {
     state = {
       predictedSpeedWhenOffered: null,
+      predictedMode: null,
+      offeredSpeedAtCheapestMode: null,
       lastPredictionRatio: null,
       lastAloneSpeed: undefined,
       saidNoVariants: undefined,

package/services/encode/quality/QualityController.js

@@ -51,7 +51,7 @@ export class QualityController {
   #affirmed = new Set();
 
   /**
-   * @param {object} host - `isLive`, `liveConsumers`, `liveRunsOf`, `producedNumbers`, `reportHostLoad`, `runStateOf`, `sampleDownloadRates`, `encodeCost`, `outputs`, `qualityOffer`, `segmentDurationSec`, `segmentPaths`, `videoEncoder`, `prepareSameHeightSwitch`, `sameHeightSwitchPending`, `sameHeightSwitchDirection`, `cancelSameHeightSwitch`, `heightReadyFor`, `bufferOf`, `visiblePictureOf`, `expectedFirstSegmentMs`
+   * @param {object} host - `isLive`, `liveConsumers`, `liveRunsOf`, `producedNumbers`, `reportHostLoad`, `runStateOf`, `sampleDownloadRates`, `encodeCost`, `outputs`, `qualityOffer`, `segmentDurationSec`, `segmentPaths`, `videoEncoder`, `prepareSameHeightSwitch`, `sameHeightSwitchPending`, `sameHeightSwitchDirection`, `cancelSameHeightSwitch`, `heightReadyFor`, `bufferOf`, `visiblePictureOf`, `computedPreparationSec`
    * @param {SegmentPathLookup} host.segmentPaths - Lookup for completed
    *   segment paths needed by quality decisions.
    */
@@ -103,16 +103,20 @@ export class QualityController {
   /**
    * How long another output of the mode on this viewer's screen takes to be
    * ready here, in seconds: as observed on this host (roadmap item 97, step
-   * 14), and otherwise this host's time to a first segment. Null when neither
-   * has been measured.
+   * 14), and otherwise computed from this host's measured wait for a first
+   * output and this output's own measured speed (torrent-tv/meta#3). Null
+   * when neither can be said.
    *
    * @param {HlsSession} session
    * @returns {number | null}
    */
   #secondsToReady(session) {
     const observedMs = this.#host.observedPreparationMs?.(session) ?? null;
-    const expectedMs = Number.isFinite(observedMs) ? observedMs : (this.#host.expectedFirstSegmentMs?.() ?? null);
-    return Number.isFinite(expectedMs) && expectedMs >= 0 ? expectedMs / 1000 : null;
+    if (Number.isFinite(observedMs) && observedMs >= 0) {
+      return observedMs / 1000;
+    }
+    const computed = this.#host.computedPreparationSec?.(session) ?? null;
+    return Number.isFinite(computed) && computed >= 0 ? computed : null;
   }
 
   /**

package/services/media/container/h264-configuration.js

@@ -21,16 +21,7 @@ export function h264Configuration(avcc) {
 
 function readSps(nal, includeOrder = false) {
   if ((nal[0] & 31) !== 7 || nal[0] & 128) throw new Error("AVC configuration entry is not an SPS.");
-  const bytes = [];
-  for (let at = 1, zeroes = 0; at < nal.length; at++) {
-    const byte = nal[at];
-    if (zeroes >= 2 && byte === 3) {
-      if (at + 1 >= nal.length || nal[at + 1] > 3) throw new Error("AVC emulation prevention byte is invalid.");
-      zeroes = 0; continue;
-    }
-    bytes.push(byte); zeroes = byte === 0 ? zeroes + 1 : 0;
-  }
-  const bits = new Bits(Buffer.from(bytes));
+  const bits = new Bits(unescapeNal(nal));
   const profile = bits.uint(8), constraints = bits.uint(8), level = bits.uint(8);
   bits.ue();
   let chroma = 1, separate = 0, depth = 8;
@@ -131,14 +122,16 @@ export function avcOrderParameters(sps, pps) {
   return { ...facts.pictureOrder, bottomFieldOrderPresent: bits.uint(1) === 1 };
 }
 
+/**
+ * Remove every emulation prevention byte: a 0x03 after two zero bytes, whatever follows it. H.264 §7.4.1
+ * forbids 0x000003 before a byte above 0x03, but encoders write it (LostFilm's LostCoder) and decoders drop
+ * it (ffmpeg's ff_h2645_extract_rbsp), so refusing it refuses files every player plays.
+ */
 export function unescapeNal(nal) {
   const bytes = [];
   for (let at = 1, zeroes = 0; at < nal.length; at++) {
     const byte = nal[at];
-    if (zeroes >= 2 && byte === 3) {
-      if (at + 1 >= nal.length || nal[at + 1] > 3) throw new Error("AVC escape byte is invalid.");
-      zeroes = 0; continue;
-    }
+    if (zeroes >= 2 && byte === 3) { zeroes = 0; continue; }
     bytes.push(byte);
     zeroes = byte === 0 ? zeroes + 1 : 0;
   }

package/services/media/playback-planner.js

@@ -200,12 +200,6 @@ export function createPlaybackPlanner({
   localBaseUrl,
   sourceRegistry,
   torrentPool,
-  // Optional. Reports what this host typically takes to produce a session's
-  // first segment. The browser needs it for the gap between "the file is
-  // downloaded" and "a segment exists": until now it assumed the pipeline
-  // merely keeps up with realtime, and showed 15 s where 3.8 s were left.
-  expectedFirstSegmentMs,
-  expectedSessionCreateMs,
   // What the torrent holds beside this picture — its dubs, its subtitle files,
   // its contact sheets — grouped by whoever knows what a torrent contains. This
   // layer answers about ONE file and must not read a torrent's file list.
@@ -480,13 +474,11 @@ export function createPlaybackPlanner({
     return { audioTracks: plan.audioTracks, pending: pendingIndexes.size > 0 };
   }
 
-  function withHostTimings(plan) {
+  function withLiveFigures(plan) {
     const withOffer = {
       ...plan,
-      expectedFirstSegmentMs: expectedFirstSegmentMs?.() ?? null,
-      expectedSessionCreateMs: expectedSessionCreateMs?.() ?? null,
-      // Answered here for the same reason as the two above: a plan is cached for
-      // the life of the process, and what this host will serve a file at is not.
+      // Answered here, not when the plan is built: a plan is cached for the
+      // life of the process, and what this host will serve a file at is not.
       // It starts as a prediction from the startup benchmarks and is replaced by
       // what an encoder running on this very source turns out to cost — frozen
       // into the cache, every later open of the file would hand the browser the
@@ -590,7 +582,7 @@ export function createPlaybackPlanner({
       };
       const cached = cache.get(cacheKey);
       if (cached) {
-        return withHostTimings(cached);
+        return withLiveFigures(cached);
       }
       // Where the time before playback goes. `cold-start` already breaks down
       // everything from the transcode-session request onwards, but the plan
@@ -634,7 +626,7 @@ export function createPlaybackPlanner({
           subtitleTracks: []
         };
         cache.set(cacheKey, plan);
-        return withHostTimings(plan);
+        return withLiveFigures(plan);
       }
 
       // Structural reads state their exact missing bytes through
@@ -710,11 +702,9 @@ export function createPlaybackPlanner({
         // all.
         sidecarSubtitles: sidecars.subtitles,
         sidecarImages: sidecars.images,
-        // Both host timings are filled in by `withHostTimings` on the way out,
-        // never here: read at build time they would be frozen into the cached
-        // plan, which is the bug fixed in 2.9.106.
-        expectedFirstSegmentMs: null,
-        expectedSessionCreateMs: null,
+        // Filled in by `withLiveFigures` on the way out, never here: read at
+        // build time it would be frozen into the cached plan, which is the bug
+        // fixed in 2.9.106.
         offeredHeights: null,
         // What the offer is computed FROM, kept on the cached plan so the offer
         // itself can be recomputed on every response. The figures are the
@@ -771,9 +761,9 @@ export function createPlaybackPlanner({
           // Retain every declared stream count for failed-run diagnostics.
           streamCounts: probe.streamCounts
         });
-        return withHostTimings(plan);
+        return withLiveFigures(plan);
       }
-      return withHostTimings({ ...plan, pending: true });
+      return withLiveFigures({ ...plan, pending: true });
     }
   };
 }

package/services/server/SegmentServing.js

@@ -52,7 +52,7 @@ export class SegmentServing {
   #host;
 
   /**
-   * @param {object} host - `buildMasterPlaylist`, `declaredTracks`, `publishedGridFor`, `runStartTimeFor`, `cushion`, `encodeOrchestrator`, `encodeRuns`, `hostTimings`, `lookaheadSeconds`, `outputTimes`, `outputs`, `segmentStore`, `startupWaitMs`, `viewers`
+   * @param {object} host - `buildMasterPlaylist`, `declaredTracks`, `publishedGridFor`, `runStartTimeFor`, `cushion`, `encodeOrchestrator`, `encodeRuns`, `coldStarts`, `lookaheadSeconds`, `outputTimes`, `outputs`, `segmentStore`, `startupWaitMs`, `viewers`
    */
   constructor(host) {
     this.#host = host;
@@ -288,8 +288,8 @@ export class SegmentServing {
       }
 
       // Cold-start: the time from the create request to a playable first
-      // segment, measured once per output by the owner of host timings.
-      const coldStartMs = isPlaylist ? null : this.#host.hostTimings.noteSegmentServed(session);
+      // segment, measured once per output.
+      const coldStartMs = isPlaylist ? null : this.#host.coldStarts.noteSegmentServed(session);
       if (coldStartMs !== null) {
         // Data is flowing again, so the next loss starts its backoff afresh
         // rather than inheriting the delay of the last one.

package/services/server/ViewerRequests.js

@@ -47,7 +47,7 @@ export class ViewerRequests {
   #rateStateBySession = new WeakMap();
 
   /**
-   * @param {object} host - `opening`, `activeOutputFor`, `viewerSecondsOn`, `minimumBufferSecondsFor`, `getSourceStats`, `disposeSession`, `expectedFirstSegmentMs`, `expectedSessionCreateMs`, `planEncodersSoon`, `waitUntilReady`, `encodeRuns`, `encodeSpeedReadingOf`, `outputTimes`, `outputs`, `lookaheadSeconds`, `quality`, `qualityOffer`, `renditions`, `segmentDurationSec`, `segmentStore`, `sourceFiles`, `startupWaitMs`, `viewers`, `acceptsGeneration`, `generationOfRequest`, `noteGivenOutput`, `holdForResponse`, `noteServingVerdict`, `servingVerdictOf`
+   * @param {object} host - `opening`, `activeOutputFor`, `viewerSecondsOn`, `minimumBufferSecondsFor`, `getSourceStats`, `disposeSession`, `planEncodersSoon`, `waitUntilReady`, `encodeRuns`, `encodeSpeedReadingOf`, `outputTimes`, `outputs`, `lookaheadSeconds`, `quality`, `qualityOffer`, `renditions`, `segmentDurationSec`, `segmentStore`, `sourceFiles`, `startupWaitMs`, `viewers`, `acceptsGeneration`, `generationOfRequest`, `noteGivenOutput`, `holdForResponse`, `noteServingVerdict`, `servingVerdictOf`
    */
   constructor(host) {
     this.#host = host;
@@ -531,15 +531,6 @@ export class ViewerRequests {
       // confirmed), or `no measurement`. The page says which, so an estimate
       // is never presented as a guarantee.
       servingVerdict: this.#host.servingVerdictOf(consumerId),
-      // What this host takes to create a session and to make a first segment.
-      // Also on the playback plan, but the browser reads that once per file:
-      // measured 2026-08-06 across four seeks, a proxy that had just restarted
-      // answered null for both, and every later seek then computed its estimate
-      // with one term of four — the figure hit zero after 3.5 s of an 11.8 s
-      // wait and read "starting now" for the remaining 8.4 s. This response is
-      // polled about every 1.5 s, so carrying them here keeps them current.
-      expectedSessionCreateMs: this.#host.expectedSessionCreateMs(),
-      expectedFirstSegmentMs: this.#host.expectedFirstSegmentMs(),
       updatedAt: progress.updatedAt,
       error: this.#host.encodeRuns.failureOf(failed ?? session)
     };

package/services/server/wire-outputs.js

@@ -78,7 +78,7 @@ import { EncodeRuns } from "../encode/EncodeRuns.js";
 import { EncodeInputs } from "../encode/EncodeInputs.js";
 import { OutputTimes } from "../encode/OutputTimes.js";
 import { HostLoad } from "../encode/quality/HostLoad.js";
-import { HostTimings } from "../encode/quality/HostTimings.js";
+import { ColdStarts, secondsToFirstPiece } from "../encode/quality/ColdStarts.js";
 import { BUDGET_CHECK_INTERVAL_MS, QualityController } from "../encode/quality/QualityController.js";
 import { EncodeOrchestrator } from "../encode/EncodeOrchestrator.js";
 import { EncodeAdmission } from "../encode/EncodeAdmission.js";
@@ -93,9 +93,8 @@ import { wireMachineBudget } from "../storage/wire.js";
 import { Returns } from "../storage/returns.js";
 import { freeBytesFor } from "../storage/free.js";
 import path from "node:path";
-import { contentOf, LocalObservations } from "../encode/LocalObservations.js";
+import { contentOf, LocalObservations, PROXY_ROOT } from "../encode/LocalObservations.js";
 import { configurationKeyOf } from "../encode/fingerprint.js";
-import { PROXY_ROOT } from "../encode/quality/HostTimings.js";
 import { qualityStateOf } from "../encode/quality/OutputQualityState.js";
 
 // Where a variant and an audio rendition live under a session — `v/<height>/…`
@@ -488,7 +487,7 @@ export function wireOutputs({
     get cushion() { return parts.cushion; },
     get encodeOrchestrator() { return parts.encodeOrchestrator; },
     get encodeRuns() { return parts.encodeRuns; },
-    get hostTimings() { return parts.hostTimings; },
+    get coldStarts() { return parts.coldStarts; },
     get lookaheadSeconds() { return parts.lookaheadSeconds; },
     get outputTimes() { return parts.outputTimes; },
     get outputs() { return parts.outputs; },
@@ -539,7 +538,7 @@ export function wireOutputs({
     get admission() { return parts.admission; },
     get getCachedMediaInfo() { return parts.getCachedMediaInfo; },
     get hostLoad() { return parts.hostLoad; },
-    get hostTimings() { return parts.hostTimings; },
+    get coldStarts() { return parts.coldStarts; },
     get keyframeTables() { return parts.keyframeTables; },
     get localBaseUrl() { return parts.localBaseUrl; },
     get outputs() { return parts.outputs; },
@@ -564,8 +563,6 @@ export function wireOutputs({
     minimumBufferSecondsFor: (output) => minimumBufferSecondsOf(output),
     getSourceStats: (...args) => parts.getSourceStats?.(...args) ?? null,
     disposeSession: (...args) => parts.lifecycle.disposeSession(...args),
-    expectedFirstSegmentMs: (...args) => parts.hostTimings.expectedFirstSegmentMs(...args),
-    expectedSessionCreateMs: (...args) => parts.hostTimings.expectedSessionCreateMs(...args),
     planEncodersSoon: (...args) => parts.encodeRuns.planEncodersSoon(...args),
     waitUntilReady: (...args) => parts.serving.waitUntilReady(...args),
     get encodeRuns() { return parts.encodeRuns; },
@@ -618,12 +615,8 @@ export function wireOutputs({
     noteServingVerdict: (consumerId, verdict) => noteServingVerdict(parts.viewers, consumerId, verdict),
     servingVerdictOf: (consumerId) => servingVerdictOf(parts.viewers, consumerId),
   });
-  // What this host takes to create an output and to produce its first segment, kept across restarts until the synthetic figure can replace it (CLAUDE.md, host timings).
-  parts.hostTimings = new HostTimings({
-    get segmentDurationSec() { return parts.segmentDurationSec; },
-    get softwarePresetBenchmark() { return parts.softwarePresetBenchmark; },
-    get stateDir() { return parts.stateDir; },
-  });
+  // How long each output took to its first served segment, said once in the log.
+  parts.coldStarts = new ColdStarts();
   parts.enabled = Boolean(enabled);
   parts.ffmpegBin = ffmpegBin;
   parts.sourceInputsFor = typeof sourceInputsFor === "function" ? sourceInputsFor : null;
@@ -776,9 +769,6 @@ export function wireOutputs({
     fileLengthOf: (session) => parts.hostLoad.fileLengthByKey.get(session.file.key) ?? 0,
     largestPieceOf: (address) => parts.segmentStore.largestPiece(address)
   });
-  // What this host learned last time it ran. Without it every restart shows
-  // the first viewer a figure with no measurement behind it.
-  parts.hostTimings.loadHostTimings();
   // Where produced segments live, addressed by WHAT they are rather than by
   // which session's encoder wrote them. Two sessions of one output — two
   // viewers who opened the same film at different places — write into one
@@ -1033,9 +1023,14 @@ export function wireOutputs({
     // (roadmap item 98), as values.
     bufferOf: (output, consumerId, spanSec) => bufferOf(parts.viewers, output, consumerId, spanSec),
     visiblePictureOf: (output, consumerId) => visiblePictureOf(parts.viewers, output, consumerId),
-    // How long this host takes to close a first segment: how soon another
-    // output could have the piece a viewer needs.
-    expectedFirstSegmentMs: () => parts.hostTimings.expectedFirstSegmentMs(),
+    // How soon another output of this mode could have the piece a viewer needs,
+    // computed from this host's measured wait for a first output and the
+    // output's own measured speed.
+    computedPreparationSec: (output) => secondsToFirstPiece({
+      firstByteWaitSec: parts.encodeOrchestrator?.runCostSeconds().firstByteWaitSec ?? 0,
+      segmentDurationSec: parts.segmentDurationSec,
+      speed: parts.encodeCost.speedForOutput(output?.outputKey ?? "")
+    }),
     dropAskOf: (output, consumerId) => dropAskOf(parts.viewers, output, consumerId),
     // EACH viewer's own link and who is present: a thin link decides for the
     // person on it and for nobody else (roadmap item 97, step 11), so the