@torrent-tv/proxy 2.81.1 → 2.82.0

package/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 2.82.0
+
+- **Fix**: THE ENCODER PING-PONGED BECAUSE NOTHING MEASURED WHAT A START COSTS. The plan compares when the wanted pieces appear under each arrangement, and for that it needs how long a fresh encoder takes to produce anything and how long killing one takes. Both were learned only from runs that had ENDED, so at a cold open both were zero — and zero does not read as “not measured”, it reads as “free”. Keeping a warming encoder then cost one piece and moving it cost `0 + 0 + one piece`: the same figure to the millisecond, so the tie fell to position and any advantage however small won. Field 2026-09-08: start at #68, a second later kill and start at #69, half a second later kill and start at #68 again, each dying having produced nothing. Over two days 153 runs were stopped that way and 68 of them made no segment at all.
+  **Both are measured at startup now, from one ffmpeg run**: spawn to the first piece the encoder itself announces closed, then SIGTERM to exit. 0.68 s and 0.02 s on the developer’s desktop. Readings from real runs replace them as they arrive. Worth stating because it is what the arithmetic already assumed: subtract keeping from moving and what is left is the killing plus the time the run has already lived — the warm-up a move throws away. That term exists in the formula and vanishes with the measurement, which is why the plan behaved as though a move were free.
+- **Fix**: The decode cost and the contention penalty were asked only where the chosen encoder was SOFTWARE, and neither is about the encoder. A host with a GPU decodes in software just the same — no hardware decoder is asked for anywhere — and what a second job costs is a property of the machine. So a GPU host had no decode model, no contention penalty and no encoder throughput at all, and the quality offer, which is arithmetic over those three, had nothing to compute from.
+- **New**: The throughput benchmark walks the CHOSEN encoder’s own speed ladder — libx264’s presets, NVENC’s `p1`…`p7`, QSV’s `veryfast`…`veryslow`, VAAPI’s quality levels. Each kind says how to measure itself (`Encoder.benchmarkArgs`), which is what the ladders declared and nothing ever ran. A kind with no ladder is measured once, which is still a reading where there was none.
+- **Chore**: 1000 checks pass, biome clean. NOT yet seen in the field. What the next session must show: `a start costs …s to a first piece and a stop …s on this host` once at startup, `firstByte=` and `kill=` non-zero in the very first `encode-plan` line, and no run stopped with “scores worse than standing at” an adjacent number.
+
+## 2.81.2
+
+- **Fix**: `disk: 0MB free` on a host with 103 GB. The free space was read from the segments’ own directory, which is made when the first session starts and removed when the proxy stops — so at every start, and after every clean exit, the reading failed and answered zero, which means “no room” to everything downstream. It reads the nearest ancestor that exists; the disk is the same disk either way.
+- **Fix**: The spilled pieces were never registered with the owner of the disk, so it divided nothing and they kept the ceiling they had. The session manager holds no torrent pool — it is handed closures over the thread boundary — and 2.81.0 asked it for a field that does not exist. They arrive the same way everything else from that thread does.
+
 ## 2.81.1
 
 - **Fix**: The `disk:` line is actually said. 2.81.0 built the reading and called it from nowhere, so the one thing that can answer "why is there no room" was absent from the log. The owner says it itself, once a pass, in the series beside the memory reading.

package/package.json

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

package/server.js

@@ -40,6 +40,7 @@ import { WorkerTorrentPool } from "./services/torrent-worker/pool-adapter.js";
 import { HlsSessionManager } from "./services/hls-session-manager.js";
 import { createPlaybackPlanner } from "./services/playback-planner.js";
 import { detectVideoEncoder, benchmarkSoftwarePresets, benchmarkDecodeCost, benchmarkContention, benchmarkCopySpeed, detectTonemapSupport } from "./services/hwaccel.js";
+import { measureStartAndStop } from "./services/encode/start-stop-cost.js";
 import { logger } from "./utils/logger.js";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -126,23 +127,31 @@ export async function startProxyServer({
   const videoEncoder = transcodeAudio
     ? await detectVideoEncoder({ ffmpegBin, logger })
     : null;
-  // For software libx264, benchmark preset throughput once at startup so the
-  // session manager can pick the highest-quality preset that still encodes each
-  // stream faster than realtime. Hardware encoders use their own fixed preset.
-  // The decode model first, and the preset benchmark second — they are
-  // independent now (the presets are timed on raw frames), but the order costs
-  // nothing and keeps the two figures side by side in the log.
-  const decodeCostModel = videoEncoder?.kind === "software"
+  // WHAT THIS HOST DOES, measured before any viewer exists. Every one of these
+  // was gated on the chosen encoder being SOFTWARE, and two of the three are
+  // not about the encoder at all: a host with a GPU decodes in software just
+  // the same — no hardware decoder is asked for anywhere — and what a second
+  // job costs is a property of the machine. So a GPU host had no decode cost,
+  // no contention penalty and no encoder throughput, and the quality offer,
+  // which is arithmetic over those three, had nothing to compute from.
+  //
+  // The decode model first and the throughput second — they are independent
+  // (the rungs are timed on raw frames), but the order keeps the two figures
+  // side by side in the log.
+  const decodeCostModel = transcodeAudio
     ? await benchmarkDecodeCost({ ffmpegBin, logger })
     : null;
   // What a second job costs on this host. Measured because the budget adds
   // independent prices and this host says two jobs that each fit alone do not
   // fit together — 2.6× on the addon box (2026-08-18).
-  const contentionPenalties = videoEncoder?.kind === "software"
+  const contentionPenalties = transcodeAudio
     ? await benchmarkContention({ ffmpegBin, logger })
     : null;
-  const softwarePresetBenchmark = videoEncoder?.kind === "software"
-    ? await benchmarkSoftwarePresets({ ffmpegBin, logger })
+  // The chosen encoder walked over its OWN speed ladder: libx264's presets,
+  // NVENC's p1…p7, QSV's veryfast…veryslow, VAAPI's quality levels. A kind with
+  // no ladder is measured once, which is still a reading where there was none.
+  const softwarePresetBenchmark = videoEncoder
+    ? await benchmarkSoftwarePresets({ ffmpegBin, logger, encoder: videoEncoder })
     : null;
   // What this host does with a picture it does NOT re-encode. Every other
   // startup measurement prices encoding or decoding, and a copied picture does
@@ -155,6 +164,15 @@ export async function startProxyServer({
   const copySpeedX = transcodeAudio
     ? await benchmarkCopySpeed({ ffmpegBin, logger })
     : null;
+  // WHAT A START AND A STOP COST HERE, before any viewer exists. Both decide one
+  // thing — leave an encoder where it stands, or kill it and start another —
+  // and both used to be learned only from runs that had ENDED, so at a cold
+  // open they were zero. Zero does not read as "not measured": it reads as
+  // "free", and a free move is always taken. Field 2026-09-08: an encoder moved
+  // between two adjacent numbers every half second and produced nothing.
+  const startStopCost = transcodeAudio
+    ? await measureStartAndStop({ ffmpegBin, encoder: videoEncoder, logger })
+    : null;
   // Whether this ffmpeg build can tone-map HDR→SDR (zscale + tonemap filters).
   // Detected once; the session manager applies the tonemap chain only for HDR
   // sources on the software path when available.
@@ -171,6 +189,7 @@ export async function startProxyServer({
     decodeCostModel,
     contentionPenalties,
     copySpeedX,
+    startStopCost,
     tonemapSupported,
     segmentFormatId: segmentFormat,
     stateDir,
@@ -178,6 +197,15 @@ export async function startProxyServer({
     // CPU-bound transcode from a download-starved input before downscaling.
     // What every torrent here has moved, so the proxy can price its own
     // downloading, hashing and delivery against the machine (roadmap item 7).
+    // What the spilled pieces weigh on the torrent thread, and how to tell them
+    // their share of the disk. The owner of the disk is on this side, where the
+    // segments are; the pieces are on the other.
+    spillDisk: typeof torrentPool.allowSpillBytes === "function"
+      ? {
+          held: () => torrentPool.spilledBytes ?? 0,
+          allow: (bytes) => torrentPool.allowSpillBytes(bytes)
+        }
+      : null,
     getTorrentTotals: async () => {
       if (typeof torrentPool.getTorrentTotals !== "function") {
         return null;

package/services/disk/free.js

@@ -0,0 +1,38 @@
+/**
+ * @file How much room the disk holding a directory has.
+ *
+ * Separate from the plain `statfs` reading because of one case that is the
+ * normal one, not an edge: the directory may not exist yet. The segments live
+ * under `os.tmpdir()/torrent-tv-hls`, which is made when the first session is
+ * created and removed when the proxy stops — so at every start, and after every
+ * clean exit, `statfs` on it fails. Field 2026-09-10: the first reading said
+ * `disk: 0MB free` on a host with 103 GB, and zero means "no room" to everything
+ * that reads it.
+ *
+ * The disk is the same disk whether or not that directory has been made yet, so
+ * the answer is the nearest ancestor that exists.
+ */
+
+import { statfs } from "node:fs/promises";
+import path from "node:path";
+
+/**
+ * @param {string} directory
+ * @returns {Promise<number | null>} Bytes free, or null where nothing answered.
+ */
+export async function freeBytesFor(directory) {
+  let at = path.resolve(directory);
+  for (let depth = 0; depth < 16; depth += 1) {
+    try {
+      const stats = await statfs(at);
+      return Number(stats.bavail) * Number(stats.bsize);
+    } catch {
+      const up = path.dirname(at);
+      if (up === at) {
+        return null;
+      }
+      at = up;
+    }
+  }
+  return null;
+}

package/services/disk/wire.js

@@ -19,14 +19,16 @@ import { DiskSpace } from "./DiskSpace.js";
  *
  * @param {object} params
  * @param {{ root: string, stats: () => { bytes: number } }} params.segmentStore
- * @param {{ spilledBytes?: number, allowSpillBytes?: (bytes: number) => unknown }} [params.torrentPool]
+ * @param {{ held: () => number, allow: (bytes: number) => unknown }} [params.spill] -
+ *   The pieces the memory store spills. They live on the torrent thread, so
+ *   this is a pair of closures over the channel rather than the pool itself.
  * @param {(directory: string) => Promise<number | null>} params.readFree
  * @param {{ info: Function, warn?: Function }} [params.logger]
  * @returns {{ revise: () => Promise<unknown>, segmentBytes: () => number, describe: () => string }}
  *   What the segments may hold is asked for rather than pushed: zero until the
  *   first revision, and zero stops growth rather than licensing it.
  */
-export function wireDiskSpace({ segmentStore, torrentPool, readFree, logger }) {
+export function wireDiskSpace({ segmentStore, spill, readFree, logger }) {
   const space = new DiskSpace({ readFree: () => readFree(segmentStore.root), logger });
   let segmentBytes = 0;
   space.register({
@@ -39,16 +41,15 @@ export function wireDiskSpace({ segmentStore, torrentPool, readFree, logger }) {
       segmentBytes = bytes;
     }
   });
-  if (typeof torrentPool?.allowSpillBytes === "function") {
-    // The pieces the memory store spills. They live on the torrent thread, so
-    // the share travels the channel that already carries everything else, and
+  if (typeof spill?.allow === "function") {
+    // The share travels the channel that already carries everything else, and
     // the reply says what they hold — one exchange, both directions.
     space.register({
       name: "spilled pieces",
-      held: () => torrentPool.spilledBytes ?? 0,
+      held: () => spill.held?.() ?? 0,
       wanted: () => Number.MAX_SAFE_INTEGER,
       allow: (bytes) => {
-        void torrentPool.allowSpillBytes?.(bytes);
+        void spill.allow(bytes);
       }
     });
   }

package/services/encode/Encoder.js

@@ -81,4 +81,31 @@ export class Encoder {
   buildVideoArgs(_options) {
     throw new Error(`${this.name} does not say how to build its video arguments.`);
   }
+
+  /**
+   * How to encode raw frames at one rung of this kind's speed ladder, for the
+   * startup benchmark and nothing else.
+   *
+   * SEPARATE FROM `buildVideoArgs` on purpose. That one produces a picture from
+   * a film: it scales, it tone-maps, it forces keyframes onto a grid, it caps a
+   * bitrate. The benchmark is fed raw frames of a known size and wants the
+   * encoder and the rung with nothing else in the way — otherwise the reading
+   * prices a scaler as though it were the encoder.
+   *
+   * WHY EVERY KIND MUST ANSWER IT. Until now the throughput benchmark existed
+   * only for libx264 and was gated on the chosen encoder being software, so a
+   * host with NVENC, QSV, VAAPI or V4L2M2M measured its encoder not at all —
+   * and the quality offer, which is arithmetic over pixels per second, had no
+   * pixels per second to work with. NVENC's own ladder is `p1`…`p7` and QSV's
+   * is `veryfast`…`veryslow`; both are declared here and neither was ever run.
+   *
+   * @param {string | null} rung - One value of {@link speedLadder}, or null
+   *   where the kind has no ladder and there is one thing to measure.
+   * @returns {string[]}
+   */
+  benchmarkArgs(rung = null) {
+    const ladder = this.speedLadder;
+    const setting = ladder?.flag && rung ? [ladder.flag, rung] : [];
+    return ["-c:v", this.name, ...setting];
+  }
 }

package/services/encode/QsvEncoder.js

@@ -35,6 +35,12 @@ export class QsvEncoder extends Encoder {
     };
   }
 
+  /** @param {string | null} rung @returns {string[]} */
+  benchmarkArgs(rung = null) {
+    const preset = rung ? ["-preset", rung] : [];
+    return ["-c:v", "h264_qsv", "-global_quality", "24", ...preset];
+  }
+
   buildVideoArgs({ targetWidth, targetHeight, segmentDurationSec, forcedKeyframeTimes }) {
     const { w, h } = safeDimensions(targetWidth, targetHeight);
     return [

package/services/encode/SoftwareEncoder.js

@@ -42,6 +42,11 @@ export class SoftwareEncoder extends Encoder {
     };
   }
 
+  /** @param {string | null} rung @returns {string[]} */
+  benchmarkArgs(rung = null) {
+    return ["-c:v", "libx264", "-preset", rung ?? SOFTWARE_PRESET, "-crf", SOFTWARE_CRF, "-pix_fmt", "yuv420p"];
+  }
+
   buildVideoArgs({
     targetWidth,
     targetHeight,

package/services/encode/VaapiEncoder.js

@@ -40,6 +40,14 @@ export class VaapiEncoder extends Encoder {
 
   // No fps filter: VAAPI inherits the source rate and keeps keyframes on the
   // grid via time-based -force_key_frames, so it already honours source fps.
+  /** @param {string | null} rung @returns {string[]} */
+  benchmarkArgs(rung = null) {
+    // Raw frames live in this process; VAAPI encodes what is in the device, so
+    // the upload is part of what this kind costs and belongs in the reading.
+    const quality = rung ? ["-quality", rung] : [];
+    return ["-vf", "format=nv12,hwupload", "-c:v", "h264_vaapi", "-qp", "24", ...quality];
+  }
+
   buildVideoArgs({ targetWidth, targetHeight, segmentDurationSec, forcedKeyframeTimes }) {
     const { w, h } = safeDimensions(targetWidth, targetHeight);
     return [

package/services/encode/run-costs.js

@@ -48,6 +48,40 @@ export class RunCosts {
   /** How long the first output took to appear, in milliseconds. @type {number[]} */
   #firstOutput = [];
 
+  /**
+   * What this host was measured to do at startup, before any viewer existed.
+   *
+   * WITHOUT IT BOTH FIGURES ARE ZERO AT A COLD OPEN, and zero does not read as
+   * "not measured" — it reads as "free". The whole comparison the plan makes is
+   * between leaving an encoder where it stands, which costs the remainder of its
+   * warm-up, and moving it, which costs the killing plus a warm-up from the
+   * beginning. Subtract one from the other and what is left is the killing plus
+   * the time the run has already lived — the warm-up a move throws away. Set the
+   * warm-up to zero and that difference collapses to zero as well: keeping and
+   * moving cost exactly the same, the tie falls to position, and any advantage
+   * however small wins. Field 2026-09-08: an encoder moved between two adjacent
+   * numbers every half second, produced nothing, and was killed each time.
+   *
+   * Readings from real runs replace it as they arrive; this is where the plan
+   * starts from, not where it stays.
+   *
+   * @type {{ firstByteWaitSec: number, killCostSec: number } | null}
+   */
+  #atStartup = null;
+
+  /**
+   * Take what the startup measurement found on this host.
+   *
+   * @param {{ firstByteWaitSec: number, killCostSec: number } | null} measured
+   * @returns {void}
+   */
+  noteStartup(measured) {
+    this.#atStartup =
+      Number.isFinite(measured?.firstByteWaitSec) && measured.firstByteWaitSec > 0
+        ? { firstByteWaitSec: measured.firstByteWaitSec, killCostSec: Math.max(0, measured.killCostSec ?? 0) }
+        : null;
+  }
+
   /**
    * Take the two readings a finished run carries. Either may be absent — a run
    * that was never told to stop did not die on command, and one that produced
@@ -112,8 +146,9 @@ export class RunCosts {
     // piece's encoding. Whoever uses it separates the two, because the piece
     // costs more when encoders share the machine and the spawn does not.
     return {
-      killCostSec: (middleOf(this.#dying) ?? 0) / 1000,
-      firstByteWaitSec: (middleOf(this.#firstOutput) ?? 0) / 1000,
+      killCostSec: (middleOf(this.#dying) ?? 0) / 1000 || (this.#atStartup?.killCostSec ?? 0),
+      firstByteWaitSec:
+        (middleOf(this.#firstOutput) ?? 0) / 1000 || (this.#atStartup?.firstByteWaitSec ?? 0),
       samples: Math.min(this.#dying.length, this.#firstOutput.length)
     };
   }

package/services/encode/start-stop-cost.js

@@ -0,0 +1,174 @@
+/**
+ * @file What starting and stopping an encoder costs on THIS host, measured
+ * before any viewer exists.
+ *
+ * WHY IT HAS TO BE MEASURED AT STARTUP. Both figures decide one thing: whether
+ * to leave an encoder where it stands or kill it and start another elsewhere.
+ * The plan compares when the wanted pieces appear under each arrangement, and
+ * for that it needs how long a fresh encoder takes to produce anything and how
+ * long killing one takes.
+ *
+ * Until now both were learned only from runs that had ENDED, so at a cold open
+ * they were zero — and zero does not read as "not measured", it reads as
+ * "free". A warming encoder then owed one piece and a moved one owed
+ * `0 + 0 + one piece`: the same figure to the millisecond. The tie fell to
+ * position, so any advantage however small won, and the plan moved the encoder
+ * on every pass. Field 2026-09-08, the first fifteen seconds of a session:
+ * start at #68, a second later kill and start at #69, half a second later kill
+ * and start at #68 again, each dying having produced nothing. Over two days,
+ * 153 runs stopped that way and 68 of them made no segment at all.
+ *
+ * ONE RUN GIVES BOTH READINGS. An encoder is started on a generated picture
+ * through the same pipeline a session uses, timed until it says it has closed
+ * its first piece, then killed and timed until it exits. Nothing about the
+ * measurement is chosen: it is the same encoder, the same muxer, the same
+ * channel the encoder announces finished pieces on.
+ */
+
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+/**
+ * How long the measurement may take before it is abandoned.
+ *
+ * Not a property of the host and not a figure anything is derived from: it
+ * bounds a startup step so a machine that cannot produce a piece at all does not
+ * hold the proxy closed. A host that hits it has said something useful — that
+ * its first piece takes longer than this — and the plan is told the bound rather
+ * than a zero.
+ */
+const GIVE_UP_AFTER_MS = 30_000;
+
+/**
+ * Measure a start and a stop on this host.
+ *
+ * @param {object} params
+ * @param {string} params.ffmpegBin
+ * @param {import("./Encoder.js").Encoder} params.encoder - The encoder this
+ *   proxy has chosen, so the reading is of the thing that will actually run.
+ * @param {number} [params.segmentDurationSec]
+ * @param {{ info: Function, warn: Function }} [params.logger]
+ * @param {() => number} [params.now]
+ * @returns {Promise<{ firstByteWaitSec: number, killCostSec: number } | null>}
+ *   Null where nothing could be measured, which is said rather than passed off
+ *   as a zero.
+ */
+export async function measureStartAndStop({
+  ffmpegBin,
+  encoder,
+  segmentDurationSec = 4,
+  logger = null,
+  now = Date.now
+}) {
+  const log = logger ?? { info: () => {}, warn: () => {} };
+  const dir = mkdtempSync(path.join(os.tmpdir(), "tt-startstop-"));
+  try {
+    const args = [
+      "-hide_banner",
+      "-nostats",
+      "-loglevel",
+      "error",
+      // A generated picture: the reading is of this host's encoder and muxer,
+      // and a file would add its own reading and its own download.
+      "-f",
+      "lavfi",
+      "-i",
+      `testsrc2=size=640x360:rate=25`,
+      "-t",
+      String(segmentDurationSec * 4),
+      // The encoder this proxy has chosen, asked for its own arguments: the
+      // reading must be of the thing that will actually run, since what a start
+      // costs is mostly the encoder opening.
+      ...(typeof encoder?.buildVideoArgs === "function"
+        ? encoder.buildVideoArgs({ targetWidth: 640, targetHeight: 360, segmentDurationSec, fps: 25 })
+        : ["-c:v", "libx264", "-preset", "ultrafast"]),
+      "-an",
+      "-f",
+      "segment",
+      "-segment_time",
+      String(segmentDurationSec),
+      // The channel the encoder names its finished pieces on — the same one a
+      // session reads, so "the first piece exists" means here what it means
+      // there.
+      "-segment_list",
+      "pipe:3",
+      "-segment_list_flags",
+      "+live",
+      "-segment_format",
+      "mp4",
+      path.join(dir, "seg-%05d.mp4")
+    ];
+
+    const spawnedAt = now();
+    const child = spawn(ffmpegBin, args, {
+      stdio: ["ignore", "ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+
+    const firstPiece = await new Promise((resolve) => {
+      const timer = setTimeout(() => resolve(null), GIVE_UP_AFTER_MS);
+      timer.unref?.();
+      child.stdio?.[3]?.on("data", () => {
+        clearTimeout(timer);
+        resolve(now() - spawnedAt);
+      });
+      child.on("error", () => {
+        clearTimeout(timer);
+        resolve(null);
+      });
+      child.on("exit", () => {
+        clearTimeout(timer);
+        resolve(null);
+      });
+    });
+
+    if (firstPiece === null) {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+        // Already gone.
+      }
+      log.warn("hwaccel: a start could not be measured; the plan is told so rather than told zero");
+      return null;
+    }
+
+    const killedAt = now();
+    const died = await new Promise((resolve) => {
+      const timer = setTimeout(() => resolve(null), GIVE_UP_AFTER_MS);
+      timer.unref?.();
+      child.on("exit", () => {
+        clearTimeout(timer);
+        resolve(now() - killedAt);
+      });
+      try {
+        child.kill("SIGTERM");
+      } catch {
+        clearTimeout(timer);
+        resolve(null);
+      }
+    });
+
+    const firstByteWaitSec = firstPiece / 1000;
+    const killCostSec = died === null ? 0 : died / 1000;
+    log.info(
+      `hwaccel: a start costs ${firstByteWaitSec.toFixed(2)}s to a first piece and ` +
+      `a stop ${killCostSec.toFixed(2)}s on this host — measured before any viewer, ` +
+      "because a plan told zero reads it as free and moves an encoder for nothing"
+    );
+    return { firstByteWaitSec, killCostSec };
+  } catch (error) {
+    log.warn(
+      `hwaccel: a start and a stop could not be measured: ` +
+      `${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  } finally {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      // best effort
+    }
+  }
+}

package/services/hls-session-manager.js

@@ -93,8 +93,8 @@ import { Viewers } from "./viewer/Viewers.js";
 import { LiveOutputs } from "./output/LiveOutputs.js";
 import { variantHeightsFor } from "./output/ladder.js";
 import { EncodeOrchestrator } from "./orchestrators/EncodeOrchestrator.js";
-import { readDiskFree } from "./memory-report.js";
 import { wireDiskSpace } from "./disk/wire.js";
+import { freeBytesFor } from "./disk/free.js";
 
 /**
  * Whether an encoder run died because its INPUT went away, rather than because
@@ -1398,7 +1398,9 @@ export class HlsSessionManager {
     segmentFormatId = undefined,
     stateDir = "",
     segmentStore = null,
-    getTorrentTotals}) {
+    getTorrentTotals,
+    startStopCost = null,
+    spillDisk = null}) {
     this.enabled = Boolean(enabled);
     this.ffmpegBin = ffmpegBin;
     this.keyframeTableBudgetMs = Number.isFinite(keyframeTableBudgetMs) && keyframeTableBudgetMs > 0
@@ -1451,6 +1453,10 @@ export class HlsSessionManager {
     // torrent itself costs the machine (item 7). Optional: a proxy wired
     // without it simply never learns that figure.
     this.getTorrentTotals = typeof getTorrentTotals === "function" ? getTorrentTotals : null;
+    // The spilled pieces, as a pair of closures over the torrent thread: what
+    // they weigh and how to tell them their share. Not the pool — the pool is
+    // on the other side of the thread boundary and this side holds none of it.
+    this.spillDisk = spillDisk;
     // Detected H.264 encoder descriptor (hardware or software). Defaults to
     // software libx264 when no detection result is supplied. May be downgraded
     // to software at runtime if a hardware encode fails.
@@ -1571,6 +1577,11 @@ export class HlsSessionManager {
       segmentStore: this.segmentStore,
       logger
     });
+    // What a start and a stop were measured to cost here, before any viewer
+    // existed. Without it both read zero at a cold open, and zero is not
+    // "unmeasured" — it is "free", which is what moved an encoder between two
+    // adjacent numbers every half second in the field.
+    this.encodeOrchestrator.noteStartupCosts(startStopCost);
     // Where each file is cut, held once per file and grid rather than once per
     // session. Two sessions of one film MUST agree about this to the
     // millisecond — a segment made by either has to be appendable where the
@@ -1597,8 +1608,8 @@ export class HlsSessionManager {
     // One owner of the disk, and the list of what takes it lives with the owner.
     this.diskSpace = wireDiskSpace({
       segmentStore: this.segmentStore,
-      torrentPool: this.torrentPool,
-      readFree: readDiskFree,
+      spill: this.spillDisk,
+      readFree: freeBytesFor,
       logger
     });
     // Realtime-budget monitor: only meaningful for the software encoder with a