@torrent-tv/proxy 2.80.4 → 2.80.6

package/services/hwaccel.js

@@ -21,7 +21,7 @@
  */
 
 import { spawn } from "node:child_process";
-import { mkdtempSync, readdirSync, rmSync, statSync } from "node:fs";
+import { mkdtempSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { mkdtemp, readFile, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -35,25 +35,25 @@ import {
   parseFfmpegVideoFps
 } from "./ffmpeg-banner.js";
 
-import { keyFrameArgs, SOFTWARE_CRF, TRANSCODE_FPS } from "./encode/args.js";
-// The five kinds, one class each. Detection and benchmarking stay in this file;
-// how a kind is driven belongs to the kind.
-import {
-  NvencEncoder,
-  QsvEncoder,
-  SoftwareEncoder,
-  V4l2m2mEncoder,
-  VaapiEncoder
-} from "./encode/index.js";
-// Re-exported so every caller goes on importing these figures from here:
-// the same calculation, moved to sit beside the encoder kinds built from it.
-export {
-  chooseOutputFps,
-  maxrateKbpsFor,
-  nominalKbpsForHeight,
-  nominalKbpsForMaxrate,
-  TRANSCODE_FPS
-} from "./encode/args.js";
+import { keyFrameArgs, SOFTWARE_CRF, TRANSCODE_FPS } from "./encode/args.js";
+// The five kinds, one class each. Detection and benchmarking stay in this file;
+// how a kind is driven belongs to the kind.
+import {
+  NvencEncoder,
+  QsvEncoder,
+  SoftwareEncoder,
+  V4l2m2mEncoder,
+  VaapiEncoder
+} from "./encode/index.js";
+// Re-exported so every caller goes on importing these figures from here:
+// the same calculation, moved to sit beside the encoder kinds built from it.
+export {
+  chooseOutputFps,
+  maxrateKbpsFor,
+  nominalKbpsForHeight,
+  nominalKbpsForMaxrate,
+  TRANSCODE_FPS
+} from "./encode/args.js";
 
 // libx264 presets to benchmark, ordered slowest/highest-quality → fastest.
 const BENCHMARK_PRESETS = ["fast", "faster", "veryfast", "superfast", "ultrafast"];
@@ -78,6 +78,15 @@ const ENCODE_BENCHMARK_MAX_PLAUSIBLE_SPEED = 1000;
  * arrive twice a second whatever the encoding speed.
  */
 const ENCODE_BENCHMARK_TIMEOUT_MS = 10_000;
+/**
+ * How many times the calibration clip is joined to itself to measure copying.
+ *
+ * Not a figure about the machine: it is how much film the reading needs to have
+ * in front of it. A copy runs at hundreds of times realtime, and the slope is
+ * taken over a window of one second, so the input has to hold more film than the
+ * fastest plausible host gets through in that second. Forty laps of a five-second
+ * clip is 200 s of film, which covers the ceiling `slopeOf` will accept.
+ */
 /** Progress reports arrive line by line. */
 const NEWLINE = String.fromCharCode(10);
 // Producing one second of video per second of clock. Not a margin and not a
@@ -94,40 +103,40 @@ const REALTIME = 1;
 const UNPRICED_DECODE_BAR = 1.8;
 
 
-// The five kinds live in `encode/`, one class each, and these keep the names
-// every caller already uses. A kind states its own arguments and its own
-// ladder of speed settings; detection and benchmarking stay here.
-/** @returns {import("./hwaccel.js").VideoEncoderDescriptor} */
-export function softwareDescriptor() {
-  return new SoftwareEncoder();
-}
-
-/**
- * @param {string} device
- * @returns {import("./hwaccel.js").VideoEncoderDescriptor}
- */
-function vaapiDescriptor(device) {
-  return new VaapiEncoder(device);
-}
-
-/**
- * @param {string} device
- * @returns {import("./hwaccel.js").VideoEncoderDescriptor}
- */
-function qsvDescriptor(device) {
-  return new QsvEncoder(device);
-}
-
-/** @returns {import("./hwaccel.js").VideoEncoderDescriptor} */
-function nvencDescriptor() {
-  return new NvencEncoder();
-}
-
-/** @returns {import("./hwaccel.js").VideoEncoderDescriptor} */
-function v4l2m2mDescriptor() {
-  return new V4l2m2mEncoder();
-}
-
+// The five kinds live in `encode/`, one class each, and these keep the names
+// every caller already uses. A kind states its own arguments and its own
+// ladder of speed settings; detection and benchmarking stay here.
+/** @returns {import("./hwaccel.js").VideoEncoderDescriptor} */
+export function softwareDescriptor() {
+  return new SoftwareEncoder();
+}
+
+/**
+ * @param {string} device
+ * @returns {import("./hwaccel.js").VideoEncoderDescriptor}
+ */
+function vaapiDescriptor(device) {
+  return new VaapiEncoder(device);
+}
+
+/**
+ * @param {string} device
+ * @returns {import("./hwaccel.js").VideoEncoderDescriptor}
+ */
+function qsvDescriptor(device) {
+  return new QsvEncoder(device);
+}
+
+/** @returns {import("./hwaccel.js").VideoEncoderDescriptor} */
+function nvencDescriptor() {
+  return new NvencEncoder();
+}
+
+/** @returns {import("./hwaccel.js").VideoEncoderDescriptor} */
+function v4l2m2mDescriptor() {
+  return new V4l2m2mEncoder();
+}
+
 
 
 /**
@@ -1713,3 +1722,122 @@ export function chooseSoftwareEncodeSettings(benchmark, ceiling, outputFps, cost
   const preset = pickSoftwarePreset(benchmark, chosen.width * chosen.height * fps, cost);
   return { width: chosen.width, height: chosen.height, preset, ladder, rungIndex: chosenIndex };
 }
+
+/**
+ * How fast this machine COPIES a picture, in seconds of film per second.
+ *
+ * The startup measurements price encoding and decoding, and a copied picture
+ * does neither: it reads packets and writes them out again. That left one whole
+ * branch of what this proxy does with no figure at all, and a figure is what
+ * every decision in the encoding layer is made from — where to put an encoder,
+ * how many to run, whether anybody will be left waiting. Without it a copied
+ * output was planned with no speed until its own run had been running long
+ * enough to report one, which is exactly the moment the plan matters most.
+ *
+ * Measured the same way as the others: ffmpeg's own progress, read as a slope
+ * over a window, so the process starting is outside the figure.
+ *
+ * The clip is joined to itself first rather than looped with `-stream_loop`.
+ * Looping charges a re-initialisation per lap — measured on the addon host at
+ * 0.03 s for 480p and 0.12 s for 1080p — and a copy of a five-second clip laps
+ * many times a second, so the reading would have been mostly re-initialisation.
+ *
+ * @param {{ ffmpegBin: string, logger?: { info: (m: string) => void, warn: (m: string) => void }, clipsDir?: string }} params
+ * @returns {Promise<number | null>} Seconds of film per second, or null where
+ *   the reading could not be taken. Null means unmeasured and is never a
+ *   substitute for a number.
+ */
+export async function benchmarkCopySpeed({ ffmpegBin, logger, clipsDir = CALIBRATION_DIR }) {
+  const log = logger ?? { info: () => {}, warn: () => {} };
+  const startedAt = Date.now();
+  // The largest clip in the set. A copy moves BYTES, so what it can do is a
+  // statement about the biggest pictures this host will be asked to pass
+  // through, and the small ones are covered by the same figure.
+  const clip = path.join(clipsDir, "cal-h264-1080-hi.mp4");
+  const speed = await measureCopySlope(ffmpegBin, clip);
+  if (!(speed > 0)) {
+    log.warn("hwaccel: copying could not be measured; a copied picture will be planned from its own run instead");
+    return null;
+  }
+  log.info(
+    `hwaccel: this host copies a picture at ${speed.toFixed(0)}x realtime ` +
+    `(measured in ${((Date.now() - startedAt) / 1000).toFixed(1)}s)`
+  );
+  return speed;
+}
+
+/**
+ * Seconds of film per second, copying one file, read from ffmpeg's progress.
+ *
+ * @param {string} ffmpegBin
+ * @param {string} filePath
+ * @returns {Promise<number | null>}
+ */
+function measureCopySlope(ffmpegBin, filePath) {
+  return new Promise((resolve) => {
+    const args = [
+      "-hide_banner", "-loglevel", "error", "-nostats",
+      // Played over and over, because a copy gets through a five-second clip in
+      // milliseconds and a slope needs a window to be taken over. Looping
+      // charges the demuxer being re-opened once a lap, so what comes out is a
+      // FLOOR on what this host can copy — the safe direction, since a plan made
+      // from it expects copying to be slower than it is.
+      "-stream_loop", "-1", "-i", filePath,
+      // What a copied output does: packets in, packets out, nothing decoded and
+      // nothing encoded. Written nowhere, so the figure is this machine's own
+      // handling and not the disk under a temp directory.
+      "-c", "copy", "-f", "null", "-",
+      // Progress is reported every half second by default, which over a window
+      // of one second is two readings. This asks for twenty.
+      "-stats_period", "0.05",
+      "-progress", "pipe:1"
+    ];
+    /** @type {Array<{ wallSec: number, outSec: number }>} */
+    const samples = [];
+    let settled = false;
+    let buffered = "";
+    let child;
+    const startedAt = Date.now();
+    const finish = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      try {
+        child?.kill("SIGKILL");
+      } catch {
+        // already gone
+      }
+      resolve(value);
+    };
+    const timer = setTimeout(() => finish(null), ENCODE_BENCHMARK_TIMEOUT_MS);
+    try {
+      child = spawn(ffmpegBin, args, { stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
+    } catch {
+      finish(null);
+      return;
+    }
+    child.stdout.on("data", (chunk) => {
+      buffered += String(chunk);
+      let newline = buffered.indexOf(NEWLINE);
+      while (newline >= 0) {
+        const line = buffered.slice(0, newline).trim();
+        buffered = buffered.slice(newline + 1);
+        if (line.startsWith("out_time_ms=")) {
+          const outSec = Number(line.slice("out_time_ms=".length)) / 1e6;
+          if (Number.isFinite(outSec) && outSec >= 0) {
+            samples.push({ wallSec: (Date.now() - startedAt) / 1000, outSec });
+          }
+        }
+        newline = buffered.indexOf(NEWLINE);
+      }
+      const slope = slopeOf(samples);
+      if (slope !== null) {
+        finish(slope);
+      }
+    });
+    child.on("error", () => finish(null));
+    child.on("exit", () => finish(slopeOf(samples, ENCODE_BENCHMARK_MIN_WINDOW_SEC)));
+  });
+}

package/services/orchestrators/EncodeOrchestrator.js

@@ -27,9 +27,9 @@ import { CoverageMap } from "../encode/CoverageMap.js";
 import { firstUnmetWant, planEncoders } from "../encode/EncodePlan.js";
 import { endOfRun } from "../encode/EncodeRun.js";
 import { ENCODE_EXIT } from "../encode/encode-exit.js";
-import { mergeMaps } from "../priority/PriorityMap.js";
 import { affordableRuns } from "../encode/run-budget.js";
 import { RunCosts } from "../encode/run-costs.js";
+import { contentionPenalty } from "../contention.js";
 import { SegmentDemand } from "../encode/SegmentDemand.js";
 
 export class EncodeOrchestrator {
@@ -40,6 +40,9 @@ export class EncodeOrchestrator {
   #runs = new Map();
 
 
+  /** The fastest speed measured on one output, kept across restarts. @type {Map<string, number>} */
+  #lastSpeed = new Map();
+
   /** How runs have ended, by cause. @type {Map<string, number>} */
   #endings = new Map();
 
@@ -62,7 +65,12 @@ export class EncodeOrchestrator {
    *   for a stretch. What to read, what to map and how to cut belong to whoever
    *   knows the source.
    * @param {number} params.segmentSeconds
-   * @param {number} params.restartCostSec - Measured: 0.12 s on the addon host.
+   * @param {import("../contention.js").ContentionPenalties | null}
+   *   [params.contentionPenalties] - How much slower one encoder runs beside
+   *   others, MEASURED on this host at startup and keyed by how many others
+   *   there are. Null until something has measured it, and then the penalty is
+   *   1 — a number invented here would be the same mistake as an invented
+   *   encoding speed.
    * @param {{ info: (line: string) => void, warn: (line: string) => void }} params.logger
    * @param {() => number} [params.now]
    */
@@ -70,8 +78,9 @@ export class EncodeOrchestrator {
     maxRunsFor,
     makeRun,
     segmentSeconds,
-    restartCostSec,
+    contentionPenalties = null,
     refetchSecPerFilmSecond = () => 0,
+    startingSpeedFor = () => 0,
     segmentStore = null,
     logger,
     now
@@ -88,9 +97,16 @@ export class EncodeOrchestrator {
     // Injected, because the film's byte rate and the swarm's are measured
     // elsewhere and this class must not reach for them.
     this.refetchSecPerFilmSecond = refetchSecPerFilmSecond;
+    // Measured per host: what a second encoder costs the first. Unmeasured is 1,
+    // and then only the budget bounds how many there are.
+    this.contentionPenalties = contentionPenalties instanceof Map ? contentionPenalties : null;
+    // WHAT THIS HOST ENCODES AT BEFORE ANY RUN HAS REPORTED. The startup
+    // benchmark measures it — a real pipeline over real clips, before a viewer
+    // exists — so the plan is never asked to compare arrivals with no speed to
+    // compute them from. Every run that then works refines it.
+    this.startingSpeedFor = startingSpeedFor;
     this.makeRun = makeRun;
     this.segmentSeconds = segmentSeconds;
-    this.restartCostSec = restartCostSec;
     this.logger = logger;
     this.now = typeof now === "function" ? now : Date.now;
   }
@@ -154,17 +170,27 @@ export class EncodeOrchestrator {
    *   takes them in this order. Absent means one undifferentiated want, which
    *   is what a caller that knows only a position states.
    */
-  want({ claimant, address, from, to, priority = 0 }) {
-    this.demand.state({ claimant, address, from, to, priority, statedAt: this.now() });
-  }
-
   /**
-   * A viewer has gone.
+   * What is wanted of one output, in its own segment numbers.
+   *
+   * ONE MAP, ALREADY MERGED, AND WITH NOBODY'S NAME ON IT. It is built once per
+   * film by the layer that knows where the viewers are; this layer receives it
+   * converted into an output's own numbering and never asks who is in it.
+   *
+   * That replaced a window per viewer per band stated here and merged here,
+   * which was the same work done twice in two layers, with the viewer's name as
+   * the key of a claim — against the rule that the encoding and the viewer are
+   * not connected at all.
+   *
+   * An empty map says nobody is coming anywhere in this output, and the plan
+   * stops its encoders for it. Nothing has to be released when somebody leaves:
+   * the map that arrives next simply does not have them in it.
    *
-   * @param {string} claimant
+   * @param {string} address
+   * @param {{ from: number, to: number, priority: number, withinSeconds: number }[]} zones
    */
-  release(claimant) {
-    this.demand.forget(claimant);
+  notePriorityMap(address, zones) {
+    this.demand.state(address, zones);
   }
 
   /**
@@ -191,6 +217,14 @@ export class EncodeOrchestrator {
         run.noteSpeed(speedX);
       }
     }
+    // HOW FAST THIS MACHINE ENCODES THIS OUTPUT is a property of the machine and
+    // the material, not of one process. Read off `run.speedX` alone it was lost
+    // at every restart: a moved encoder is a new object that has measured
+    // nothing, so the plan fell back to "nothing is known" and stopped comparing
+    // arrivals at all — which is every decision in this layer.
+    if (speedX > 0 && speedX > (this.#lastSpeed.get(address) ?? 0)) {
+      this.#lastSpeed.set(address, speedX);
+    }
   }
 
   /**
@@ -241,32 +275,20 @@ export class EncodeOrchestrator {
         });
       }
     }
-    // Carrying the priority through, because the filling takes the work in that
-    // order: what a viewer must have before they set off comes before what is
-    // merely in front of them, which comes before the rest of the track. Passed
-    // as a plain number so the plan stays arithmetic.
     // ONE MAP, NOT ONE WINDOW PER VIEWER PER ZONE.
     //
-    // Two viewers a few seconds apart state stretches that overlap, and the
-    // plan puts one encoder on each stretch it is given — so unmerged windows
-    // buy an encoder per viewer for film they both want, which is the opposite
-    // of what sharing the output is for. Merged, the highest number per segment
-    // wins and the stretches do not overlap, so one encoder serves everyone
-    // standing in front of it.
-    const windows = mergeMaps([
-      this.demand.windowsOn(address).map((window) => ({
-        from: window.from,
-        // Half-open on the way in and back again: these are whole segment
-        // numbers, and #10..#20 next to #21..#30 must not be read as touching
-        // at 20 and 21 at once.
-        to: window.to + 1,
-        // A window stated without a number is still a want — one
-        // undifferentiated want, which is what a caller that knows only a
-        // position states. Zero would read as "nothing wanted here" and the
-        // merge would drop it.
-        priority: Number(window.priority) || 1
-      }))
-    ]).map((zone) => ({ from: zone.from, to: zone.to - 1, priority: zone.priority }));
+    // Two viewers a few seconds apart state stretches that overlap, and the plan
+    // puts one encoder on each stretch it is given — so unmerged windows buy an
+    // encoder per viewer for film they both want, which is the opposite of what
+    // sharing the output is for. Merged, the highest rank and the soonest time
+    // per number win and the stretches do not overlap, so one encoder serves
+    // everyone standing in front of it.
+    //
+    // Asked of the register, which is the thing that holds the windows. This
+    // used to reach into the layer that STATES them for the same arithmetic,
+    // which is the coupling the layer rule forbids; the arithmetic itself now
+    // lives where it belongs to nobody.
+    const windows = this.demand.mapOn(address);
     const live = this.runsOn(address).filter((run) => run.isAlive);
     const actions = planEncoders({
       coverage,
@@ -277,15 +299,29 @@ export class EncodeOrchestrator {
       runs: live,
       maxRuns: this.#affordableOn(address, live),
       segmentSeconds: this.segmentSeconds,
-      restartCostSec: this.restartCostSec,
-      // Measured from this host's own runs, rather than written into the code
-      // from one machine's reading.
+      // What a start and a kill cost, measured from this host's own runs rather
+      // than written into the code from one machine's reading. Zero until
+      // something has been measured, which is the same convention as the
+      // refetch price below and is stated so the bias is known.
       ...this.#costs.seconds(),
       // What a second of film costs to fetch again, in seconds of swarm time.
       // Answered by whoever measures the film's own byte rate and the swarm's;
       // zero until they have, which makes driving through look cheaper than it
       // is and is stated here so the bias is known.
-      refetchSecPerFilmSecond: this.refetchSecPerFilmSecond(address)
+      refetchSecPerFilmSecond: this.refetchSecPerFilmSecond(address),
+      // How much slower one encoder runs beside others, read off this host's own
+      // startup measurement. A pure function over a measured table: beyond what
+      // was measured it holds the largest reading rather than continuing a curve
+      // nothing observed.
+      contentionPenaltyFor: (others) => contentionPenalty(others, this.contentionPenalties).penalty,
+      // The best figure this host has: what a run here is doing now, what one
+      // was last measured doing, or what the startup benchmark predicted. The
+      // first two are this output's own; the third exists before either.
+      speedX: Math.max(
+        live.reduce((best, run) => Math.max(best, run.speedX || 0), 0),
+        this.#lastSpeed.get(address) ?? 0,
+        this.startingSpeedFor(address) || 0
+      )
     });
 
     for (const action of actions) {
@@ -308,7 +344,22 @@ export class EncodeOrchestrator {
       }
       // A run that stays keeps its claim current: the free stretch ahead of it
       // may have shrunk since it was given one.
-      this.#claimFor(coverage, action.run, action.from, action.to);
+      //
+      // THE CLAIM IS THE STRETCH IT WAS GIVEN, and there is one rule for that
+      // everywhere. It used to be narrowed here to what the run had already
+      // MADE whenever the run had no end, which meant a run claimed the single
+      // number it was writing and nothing beyond. The plan then read the road
+      // in front of a working encoder as free and started more encoders on it:
+      // three processes writing one directory with the same names, field
+      // 2026-09-06, and a piece of the film lost for good when the first of
+      // them was cleaned up after.
+      //
+      // The worry that narrowing was written for is real and is answered where
+      // it belongs — a viewer opening the same film further in must not find
+      // every number taken. That is the plan's business, and the plan can take
+      // road away from a run that has no end, because such a run carries no
+      // `-to` and simply stops when its head meets somebody else's claim.
+      coverage.claim(action.run, action.from, endOfRun({ from: action.from, to: action.to }));
     }
   }
 
@@ -340,6 +391,14 @@ export class EncodeOrchestrator {
       this.logger.warn(`encode: no encoder could be made for #${from}..#${to} of ${address}`);
       return;
     }
+    // What this machine has been measured to do on this output, carried over.
+    // A restart does not make the machine slower, and without this every moved
+    // encoder began as one whose speed nothing had measured — which the plan
+    // reads as "no arrival can be computed" and answers by comparing nothing.
+    const known = this.#lastSpeed.get(address) ?? 0;
+    if (known > 0) {
+      run.noteSpeed(known);
+    }
     const onThisOutput = this.#runs.get(address) ?? [];
     onThisOutput.push(run);
     this.#runs.set(address, onThisOutput);
@@ -369,11 +428,24 @@ export class EncodeOrchestrator {
    */
   #affordableOn(address, live) {
     const byProcessor = Math.max(0, this.maxRunsFor(address));
-    const fastest = live.reduce((best, run) => Math.max(best, run.speedX || 0), 0);
+    // The best figure this host has: what a run here is doing now, what one was
+    // last measured doing, or what the startup benchmark predicted. The first
+    // two are this output's own; the third exists before either, so the budget
+    // is never asked to price encoders at a speed of zero.
+    const fastest = Math.max(
+      live.reduce((best, run) => Math.max(best, run.speedX || 0), 0),
+      this.#lastSpeed.get(address) ?? 0,
+      this.startingSpeedFor(address) || 0
+    );
     const budget = affordableRuns({
       byProcessor,
       speedX: fastest,
-      refetchSecPerFilmSecond: this.refetchSecPerFilmSecond(address)
+      refetchSecPerFilmSecond: this.refetchSecPerFilmSecond(address),
+      // How much slower one encoder runs beside others, read off this host's own
+      // startup measurement. A pure function over a measured table: beyond what
+      // was measured it holds the largest reading rather than continuing a curve
+      // nothing observed.
+      contentionPenaltyFor: (others) => contentionPenalty(others, this.contentionPenalties).penalty
     });
     if (budget.runs !== byProcessor && budget.because !== this.#lastBudgetReason.get(address)) {
       this.#lastBudgetReason.set(address, budget.because);
@@ -407,50 +479,7 @@ export class EncodeOrchestrator {
     }
     onThisOutput.push(run);
     this.#runs.set(address, onThisOutput);
-    this.#claimFor(this.coverageOf(address), run, run.from, run.to);
-  }
-
-  /**
-   * What a run holds, as far as the map is concerned.
-   *
-   * A run given an end holds exactly that stretch. A run given NO end — `to`
-   * below `from`, which is how this is written everywhere here — would hold the
-   * rest of the film, and that is what must not be claimed: a second viewer
-   * opening the same film further in would find every number taken and get no
-   * encoder at all, waiting instead for the first run to encode its way there,
-   * which on a long film is an hour.
-   *
-   * What bounds it in practice is the look-ahead: a run is suspended once it is
-   * that far in front of the segment its viewer last asked for, and past that it
-   * produces nothing until somebody asks. So that is the honest extent of the
-   * claim, and it is a measured figure rather than a chosen one — the same
-   * allowance the browser sizes its cushion from. `planRunInterval` has applied
-   * this rule since runs got intervals; this path did not, which is how an
-   * encoder came to be started and killed every five seconds in the field.
-   *
-   * @param {CoverageMap} coverage
-   * @param {object} run
-   * @param {number} from
-   * @param {number} to
-   */
-  #claimFor(coverage, run, from, to) {
-    const end = endOfRun({ from, to });
-    if (Number.isFinite(end)) {
-      coverage.claim(run, from, end);
-      return;
-    }
-    // A RUN WITH NO END HOLDS WHAT IT HAS MADE, NOT WHAT IT MIGHT MAKE.
-    //
-    // "No end" means the film's length is not known, so there is no last number
-    // to claim towards. Claiming the rest of the film would leave a viewer who
-    // opens the same film further in with every number taken and no encoder at
-    // all. Claiming a fixed distance in front of the head — which is what this
-    // did — needs a number nobody measured, and the number it used was the
-    // suspended-encoder threshold that no longer exists.
-    //
-    // What it has made is a fact, and it is the only one available here.
-    const head = Number.isFinite(run?.head) ? run.head : from;
-    coverage.claim(run, from, Math.max(from, head));
+    this.coverageOf(address).claim(run, run.from, endOfRun(run));
   }
 
   /**
@@ -474,13 +503,13 @@ export class EncodeOrchestrator {
     this.#costs.note(ended);
     // Exactly one ending is normal — the run reached the end of the stretch it
     // was given and closed its last file. Every other leaves a piece open, and
-    // that file's name is indistinguishable from a finished one's: on SIGTERM
-    // ffmpeg writes the open piece out and names it on the ready channel like
-    // any other, so it is a valid file holding less film than its name
-    // promises. The run says which one that was.
+    // that file looks finished however the run ended: stopped, ffmpeg writes it
+    // out and names it like any other; killed harder, it leaves the bytes it
+    // had. Either way it decodes and holds less film than its number promises.
+    // So what is kept is what the run PROVED it finished, and nothing beyond.
     if (ended.ending !== ENCODE_EXIT.COMPLETE && this.segmentStore) {
       void this.segmentStore
-        .discardOpenPieceOf(ended.address, { from: ended.from, to: ended.to }, null, ended.flushedName)
+        .discardOpenPieceOf(ended.address, { from: ended.from, to: ended.to }, null, ended.provenName)
         .catch(() => {});
     }
     this.coverageOf(ended.address).release(ended.run);
@@ -523,8 +552,8 @@ export class EncodeOrchestrator {
     const parts = [];
     for (const address of new Set([...this.demand.addresses(), ...this.#runs.keys()])) {
       const coverage = this.coverageOf(address);
-      const stated = this.demand.windowsOn(address);
-      const windows = stated.map((w) => ({ from: w.from, to: w.to }));
+      const stated = this.demand.mapOn(address);
+      const windows = stated.map((zone) => ({ from: zone.from, to: zone.to }));
       const waiting = firstUnmetWant(coverage, windows);
       const runs = this.runsOn(address)
         .map((run) => `#${run.head}..#${run.to}@${run.speedX.toFixed(1)}x`)