@torrent-tv/proxy 2.101.1 → 2.101.3

package/bin/cli.js

@@ -90,7 +90,6 @@ program
   .option("--no-port-mapping", "Disable automatic UPnP/NAT-PMP port mapping")
   .option("--delivery-sink", "Serve /api/delivery-sink, a torrent-free byte stream for delivery testing")
   .option("--pin-preset <name>", "Encode every software picture at this libx264 preset only, for runs that must be compared at one quality (off by default)")
-  .option("--input-stretch-bytes <bytes>", "Size every original-input stretch to this many bytes instead of copy rate times open, for runs that compare input sizes; memory, downloaded bytes and the plan still bound it (off by default)")
   .option("--heap-snapshots", "Write a heap snapshot of a thread whose memory reaches a new high-water; each one stops that thread while it is written (off by default)")
   .option("--profile-start <seconds>", "Profile the CPU of the main thread and the torrent thread for this many seconds from the first source opened, written beside the state (off by default)")
   .option(
@@ -400,7 +399,6 @@ try {
     profileStartSeconds: Number(options.profileStart) || 0,
     heapSnapshots: options.heapSnapshots === true,
     pinnedPreset: typeof options.pinPreset === "string" && options.pinPreset.trim() ? options.pinPreset.trim() : null,
-    inputStretchBytes: Number(options.inputStretchBytes) > 0 ? Math.floor(Number(options.inputStretchBytes)) : null,
     // Late-bound the same way `webRtcManager` is below: the torrent pool is
     // built inside `startProxyServer`, before `dataChannelHandler` — the
     // thing that actually owns a channel to push down — exists.

package/package.json

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

package/server.js

@@ -88,6 +88,7 @@ import { takeTurns } from "./utils/take-turns.js";
 import { completedFilesRoot } from "./services/storage/files/CompletedFiles.js";
 import { startupCpuProfile } from "./services/storage/cpu-profile.js";
 import { startProcessorReport } from "./services/storage/processor-report.js";
+import { processorBound } from "./services/storage/machine-processor.js";
 
 const require = createRequire(import.meta.url);
 const { version } = require("./package.json");
@@ -134,9 +135,6 @@ export async function startProxyServer({
   // The one software preset every picture is encoded at, for runs compared at
   // one quality; null leaves the choice to the machine.
   pinnedPreset = null,
-  // The size every original-input stretch is given in place of copy rate
-  // times open, for runs that compare input sizes; null keeps the rule.
-  inputStretchBytes = null,
   // What viewers' connections carry beyond the film, per byte of film; the
   // transport counts it and is built after this server, so it is late-bound.
   serviceShare = () => null,
@@ -234,6 +232,10 @@ export async function startProxyServer({
   let videoEncoder = transcodeAudio
     ? await detectVideoEncoder({ ffmpegBin, logger })
     : null;
+  // The cores this process may use (a container's quota or CPU set): the
+  // readings below divide out a share of those, the unit every later share of
+  // the machine is in (torrent-tv/meta#180, phase 3).
+  const processorCores = processorBound().cores;
   // 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
@@ -246,7 +248,7 @@ export async function startProxyServer({
   // (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 })
+    ? await benchmarkDecodeCost({ ffmpegBin, logger, processorCores })
     : 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
@@ -267,16 +269,16 @@ export async function startProxyServer({
   // the processor and the threads, the device and its driver — which is what
   // decides whether anything kept from an earlier run still applies.
   const fingerprint = videoEncoder
-    ? await readHostFingerprint({ ffmpegBin, encoder: videoEncoder })
+    ? await readHostFingerprint({ ffmpegBin, encoder: videoEncoder, processorCores })
     : null;
   /** @type {Record<string, object[]>} */
   const calibratedModes = {};
   if (videoEncoder) {
     calibratedModes[videoEncoder.kind] =
-      (await calibrateEncoder({ ffmpegBin, encoder: videoEncoder, logger })).modes;
+      (await calibrateEncoder({ ffmpegBin, encoder: videoEncoder, logger, processorCores })).modes;
     if (videoEncoder.kind !== "software") {
       calibratedModes.software =
-        (await calibrateEncoder({ ffmpegBin, encoder: softwareDescriptor(), logger })).modes;
+        (await calibrateEncoder({ ffmpegBin, encoder: softwareDescriptor(), logger, processorCores })).modes;
       // A device that passed detection's own test and then none of whose modes
       // passed the product's is not used: detection encodes a synthetic pattern
       // with arguments of its own, and it is the product's arguments a viewer
@@ -857,7 +859,6 @@ export async function startProxyServer({
   let sourcePreparation;
   const outputParts = wireOutputs({
     pinnedPreset,
-    inputStretchBytes,
     indexMemory,
     serviceShare,
     readMetadataActivity: () => containerOrchestrator.activity(),

package/services/encode/EncodeInputs.js

@@ -62,20 +62,10 @@ export class EncodeInputs {
    * @type {(output: object, from: number, to: number, input: object) => void}
    */
   #stretchCopied;
-  /**
-   * A stretch size the operator named for comparison runs
-   * (`--input-stretch-bytes`), in place of copy rate times open; null keeps
-   * the measured rule. Only the target changes: memory, downloaded bytes and
-   * the plan's bound still end a stretch (torrent-tv/meta#182).
-   *
-   * @type {number | null}
-   */
-  #fixedStretchBytes;
 
   constructor({ resolve, readRanges, heldRanges = null, reviseBudget, changed, failed, capacity = () => null, urgent = () => true,
-    rankAt = () => null, openOf = () => null, log = () => {}, now = Date.now, stretchCopied = () => {}, stretchBytes = null }) {
+    rankAt = () => null, openOf = () => null, log = () => {}, now = Date.now, stretchCopied = () => {} }) {
     this.#stretchCopied = stretchCopied;
-    this.#fixedStretchBytes = Number.isSafeInteger(stretchBytes) && stretchBytes > 0 ? stretchBytes : null;
     this.#openOf = openOf;
     this.#resolve = resolve;
     this.#read = readRanges;
@@ -354,10 +344,6 @@ export class EncodeInputs {
   #sizingFor(output) {
     const rate = middleOf(this.#copyRates);
     const open = this.#openOf(output);
-    if (this.#fixedStretchBytes !== null) {
-      return { bytes: this.#fixedStretchBytes, openMeasured: true, openSeconds: open?.seconds ?? null,
-        copyBytesPerMs: rate, fixed: true };
-    }
     return rate === null || !open ? null : { bytes: Math.floor(rate * open.seconds * 1000),
       openMeasured: open.measured, openSeconds: open.seconds, copyBytesPerMs: rate };
   }
@@ -621,7 +607,7 @@ export class EncodeInputs {
     if (result.kind === "result") {
       this.#log(`encode input selection of ${addressOf(output)}: ${JSON.stringify({
         from, requestedTo: request.to, serves, floor, targetEnd, chosenEnd: end,
-        targetBytes: target, targetFixed: sizing?.fixed === true, minimumBytes: minimum, inputBytes: result.bytes,
+        targetBytes: target, minimumBytes: minimum, inputBytes: result.bytes,
         copyBytesPerMs: sizing?.copyBytesPerMs ?? null, openSeconds: sizing?.openSeconds ?? null,
         openMeasured: sizing?.openMeasured ?? null, reservations, probes
       })}`);

package/services/encode/ProcessorBudget.js

@@ -0,0 +1,104 @@
+/**
+ * @file The one owner of what this machine's processor gives the encoders
+ * (torrent-tv/meta#180, phase 2: one owner, results unchanged).
+ *
+ * Before it, the same two readings reached the processor's decisions by six
+ * routes: the share of the machine other work leaves (`HostLoad`'s latest
+ * reading) was read separately by the admission, the quality offer, the cost
+ * model and the download share, and the contention penalties measured at
+ * startup were handed separately to the cost model, the runs and the plan. A
+ * reading that changes, or a new one (the processor's bound and measured free
+ * amount, `storage/machine-processor.js`), would have had to be threaded to
+ * each of them again. Now each asks this object, and the arithmetic stays in
+ * the two files that define it (`available-share.js`, `contention.js`).
+ *
+ * It lives in the encoding component because every question it answers is the
+ * encoders', and that component may import nothing outside itself; it is
+ * assembled beside the machine budget in `server/wire-outputs.js`. Its unit is
+ * today's: shares of the whole machine and seconds of the whole machine per
+ * second of film. Nothing here changes an answer.
+ */
+
+import { correctForAvailability, leftForEncoders } from "./available-share.js";
+import { contentionPenalty } from "./contention.js";
+
+export class ProcessorBudget {
+  /** @type {() => ({ share: number, forEncoders?: number, known: boolean } | null | undefined)} */
+  #reading;
+
+  /** @type {import("./contention.js").ContentionPenalties | null} */
+  #penalties;
+
+  /**
+   * @param {object} params
+   * @param {() => ({ share: number, forEncoders?: number, known: boolean } | null | undefined)} params.reading -
+   *   The latest share of the machine other work leaves, as `HostLoad` keeps it.
+   * @param {import("./contention.js").ContentionPenalties | null} [params.penalties] -
+   *   How much slower one job runs beside others, measured at startup.
+   */
+  constructor({ reading, penalties = null }) {
+    if (typeof reading !== "function") {
+      throw new TypeError("ProcessorBudget requires reading");
+    }
+    this.#reading = reading;
+    this.#penalties = penalties instanceof Map ? penalties : null;
+  }
+
+  /**
+   * The latest share of the machine other work leaves, or null before the
+   * first reading.
+   *
+   * @returns {{ share: number, forEncoders?: number, known: boolean } | null}
+   */
+  availability() {
+    return this.#reading() ?? null;
+  }
+
+  /**
+   * The share of the machine an encoder gets now; 1 where the host does not
+   * report its load.
+   *
+   * @returns {number}
+   */
+  left() {
+    return leftForEncoders(this.availability());
+  }
+
+  /**
+   * A speed measured alone on a quiet machine, as it would run now.
+   *
+   * @param {number} aloneSpeed
+   * @returns {number}
+   */
+  speedOf(aloneSpeed) {
+    return correctForAvailability(aloneSpeed, this.availability());
+  }
+
+  /**
+   * The measured penalties, as the plan and the runs read them.
+   *
+   * @returns {import("./contention.js").ContentionPenalties | null}
+   */
+  get penalties() {
+    return this.#penalties;
+  }
+
+  /**
+   * Replace the penalties, as a new measurement of them does.
+   *
+   * @param {import("./contention.js").ContentionPenalties | null} penalties
+   */
+  set penalties(penalties) {
+    this.#penalties = penalties instanceof Map ? penalties : null;
+  }
+
+  /**
+   * How much slower one job runs with `others` beside it.
+   *
+   * @param {number} others
+   * @returns {{ penalty: number, measured: boolean, from: number }}
+   */
+  penaltyFor(others) {
+    return contentionPenalty(others, this.#penalties);
+  }
+}

package/services/encode/available-share.js

@@ -41,6 +41,19 @@
  * `share`, what other processes leave, stays for the download's share of the
  * proxy's processor (`processor-share.js`), which divides the proxy's room
  * between its own download and its encoders and must not lose that room twice.
+ *
+ * THE WHOLE MACHINE IS WHAT THIS PROCESS MAY USE (torrent-tv/meta#180, phase
+ * 3). `/proc/stat` and `os.cpus()` describe the host; a container's CPU quota
+ * (`cpu.max`, Docker `--cpus`) or a CPU set (`--cpuset-cpus`) gives the proxy
+ * fewer cores than that. Where such a bound is smaller than the host, both
+ * shares are fractions of the bound instead: the encoders get what the host's
+ * other work leaves, but never more than the bound less the proxy's own draw.
+ * Measured as fractions of the host, a 1.5-core quota on an 8-core host read
+ * a busy neighbour as lost room the quota never had, and the proxy's own draw
+ * as an eighth of what it takes from the quota. The startup measurements are
+ * divided by the same fraction (`host-load.js` `freeShareDuring`), so a cost
+ * filed from either stays in one unit. Without a bound smaller than the host,
+ * nothing changes.
  */
 
 /**
@@ -52,10 +65,17 @@
  * @param {number | null} reading.encoderShare - Our own ffmpeg processes.
  * @param {number | null} reading.proxyShare - The proxy process itself, every
  *   thread of it.
- * @returns {{ share: number, forEncoders: number, unattributed: number, known: boolean }}
+ * @param {number | null} [reading.hostCores] - The cores the three shares
+ *   above are fractions of.
+ * @param {number | null} [reading.boundCores] - The cores this process may use
+ *   (`storage/machine-processor.js` `processorBound`); counts only when
+ *   smaller than `hostCores`.
+ * @returns {{ share: number, forEncoders: number, unattributed: number, known: boolean, boundCores?: number }}
  *   `share` is what other processes leave; `forEncoders` what they and the
- *   proxy leave. `known` is false when the host does not report its own load —
- *   then both are 1 and the caller must say it is uncorrected rather than pretend.
+ *   proxy leave; both of `boundCores` where it is given, else of the whole
+ *   host. `unattributed` stays a fraction of the host. `known` is false when
+ *   the host does not report its own load — then both are 1 and the caller
+ *   must say it is uncorrected rather than pretend.
  */
 export function availableShareFrom(reading = {}) {
   const systemBusy = finite(reading.systemBusy);
@@ -65,11 +85,26 @@ export function availableShareFrom(reading = {}) {
     return { share: 1, forEncoders: 1, unattributed: 0, known: false };
   }
   const encoders = finite(reading.encoderShare) ?? 0;
-  const ours = encoders + (finite(reading.proxyShare) ?? 0);
+  const proxy = finite(reading.proxyShare) ?? 0;
+  const ours = encoders + proxy;
   // Rounding, and the two readings being taken microseconds apart, can put our
   // own share fractionally above the system total. Below zero is not a
   // measurement of anything.
   const unattributed = clamp(systemBusy - ours, 0, 1);
+  const hostCores = finite(reading.hostCores);
+  const boundCores = finite(reading.boundCores);
+  if (hostCores !== null && boundCores !== null && boundCores > 0 && boundCores < hostCores) {
+    // In cores: the host's other work takes from the host, the proxy's own
+    // draw from the bound as well.
+    const leftOnHost = hostCores - clamp(systemBusy - encoders, 0, 1) * hostCores;
+    return {
+      share: clamp(Math.min(boundCores, hostCores - unattributed * hostCores) / boundCores, 0, 1),
+      forEncoders: clamp(Math.min(boundCores - proxy * hostCores, leftOnHost) / boundCores, 0, 1),
+      unattributed,
+      known: true,
+      boundCores
+    };
+  }
   return { share: clamp(1 - unattributed, 0, 1), forEncoders: clamp(1 - (systemBusy - encoders), 0, 1),
     unattributed, known: true };
 }

package/services/encode/calibration.js

@@ -185,6 +185,8 @@ async function checkModeProducesCorrectSegments({ ffmpegBin, encoder, rung, segm
  * @param {{ info: (m: string) => void, warn: (m: string) => void }} [params.logger]
  * @param {number} [params.segmentDurationSec]
  * @param {Array<{ width: number, height: number }>} [params.frames]
+ * @param {number | null} [params.processorCores] - The cores this process may
+ *   use, which the readings' share of the machine is of (`measureEncodeSlope`).
  * @param {object} [params.measure] - Replaces the three readings, for a check
  *   that must not run ffmpeg: `check`, `rawFrames`, `speed`. `speed` answers a
  *   number, or `{ speed, freeShare }` as `measureEncodeSlope` does.
@@ -196,12 +198,13 @@ export async function calibrateEncoder({
   logger,
   segmentDurationSec = 4,
   frames = CALIBRATION_FRAMES,
+  processorCores = null,
   measure = null
 }) {
   const log = logger ?? { info: () => {}, warn: () => {} };
   const check = measure?.check ?? checkModeProducesCorrectSegments;
   const rawFrames = measure?.rawFrames ?? ((frame) => decodeToRawFrames(ffmpegBin, log, frame));
-  const speed = measure?.speed ?? ((rung, rawPath, frame) => measureEncodeSlope(ffmpegBin, encoder, rung, rawPath, frame));
+  const speed = measure?.speed ?? ((rung, rawPath, frame) => measureEncodeSlope(ffmpegBin, encoder, rung, rawPath, frame, processorCores));
   const release = measure?.release ?? ((rawPath) => {
     try {
       rmSync(path.dirname(rawPath), { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });

package/services/encode/fingerprint.js

@@ -22,7 +22,10 @@
  * 2. the libx264 build — the version string x264 writes into every stream it
  *    produces (`x264 - core N rNNNN hash`), read from one encoded frame;
  * 3. the processor model and the thread count the encoder is given
- *    (`CPU_THREADS`, which is the core count);
+ *    (`CPU_THREADS`, which is the core count), and the cores this process may
+ *    use where a container's CPU quota or CPU set makes them fewer: a speed
+ *    filed as a share of those cores (`available-share.js`) does not hold
+ *    under another quota (torrent-tv/meta#180);
  * 4. for a device-backed encoder, the device model and its driver: NVIDIA's
  *    own tool where it exists, and otherwise what the kernel publishes under
  *    `/sys` for the render node or the video device.
@@ -116,7 +119,9 @@ export function configurationKeyOf(fingerprint, encoder) {
       ...common,
       `x264=${fingerprint?.x264 ?? UNKNOWN}`,
       `cpu=${fingerprint?.cpu ?? UNKNOWN}`,
-      `threads=${fingerprint?.threads ?? UNKNOWN}`
+      `threads=${fingerprint?.threads ?? UNKNOWN}`,
+      // Only where it binds, so a host without a quota keeps its key.
+      ...(Number.isFinite(fingerprint?.boundCores) ? [`bound=${fingerprint.boundCores}`] : [])
     ].join(";");
   }
   const device = fingerprint?.devices?.[encoder?.kind] ?? null;
@@ -137,6 +142,8 @@ export function configurationKeyOf(fingerprint, encoder) {
  * @property {string} x264
  * @property {string} cpu
  * @property {number} threads
+ * @property {number | null} [boundCores] - The cores this process may use,
+ *   where fewer than the host's; absent or null otherwise.
  * @property {Record<string, DeviceFingerprint>} devices - By encoder kind.
  */
 
@@ -288,10 +295,10 @@ async function nvidiaDevice() {
  * Read this host's fingerprint. Always resolves: an unreadable part is
  * `unknown`, never a refusal to start.
  *
- * @param {{ ffmpegBin: string, encoder?: { kind: string, device: string | null } | null }} params
+ * @param {{ ffmpegBin: string, encoder?: { kind: string, device: string | null } | null, processorCores?: number | null }} params
  * @returns {Promise<HostFingerprint>}
  */
-export async function readHostFingerprint({ ffmpegBin, encoder = null }) {
+export async function readHostFingerprint({ ffmpegBin, encoder = null, processorCores = null }) {
   const versionText = await capture(ffmpegBin, ["-hide_banner", "-version"], 5000);
   // `-hide_banner` does not hide the version line itself: it is the answer.
   const ffmpeg = parseFfmpegVersion(versionText ? versionText.toString("utf8") : "");
@@ -317,6 +324,7 @@ export async function readHostFingerprint({ ffmpegBin, encoder = null }) {
     x264,
     cpu: os.cpus()[0]?.model?.trim() || UNKNOWN,
     threads: CPU_THREADS,
+    boundCores: Number.isFinite(processorCores) && processorCores < os.cpus().length ? processorCores : null,
     devices
   };
 }

package/services/encode/host-load.js

@@ -189,14 +189,14 @@ export function shareOfMachine(before, after, cores = os.cpus().length) {
  * One reading of everything above, to be compared against the next.
  *
  * @param {number | null} pid - The encoder's process, when one is running.
- * @returns {Promise<{ takenAt: number, processCpuSeconds: number | null, system: CpuTotals | null }>}
+ * @returns {Promise<{ takenAt: number, processCpuSeconds: number | null, system: CpuTotals | null, proxyCpuSeconds: number }>}
  */
 export async function sampleHost(pid) {
   const [processCpuSeconds, system] = await Promise.all([
     pid === null ? Promise.resolve(null) : readProcessCpuSeconds(pid),
     readSystemCpu()
   ]);
-  return { takenAt: Date.now(), processCpuSeconds, system };
+  return { takenAt: Date.now(), processCpuSeconds, system, proxyCpuSeconds: readProxyCpuSeconds() };
 }
 
 /**
@@ -215,12 +215,22 @@ export async function sampleHost(pid) {
  * Null when the host does not report its load (no `/proc`), or a reading was
  * refused; the measurement is then used as it was read, and says so.
  *
- * @param {{ takenAt: number, processCpuSeconds: number | null, system: object | null } | null} before
- * @param {{ takenAt: number, processCpuSeconds: number | null, system: object | null } | null} after
+ * Where this process may use fewer cores than the host has (a container's CPU
+ * quota or CPU set, `boundCores`), the share is of those cores, as the share a
+ * running encoder is filed with (`available-share.js`): what the host's other
+ * work leaves, but never more than the bound less this process's own draw.
+ * Otherwise the measurement, which ran inside the bound, was divided by a
+ * share of the whole host, and a busy neighbour made it read faster than the
+ * bound allows (torrent-tv/meta#180, phase 3).
+ *
+ * @param {{ takenAt: number, processCpuSeconds: number | null, system: object | null, proxyCpuSeconds?: number | null } | null} before
+ * @param {{ takenAt: number, processCpuSeconds: number | null, system: object | null, proxyCpuSeconds?: number | null } | null} after
  * @param {number} [cores]
+ * @param {number | null} [boundCores] - The cores this process may use; counts
+ *   only when fewer than `cores`.
  * @returns {number | null} Between 0 and 1.
  */
-export function freeShareDuring(before, after, cores = os.cpus().length) {
+export function freeShareDuring(before, after, cores = os.cpus().length, boundCores = null) {
   if (!before || !after) {
     return null;
   }
@@ -229,10 +239,28 @@ export function freeShareDuring(before, after, cores = os.cpus().length) {
     return null;
   }
   const others = Math.min(1, Math.max(0, shares.systemShare - shares.processShare));
-  const free = 1 - others;
+  const free = Number.isFinite(boundCores) && boundCores > 0 && boundCores < cores
+    ? Math.min(1, (cores - others * cores) / boundCores, (boundCores - proxyCoresBetween(before, after)) / boundCores)
+    : 1 - others;
   return free > 0 ? free : null;
 }
 
+/**
+ * The cores this process drew between two readings; 0 where either has no
+ * reading of it.
+ *
+ * @param {{ takenAt: number, proxyCpuSeconds?: number | null }} before
+ * @param {{ takenAt: number, proxyCpuSeconds?: number | null }} after
+ * @returns {number}
+ */
+function proxyCoresBetween(before, after) {
+  const elapsedSec = (after.takenAt - before.takenAt) / 1000;
+  if (!(elapsedSec > 0) || !Number.isFinite(before.proxyCpuSeconds) || !Number.isFinite(after.proxyCpuSeconds)) {
+    return 0;
+  }
+  return Math.max(0, (after.proxyCpuSeconds - before.proxyCpuSeconds) / elapsedSec);
+}
+
 /**
  * How much CPU THIS process has used, across every thread it owns.
  *

package/services/encode/hwaccel.js

@@ -679,13 +679,13 @@ export async function benchmarkContention({ ffmpegBin, logger, clipsDir = CALIBR
   return penalties;
 }
 
-export async function benchmarkDecodeCost({ ffmpegBin, logger, clipsDir = CALIBRATION_DIR }) {
+export async function benchmarkDecodeCost({ ffmpegBin, logger, clipsDir = CALIBRATION_DIR, processorCores = null }) {
   const log = logger ?? { info: () => {}, warn: () => {} };
   const startedAllAt = Date.now();
   /** @type {Record<string, { pixelTerm: number, bitrateTerm: number, constantTerm: number }>} */
   const families = {};
   for (const [family, clips] of Object.entries(CALIBRATION_SETS)) {
-    const fitted = await fitOneFamily({ ffmpegBin, log, clipsDir, family, clips });
+    const fitted = await fitOneFamily({ ffmpegBin, log, clipsDir, family, clips, processorCores });
     if (fitted) {
       families[family] = fitted;
     }
@@ -721,10 +721,10 @@ export async function benchmarkDecodeCost({ ffmpegBin, logger, clipsDir = CALIBR
 /**
  * Fit one codec family's decode cost from its own clips.
  *
- * @param {{ ffmpegBin: string, log: { info: Function, warn: Function }, clipsDir: string, family: string, clips: string[] }} params
+ * @param {{ ffmpegBin: string, log: { info: Function, warn: Function }, clipsDir: string, family: string, clips: string[], processorCores?: number | null }} params
  * @returns {Promise<{ pixelTerm: number, bitrateTerm: number, constantTerm: number } | null>}
  */
-async function fitOneFamily({ ffmpegBin, log, clipsDir, family, clips }) {
+async function fitOneFamily({ ffmpegBin, log, clipsDir, family, clips, processorCores = null }) {
   const startedAllAt = Date.now();
   /** @type {Array<{ megapixelsPerSecond: number, megabitsPerSecond: number, costSecondsPerSecond: number }>} */
   const samples = [];
@@ -745,7 +745,7 @@ async function fitOneFamily({ ffmpegBin, log, clipsDir, family, clips }) {
   }
   for (const [index, clip] of clips.entries()) {
     const stream = streams[index];
-    const measured = stream ? await decodePipedStream(ffmpegBin, stream, log) : null;
+    const measured = stream ? await decodePipedStream(ffmpegBin, stream, log, processorCores) : null;
     if (!measured?.speed) {
       log.warn(
         `hwaccel: decode benchmark "${clip}" said nothing; ${family} not measured` +
@@ -998,9 +998,11 @@ function runCapturingStderr(ffmpegBin, args, timeoutMs) {
  *
  * @param {string} ffmpegBin
  * @param {{ bytes: Buffer, demuxer: string, megapixelsPerSecond: number, megabitsPerSecond: number, fps: number }} stream
+ * @param {{ info: Function, warn: Function }} [log]
+ * @param {number | null} [processorCores] - The cores this process may use, for `freeShareDuring`.
  * @returns {Promise<{ speed: number, windowSec: number, megapixelsPerSecond: number, megabitsPerSecond: number } | null>}
  */
-function decodePipedStream(ffmpegBin, stream, log = { info: () => {}, warn: () => {} }) {
+function decodePipedStream(ffmpegBin, stream, log = { info: () => {}, warn: () => {} }, processorCores = null) {
   return new Promise((resolve) => {
     const args = [
       "-hide_banner", "-loglevel", "error", "-nostats",
@@ -1047,7 +1049,7 @@ function decodePipedStream(ffmpegBin, stream, log = { info: () => {}, warn: () =
       const hostAfter = hostBefore !== null && child?.pid && child.exitCode === null
         ? await sampleHost(child.pid).catch(() => null)
         : null;
-      const freeShare = freeShareDuring(hostBefore === null ? null : await hostBefore, hostAfter);
+      const freeShare = freeShareDuring(hostBefore === null ? null : await hostBefore, hostAfter, undefined, processorCores);
       try {
         child?.stdin?.destroy();
       } catch {
@@ -1418,9 +1420,13 @@ export function slopeOf(samples, minimumWindowSec = ENCODE_BENCHMARK_WINDOW_SEC)
  * A hardware encoder is limited by its device and not by the cores, so its
  * reading is kept as read.
  *
+ * `processorCores` is the cores this process may use (a container's quota or
+ * CPU set); the share divided out is of those where they are fewer than the
+ * host's (`freeShareDuring`, torrent-tv/meta#180).
+ *
  * @returns {Promise<{ speed: number, measuredSpeed: number, freeShare: number | null } | null>}
  */
-export function measureEncodeSlope(ffmpegBin, encoder, rung, rawFramesPath, frame = { width: BENCHMARK_REF_W, height: BENCHMARK_REF_H }) {
+export function measureEncodeSlope(ffmpegBin, encoder, rung, rawFramesPath, frame = { width: BENCHMARK_REF_W, height: BENCHMARK_REF_H }, processorCores = null) {
   const cpuBound = encoder?.kind === "software";
   return new Promise((resolve) => {
     const args = [
@@ -1470,7 +1476,7 @@ export function measureEncodeSlope(ffmpegBin, encoder, rung, rawFramesPath, fram
           resolve(null);
           return;
         }
-        const freeShare = freeShareDuring(before, after);
+        const freeShare = freeShareDuring(before, after, undefined, processorCores);
         resolve({ speed: freeShare === null ? value : value / freeShare, measuredSpeed: value, freeShare });
       });
     };

package/services/encode/quality/HostLoad.js

@@ -593,6 +593,7 @@ export class HostLoad {
       // What the offer will multiply a prediction by, in the same line as the
       // readings it comes from.
       ` available=${asPercent(this.hostAvailability.share)} for-encoders=${asPercent(this.hostAvailability.forEncoders)}` +
+      (Number.isFinite(this.hostAvailability.boundCores) ? ` of ${this.hostAvailability.boundCores.toFixed(2)} cores` : "") +
       ` free=${asPercent(free)}` + processor + late
     );
   }
@@ -664,7 +665,7 @@ export class HostLoad {
   /**
    * @param {{ elapsedSec: number, processShare: number | null, systemShare: number | null, rejected?: string[] } | null} share
    * @param {{ proxyCpuSeconds: number | null }} previous
-   * @param {{ proxyCpuSeconds: number | null }} sample
+   * @param {{ proxyCpuSeconds: number | null, processor?: { bound?: { cores: number } | null } | null }} sample
    * @returns {number | null} The proxy's own share of the machine, for the log.
    */
   #setAvailability(share, previous, sample) {
@@ -682,10 +683,14 @@ export class HostLoad {
     const proxyShare = Number.isFinite(previous.proxyCpuSeconds)
       ? (sample.proxyCpuSeconds - previous.proxyCpuSeconds) / (share.elapsedSec * cores)
       : null;
+    // Of the cores this process may use where that is fewer than the host's
+    // (torrent-tv/meta#180, phase 3).
     this.hostAvailability = availableShareFrom({
       systemBusy: share.systemShare,
       encoderShare: share.processShare,
-      proxyShare
+      proxyShare,
+      hostCores: cores,
+      boundCores: sample.processor?.bound?.cores ?? null
     });
     return proxyShare;
   }

package/services/server/ViewerRequests.js

@@ -658,6 +658,7 @@ export class ViewerRequests {
           fileLength: stats?.fileLength,
           pieceLength: stats?.pieceLength,
           downloadRateReadings: this.#sourceRateReadings(measurement, output.file.sourceKey, stats, now),
+          downloadRateSummaries: this.#sourceRateSummaries(measurement, output.file.sourceKey),
           downloadForecast,
         });
       }
@@ -774,11 +775,14 @@ export class ViewerRequests {
         bufferLimitSeconds: input.bufferLimitSeconds,
         lookaheadSeconds: input.lookaheadSeconds,
         link: input.linkReadings,
-        sources: input.sources.map(({ id, complete, residence, downloadForecast, downloadRateReadings }) => ({
+        sources: input.sources.map(({ id, complete, residence, downloadForecast, downloadRateReadings,
+          downloadRateSummaries }) => ({
           id, complete, residenceRanges: residence?.length ?? 0,
           forecastAt: downloadForecast?.measuredAt ?? null, plannedPieces: downloadForecast?.ranges.length ?? 0,
           unknownPieces: downloadForecast?.ranges.filter(range => range.availableAt === null).length ?? 0,
-          downloadRateBytesPerSecond: downloadRateReadings?.lastValue ?? null
+          // The rate the forecast reads, and both summaries it was chosen from.
+          downloadRateBytesPerSecond: this.#host.playbackReadiness.forecastRate(downloadRateReadings, now, 0, "time"),
+          downloadRateSummaries
         })),
         tracks: tracks.map(({ id, processedSeconds, readings, segments, readySegmentIndices }) => ({
           id, processedSeconds, readings, segments: segments.length, prepared: readySegmentIndices.length
@@ -818,7 +822,7 @@ export class ViewerRequests {
     const rates = (forecast.operations ?? []).map(operation =>
       `${operation.track} ${operation.operation} ${Number.isFinite(operation.speed) ? operation.speed.toFixed(2) : "?"}x`);
     const downloads = (input.sources ?? []).map(source => {
-      const rate = source.downloadRateReadings?.lastValue;
+      const rate = this.#host.playbackReadiness.forecastRate(source.downloadRateReadings, now, 0, "time");
       return `${Number.isFinite(rate) ? (rate / 1_048_576).toFixed(2) : "?"} MB/s`;
     });
     logger.info(`playback held ${session.id} consumer=${consumerId}: delay ${seconds(delay)}s by ` +
@@ -949,7 +953,14 @@ export class ViewerRequests {
     }
     // Totals that went back belong to a torrent added again: read on from them.
     if (limit) source.limit = limit;
-    return sourceService(source.free.snapshot(), source.delivered.snapshot());
+    return sourceService(source.free.snapshot(), source.delivered.snapshot(),
+      (summary) => this.#host.playbackReadiness.forecastRate(summary, now, 0, "time"));
+  }
+
+  /** Both summaries a source's service was chosen from, for the forecast's log line. */
+  #sourceRateSummaries(state, id) {
+    const source = state.sources.get(id);
+    return source ? { free: source.free.snapshot(), delivered: source.delivered.snapshot() } : null;
   }
 }
 
@@ -962,12 +973,19 @@ export class ViewerRequests {
  * downloaded 5-18 MB/s, answered "service not advancing", and held the viewer
  * (r54, torrent-tv/meta#178). What the swarm did carry, it can carry.
  *
+ * The two are compared by the rate the forecast reads from them, bytes over
+ * the span measured. Compared by their last readings, a summary whose last
+ * reading was 10.7 MB/s and whose span read 0 B/s won over 3.4-16.7 MB/s
+ * carried, and the forecast held the viewer with no delay to state (r74,
+ * torrent-tv/meta#185).
+ *
  * @param {object | null} free - A rate summary (`RateTrend.snapshot`).
  * @param {object | null} delivered
+ * @param {(summary: object) => number | null} rateOf - The rate the forecast reads from a summary.
  * @returns {object | null}
  */
-export function sourceService(free, delivered) {
+export function sourceService(free, delivered, rateOf) {
   if (!free) return delivered;
   if (!delivered) return free;
-  return delivered.lastValue > free.lastValue ? delivered : free;
+  return (rateOf(delivered) ?? 0) > (rateOf(free) ?? 0) ? delivered : free;
 }

package/services/server/wire-outputs.js

@@ -102,6 +102,7 @@ import { configurationKeyOf } from "../encode/fingerprint.js";
 import { qualityStateOf } from "../encode/quality/OutputQualityState.js";
 import { downloadShare } from "../storage/processor-share.js";
 import { describeProcessor, processorBetween, sampleProcessor } from "../storage/machine-processor.js";
+import { ProcessorBudget } from "../encode/ProcessorBudget.js";
 import { ENCODE_RUN_STATE, processCanBeSignalled } from "../encode/encode-run-state.js";
 import { secondsUntilClosed } from "../encode/piece-close-time.js";
 
@@ -196,9 +197,6 @@ export function wireOutputs({
     // A software preset every picture is encoded at, for runs compared at one
     // quality (`--pin-preset`); null leaves the choice to the machine.
     pinnedPreset = null,
-    // A size every original-input stretch is given in place of copy rate
-    // times open (`--input-stretch-bytes`); null keeps the rule.
-    inputStretchBytes = null,
     // What every encoder this host may use was qualified and measured to do at
     // startup, by kind (`encode/calibration.js`). Takes the place of the one
     // array above, which a test may still hand in on its own.
@@ -350,7 +348,7 @@ export function wireOutputs({
     producedNumbers: (...args) => parts.serving.producedNumbers(...args),
     servesAudioSeparately: (...args) => parts.renditions.servesAudioSeparately(...args),
     disposeSession: (...args) => parts.lifecycle.disposeSession(...args),
-    get contentionPenalties() { return parts.contentionPenalties; },
+    get contentionPenalties() { return parts.processor?.penalties ?? null; },
     get encodeCost() { return parts.encodeCost; },
     get encodeOrchestrator() { return parts.encodeOrchestrator; },
     get ffmpegBin() { return parts.ffmpegBin; },
@@ -736,7 +734,7 @@ export function wireOutputs({
       files.set(key, file);
     }
     const watched = [...files.values()].filter((file) => Number.isFinite(file.bytesPerFilmSecond) && file.bytesPerFilmSecond > 0);
-    const share = downloadShare({ availableShare: parts.hostLoad.hostAvailability?.share ?? 1,
+    const share = downloadShare({ availableShare: parts.processor?.availability()?.share ?? 1,
       baseDraw: parts.hostLoad.baseDraw, costPerMegabyte: parts.hostLoad.observedTorrentCostPerMegabyte, files: watched });
     // Kept beside the readings it is judged against: what the torrents moved
     // over each interval is said next to the limit in force (meta#178).
@@ -744,7 +742,17 @@ export function wireOutputs({
     void Promise.resolve(parts.setDownloadRate(share.bytesPerSecond, `film speed ${share.filmSpeed.toFixed(2)}x ` +
       `over ${watched.length} file(s), ${Math.round(share.capacity * 100)}% of the machine for the proxy`)).catch(() => {});
   };
-  parts.contentionPenalties = contentionPenalties instanceof Map ? contentionPenalties : null;
+  // The one owner of what the processor gives the encoders: the share of the
+  // machine other work leaves and the measured contention penalties, read by
+  // every place that decides on the processor (torrent-tv/meta#180).
+  parts.processor = new ProcessorBudget({ reading: () => parts.hostLoad.hostAvailability, penalties: contentionPenalties });
+  // Kept as the name the penalties were always set and read by, now the budget's.
+  Object.defineProperty(parts, "contentionPenalties", {
+    get: () => parts.processor.penalties,
+    set: (penalties) => { parts.processor.penalties = penalties; },
+    enumerable: true,
+    configurable: true
+  });
   // Seconds of film per second when the picture is COPIED, measured at
   // startup. Nothing else prices that branch: the other benchmarks measure
   // encoding and decoding, and a copy does neither.
@@ -913,11 +921,11 @@ export function wireOutputs({
     host: () => ({
       benchmark: parts.softwarePresetBenchmark,
       decodeModel: parts.decodeCostModel,
-      contentionPenalties: parts.contentionPenalties,
+      contentionPenalties: parts.processor.penalties,
       copySpeedX: parts.copySpeedX,
       audioCalibration,
       audioDescriptionOf,
-      availability: parts.hostLoad.hostAvailability,
+      availability: parts.processor.availability() ?? undefined,
       // WHICH encoder this host settled on. Only the software ladder is
       // benchmarked, so a reading taken off a hardware encoder cannot be
       // split into its decode and encode halves and is not filed as one.
@@ -957,7 +965,7 @@ export function wireOutputs({
     encodeCost: parts.encodeCost,
     occupiedCostSec: (fileKey) => parts.admission?.occupiedCost({ exceptFileKey: fileKey }).costSec ?? 0,
     occupancyKnownFor: (fileKey) => (parts.admission?.occupiedCost({ exceptFileKey: fileKey }).unpriced ?? 0) === 0,
-    availability: () => parts.hostLoad.hostAvailability ?? null,
+    availability: () => parts.processor.availability(),
     outputs: parts.outputs,
     stateFor: (session) => parts.encodeRuns.runStateOf(session),
     // WHICH HEIGHTS A LIVE VIEWER HAS ON SCREEN, as numbers. Who is watching
@@ -1051,7 +1059,7 @@ export function wireOutputs({
     finished: (address) => parts.outputs.outputsOn(address).some((session) => finishedOutput(session)),
     loadOf: (address) => parts.encodeCost.loadOfOutput(address),
     loadForCandidate: (spec, file) => parts.encodeCost.loadForCandidate(spec, file),
-    availability: () => parts.hostLoad.hostAvailability ?? null
+    availability: () => parts.processor.availability()
   });
   parts.encodeOrchestrator = new EncodeOrchestrator({
     inputDemandChanged: (address, windows) => {
@@ -1067,7 +1075,7 @@ export function wireOutputs({
     maxRunsFor: (address) => parts.encodeRuns.maxRunsForOutput(address),
     makeRun: ({ address, from, to, because }) => parts.encodeRuns.makeRunAt(address, from, to, because),
     segmentSeconds: parts.segmentDurationSec,
-    contentionPenalties: parts.contentionPenalties,
+    contentionPenalties: parts.processor.penalties,
     startingSpeedFor: (address) => parts.encodeCost.speedForOutput(address),
     segmentCoverage,
     // HOW IT ASKS TO DECIDE AGAIN. A plan that refuses to place anything
@@ -1106,7 +1114,6 @@ export function wireOutputs({
     readRanges: readEncodeRanges,
     heldRanges: readEncodeHeldRanges,
     stretchCopied,
-    stretchBytes: inputStretchBytes,
     reviseBudget: () => parts.machineBudget.revise("memory", "admitted encode inputs"),
     capacity: () => parts.machineBudget.capacityOf("memory"),
     // How long this output's input takes to open, from the one owner of start
@@ -1130,9 +1137,6 @@ export function wireOutputs({
       parts.serving.invalidateWaits(output);
     }
   }) : null);
-  if (parts.encodeInputs && inputStretchBytes) {
-    logger.info(`encode input: every original-input stretch sized to ${inputStretchBytes} bytes (--input-stretch-bytes)`);
-  }
   // One owner of the disk, and the list of what takes it lives with the owner.
   parts.machineBudget = wireMachineBudget({
     segmentStore: parts.segmentStore,

package/services/viewer/playback-readiness.js

@@ -143,8 +143,20 @@ export function predictPlaybackReadiness(input = {}) {
   // Kept are the pieces still to play, the first piece (where the track
   // starts), the read piece nearest before them (what an unread piece is placed
   // by) and read pieces inside what the page reports holding (their frames).
+  //
+  // THE NEAR WINDOW AND THE TAIL (torrent-tv/meta#185). Pieces starting within
+  // the proxy's look-ahead of the viewer are placed in exact time, where whether
+  // the media is continuous is decided, and their bytes are those the torrent
+  // thread plans arrivals for. The pieces after it are scheduled by the same
+  // rules in seconds, by {@link scheduleTail}: no exact time and no planned
+  // arrival exists for them. Placing every remaining piece of a two-hour film
+  // in exact time on every poll cost 70-1128 ms a call on Home Assistant (r73,
+  // r74).
+  const lookahead = finiteNonNegative(input.lookaheadSeconds);
+  const horizonEnd = lookahead > 0 ? finiteNonNegative(input.positionSeconds) + lookahead : Number.POSITIVE_INFINITY;
   const tracks = (Array.isArray(input.tracks) ? input.tracks : []).map((track) =>
-    Array.isArray(track.segments) ? { ...track, segments: piecesThatMatter(track, finiteNonNegative(input.positionSeconds)) } : track);
+    Array.isArray(track.segments) ? { ...track,
+      segments: piecesThatMatter(track, finiteNonNegative(input.positionSeconds), horizonEnd) } : track);
   const duration = finiteNonNegative(input.durationSeconds);
   // Each track's served ticks are placed on the clock the page reports by the
   // offset its player applied (`timestampOffset`).
@@ -212,11 +224,20 @@ export function predictPlaybackReadiness(input = {}) {
     bitsPerMediaSecond: averageBitsPerMediaSecond(track, track.segments,
       new Set(Array.isArray(track.readySegmentIndices) ? track.readySegmentIndices : [])),
     segments: segmentsOf[trackIndex]
-      .filter((segment) => Number.isInteger(segment?.index) &&
-        Number.isFinite(segment?.startSeconds) && Number.isFinite(segment?.endSeconds) &&
-        segment.endSeconds > segment.startSeconds && segment.endSeconds > position)
-      .sort((left, right) => left.startSeconds - right.startSeconds || left.index - right.index)
+      .filter((segment) => isPiece(segment) && segment.endSeconds > position && segment.startSeconds < horizonEnd)
+      .sort((left, right) => left.startSeconds - right.startSeconds || left.index - right.index),
+    // The pieces after the near window, as the playlist cuts them, and the
+    // offset the page's player placed them by.
+    tail: horizonEnd === Number.POSITIVE_INFINITY ? [] :
+      (Array.isArray(input.tracks[trackIndex].segments) ? input.tracks[trackIndex].segments : [])
+        .filter((segment) => isPiece(segment) && segment.startSeconds >= horizonEnd && segment.endSeconds > position)
+        .sort((left, right) => left.startSeconds - right.startSeconds || left.index - right.index),
+    clockSeconds: Number.isFinite(track.clockOffsetSeconds) ? track.clockOffsetSeconds : 0
   }));
+  for (const state of trackState) {
+    state.tailEndSeconds = state.tail.length > 0
+      ? Math.min(duration, state.tail.at(-1).endSeconds + state.clockSeconds) : null;
+  }
   if (trackState.some(({ segments }) => segments.length === 0)) {
     return result(false, null, buffered, reserve, null, "timeline-unavailable", 0);
   }
@@ -241,8 +262,9 @@ export function predictPlaybackReadiness(input = {}) {
     return result(false, null, buffered, reserve, null, "link-rate-unavailable", 0);
   }
 
-  const preparedSegments = trackState.reduce((sum, { ready, segments }) =>
-    sum + segments.filter((segment) => ready.has(segment.index)).length, 0);
+  const preparedSegments = trackState.reduce((sum, { ready, segments, tail }) =>
+    sum + segments.filter((segment) => ready.has(segment.index)).length +
+    tail.filter((segment) => ready.has(segment.index)).length, 0);
   const jobs = [];
 
   for (let trackIndex = 0; trackIndex < trackState.length; trackIndex += 1) {
@@ -497,12 +519,22 @@ export function predictPlaybackReadiness(input = {}) {
       for (const range of production.segment.ranges) addMediaRange(prepared, range);
       // Supply interruption coverage is stock held by the proxy as well as
       // the browser. It is not a browser buffer-size admission rule.
-      const ahead = Math.max(0, secondsAhead(before, at) -
-        Math.min(reserve, secondsAhead(trackEnd, before)) * Number(production.requiresSource));
+      // The reserve is bounded by what is left of the track, not of the window.
+      const left = state.tailEndSeconds === null ? secondsAhead(trackEnd, before)
+        : Math.max(0, state.tailEndSeconds - toSeconds(before));
+      const ahead = Math.max(0, secondsAhead(before, at) - Math.min(reserve, left) * Number(production.requiresSource));
       constrain(production.at - ahead, "production", trackIndex, production.segment.index, production.at, ahead,
         production.requiresSource);
     }
   }
+  if (trackState.some(({ tail }) => tail.length > 0)) {
+    const stop = scheduleTail({ trackState, sourceState, sourceByteCoverage, sourceArrivals, runStarts, trackFinish,
+      link, position, reserve, transferFinish, constrain });
+    if (stop) {
+      return { ...result(false, null, buffered, reserve, null, stop.reason, preparedSegments),
+        ...(stop.unavailableSource ? { unavailableSource: stop.unavailableSource } : {}) };
+    }
+  }
   const delay = Math.max(0, ...constraints);
   const originReady = trackState.every(({ clientRanges }) => compare(contiguousEnd(clientRanges, at), at) > 0);
   const ready = delay === 0 && originReady;
@@ -527,6 +559,183 @@ export function predictPlaybackReadiness(input = {}) {
 
 }
 
+/** A playlist piece with an index and a positive span in seconds. */
+function isPiece(segment) {
+  return Number.isInteger(segment?.index) && Number.isFinite(segment?.startSeconds) &&
+    Number.isFinite(segment?.endSeconds) && segment.endSeconds > segment.startSeconds;
+}
+
+/**
+ * The pieces after the near window, scheduled by the near window's rules in
+ * seconds and constrained as they are scheduled: their source bytes arrive in
+ * byte order at the source's measured service after the near window's bytes,
+ * a piece whose bytes come after its output's last run was admitted starts a
+ * run and pays the output's open, it is encoded at the output's measured rate
+ * and delivered over the one link in media order.
+ *
+ * Where a byte stands in that order is the bytes still missing before it,
+ * read off what is held, planned and brought by the near window
+ * ({@link missingBefore}); a piece is placed by the last range of it that
+ * misses bytes, so a range it reads that is already held — an AVI's index at
+ * the end of the file — does not place it at the end of the file. Planned and
+ * brought bytes come when they were to come. No exact time, list of arrivals
+ * or per-piece object is built: this runs over the rest of the film on every
+ * poll (torrent-tv/meta#185).
+ *
+ * @returns {{ reason: string, unavailableSource?: object } | null} Why there is no answer, or null.
+ */
+function scheduleTail({ trackState, sourceState, sourceByteCoverage, sourceArrivals, runStarts, trackFinish, link,
+  position, reserve, transferFinish, constrain }) {
+  // Per source: what is missing before a byte, and how far the tail has asked.
+  const supply = new Map();
+  const supplyOf = (sourceId) => {
+    let state = supply.get(sourceId);
+    if (!state) {
+      const coverage = sourceByteCoverage.get(sourceId) ?? [];
+      const heldBefore = [0];
+      for (const range of coverage) heldBefore.push(heldBefore.at(-1) + range.end - range.start);
+      state = { coverage, heldBefore, asked: null, orders: [], finishes: [] };
+      supply.set(sourceId, state);
+    }
+    return state;
+  };
+  const next = trackState.map(() => 0);
+  let delivered = transferFinish;
+  for (;;) {
+    // The next piece in media order across the tracks, as the near window orders them.
+    let trackIndex = -1;
+    for (let index = 0; index < trackState.length; index += 1) {
+      const candidate = trackState[index].tail[next[index]];
+      if (!candidate) continue;
+      const best = trackIndex < 0 ? null : trackState[trackIndex].tail[next[trackIndex]];
+      if (!best || candidate.startSeconds < best.startSeconds ||
+        (candidate.startSeconds === best.startSeconds && candidate.endSeconds < best.endSeconds)) trackIndex = index;
+    }
+    if (trackIndex < 0) return null;
+    const state = trackState[trackIndex];
+    const { track } = state;
+    const segment = state.tail[next[trackIndex]++];
+    const startsAt = segment.startSeconds + state.clockSeconds;
+    const endsAt = segment.endSeconds + state.clockSeconds;
+    // Media the page already holds is not transferred again.
+    if (Array.isArray(track.clientRanges) && track.clientRanges.some((range) =>
+      range?.start <= Math.max(startsAt, position) && range?.end >= endsAt)) continue;
+    const exactBytes = sizeOf(track.segmentSizesBytes, segment.index);
+    const sizeBits = exactBytes > 0 ? exactBytes * 8 : state.bitsPerMediaSecond * (segment.endSeconds - segment.startSeconds);
+    if (!(sizeBits > 0)) return { reason: "segment-size-unavailable" };
+    const produced = state.ready.has(segment.index);
+    let work = 0;
+    if (!produced) {
+      work = segment.endSeconds - segment.startSeconds;
+      for (const range of Array.isArray(track.processingRanges) ? track.processingRanges : []) {
+        if (Number.isFinite(range?.start) && Number.isFinite(range?.end)) {
+          work -= Math.max(0, Math.min(range.end, segment.endSeconds) - Math.max(range.start, segment.startSeconds));
+        }
+      }
+      work = Math.max(0, work);
+    }
+    let sourceArrivalAt = 0;
+    if (work > 0) {
+      if (!state.curve) return { reason: "encode-rate-unavailable" };
+      const trackSources = Array.isArray(track.sourceIds) ? track.sourceIds : [];
+      const exactInputs = Array.isArray(segment.sourceInputs) ? segment.sourceInputs : null;
+      const count = trackSources.length + (exactInputs?.length ?? 0);
+      for (let place = 0; place < count; place += 1) {
+        const sourceId = place < trackSources.length ? trackSources[place]
+          : exactInputs[place - trackSources.length]?.sourceId;
+        if (namedBefore(sourceId, place, trackSources, exactInputs)) continue;
+        const source = sourceState.get(sourceId);
+        if (!source) return { reason: "source-measurement-unavailable" };
+        if (source.source.complete === true) continue;
+        const ranges = exactInputs ? inputRangesOf(exactInputs, sourceId) : null;
+        if (ranges === null) return { reason: "source-input-ranges-unavailable" };
+        const bytes = supplyOf(sourceId);
+        let order = 0;
+        for (const range of ranges) {
+          // Bytes the torrent thread planned, or the near window brought, come when they were to come.
+          sourceArrivalAt = Math.max(sourceArrivalAt, latestArrival(range, sourceArrivals.get(sourceId)));
+          const after = missingBefore(bytes, range.end);
+          if (after > missingBefore(bytes, range.start)) order = Math.max(order, after);
+        }
+        if (order === 0) continue;
+        const { service } = source;
+        if (!service.rate || !(service.rate.rateAt(0) > 0)) {
+          return { reason: service.rate ? "service-not-advancing" : "download-rate-unavailable",
+            unavailableSource: { sourceId, segmentIndex: segment.index, missingBytes: order - (bytes.asked ?? 0) } };
+        }
+        // The tail's first asked byte is where this source's tail begins:
+        // bytes missing before it are not this film's to wait for.
+        bytes.asked ??= Math.max(0, order - missingWithin(bytes, ranges));
+        let arrival;
+        if (order > bytes.asked) {
+          service.finish = service.rate.finish(order - bytes.asked, service.finish);
+          bytes.asked = order;
+          bytes.orders.push(order);
+          bytes.finishes.push(service.finish);
+          arrival = service.finish;
+        } else {
+          // Brought by an earlier piece's ask: when that ask reached it.
+          let low = 0, high = bytes.orders.length - 1;
+          while (low < high) {
+            const middle = (low + high) >>> 1;
+            if (bytes.orders[middle] < order) low = middle + 1;
+            else high = middle;
+          }
+          arrival = bytes.finishes[low] ?? service.finish;
+        }
+        sourceArrivalAt = Math.max(sourceArrivalAt, arrival);
+      }
+    }
+    let admittedAt = Math.max(trackFinish[trackIndex], sourceArrivalAt);
+    if (work > 0) {
+      const run = runStarts[trackIndex];
+      const live = run.spans.some(span => segment.startSeconds >= span.start && segment.startSeconds < span.end);
+      if (!live && (run.admittedAt === null || sourceArrivalAt > run.admittedAt)) {
+        run.admittedAt = admittedAt;
+        admittedAt += run.openSeconds;
+      }
+    }
+    const producedAt = work > 0 ? state.curve.finish(work, admittedAt) : 0;
+    trackFinish[trackIndex] = Math.max(trackFinish[trackIndex], producedAt);
+    delivered = link.finish(sizeBits, Math.max(delivered, producedAt));
+    const completedAt = delivered + finiteNonNegative(track.appendSeconds);
+    // The media before a piece is what the playlist puts before it: whether a
+    // hole stops the media is decided in the near window, in exact time.
+    const ahead = Math.max(0, startsAt - position);
+    const requiresSource = sourceArrivalAt > 0;
+    constrain(completedAt - ahead, "delivery", trackIndex, segment.index, completedAt, ahead, false);
+    const covered = Math.max(0, ahead - Math.min(reserve, Math.max(0, state.tailEndSeconds - startsAt)) *
+      Number(requiresSource));
+    constrain(producedAt - covered, "production", trackIndex, segment.index, producedAt, covered, requiresSource);
+  }
+}
+
+/**
+ * The bytes not held, and not brought by the near window, before `byte` of a
+ * source: `byte` less what the sorted coverage holds below it.
+ *
+ * @param {{ coverage: Array<{ start: number, end: number }>, heldBefore: number[] }} bytes
+ * @param {number} byte
+ */
+function missingBefore(bytes, byte) {
+  const { coverage, heldBefore } = bytes;
+  let low = 0, high = coverage.length;
+  while (low < high) {
+    const middle = (low + high) >>> 1;
+    if (coverage[middle].end <= byte) low = middle + 1;
+    else high = middle;
+  }
+  const inside = low < coverage.length && coverage[low].start < byte ? byte - coverage[low].start : 0;
+  return byte - heldBefore[low] - inside;
+}
+
+/** The missing bytes of a piece's ranges of one source. */
+function missingWithin(bytes, ranges) {
+  let missing = 0;
+  for (const range of ranges) missing += missingBefore(bytes, range.end) - missingBefore(bytes, range.start);
+  return missing;
+}
+
 /**
  * Seconds from `from` to `to`, or zero when `to` is not later.
  *
@@ -628,21 +837,24 @@ function heldRanges(ranges, segments, unit, position) {
 }
 
 /**
- * The pieces of a track this forecast reads: those still to play (ending after
- * `position`), the first piece, every piece that has been read and every piece
- * that is made. A piece that is none of these changes no answer: it is not
- * scheduled, it is not where the track starts, no unread piece is placed by it
- * (only read pieces are), it lends no frame to what the page holds, and it has
- * no size to measure the output's rate by.
+ * The pieces of a track this forecast places in exact time: those still to
+ * play (ending after `position`) that start before `horizonEnd`, the first
+ * piece, every piece that has been read and every piece that is made. A piece
+ * that is none of these changes no exact answer: after the near window it is
+ * scheduled in seconds, it is not where the track starts, no unread piece is
+ * placed by it (only read pieces are), it lends no frame to what the page
+ * holds, and it has no size to measure the output's rate by.
  *
  * @param {{ segments: object[], readySegmentIndices?: number[] }} track
  * @param {number} position - Seconds.
+ * @param {number} [horizonEnd] - Seconds: where the near window ends.
  * @returns {object[]}
  */
-function piecesThatMatter(track, position) {
+function piecesThatMatter(track, position, horizonEnd = Number.POSITIVE_INFINITY) {
   const made = new Set(Array.isArray(track.readySegmentIndices) ? track.readySegmentIndices : []);
   const kept = track.segments.filter((segment) => segment?.index === 0 || segment?.mediaRanges !== undefined ||
-    made.has(segment?.index) || !(Number.isFinite(segment?.endSeconds) && segment.endSeconds <= position));
+    made.has(segment?.index) || (!(Number.isFinite(segment?.endSeconds) && segment.endSeconds <= position) &&
+      !(Number.isFinite(segment?.startSeconds) && segment.startSeconds >= horizonEnd)));
   return kept.length === track.segments.length ? track.segments : kept;
 }