@torrent-tv/proxy 2.80.4 → 2.80.6

package/services/encode/EncodeRun.js

@@ -61,11 +61,10 @@ const MICROSECONDS_PER_SECOND = 1_000_000;
  * @property {number} livedMs
  * @property {boolean} normal - Whether this ending is the expected one.
  * @property {string} lastError - The last thing ffmpeg said on stderr.
- * @property {string | null} flushedName - The piece the encoder wrote out while
- *   it was shutting down, if it wrote one. It is closed and it is SHORT: it
- *   holds film only up to the instant the run was stopped, while its name
- *   promises the whole span the playlist gives that number. Null where the run
- *   was never told to stop.
+ * @property {string | null} provenName - The last piece this run named while it
+ *   was still running normally, and therefore the last one it is known to have
+ *   finished. Anything on disk beyond it was open when the run ended, whatever
+ *   ended it. Null where the run named nothing.
  */
 
 /**
@@ -105,24 +104,27 @@ export class EncodeRun {
   #closedTail = "";
 
   /**
-   * The last piece named on the ready channel AFTER the run was told to stop.
+   * The last piece named on the ready channel while the run was still running
+   * normally — the last one it is KNOWN to have finished.
    *
-   * On SIGTERM ffmpeg writes out the piece it had open and names it like any
-   * other, so "the encoder closed it" stops meaning "it is whole". Field
-   * 2026-09-06: a run stopped mid-piece left `segment-00010.mp4` holding 3.92 s
-   * of the 5.589 s its name promises, and the viewer's picture jumped 1.5 s at
-   * 1:02. The soundtrack did the same at 17.5 s, 2.8 s wide, in the same
-   * session.
+   * "The encoder named it" was taken to mean "it is whole". That is true of the
+   * file and false of the span. On SIGTERM ffmpeg writes out the piece it had
+   * open and names it like any other; killed harder, or dying on its own, it
+   * leaves that piece unnamed and half-written. Both are readable, and neither
+   * covers the span its number promises. Field 2026-09-06: a run stopped
+   * mid-piece left `segment-00010.mp4` holding 3.92 s of the 5.589 s the
+   * playlist gives #10, and the viewer's picture jumped 1.5 s at 1:02; the
+   * soundtrack did the same at 17.5 s, 2.8 s wide, in the same session.
    *
-   * Distinguished by WHEN the name arrives, which is exact and needs no reading
-   * of the file: a name that arrives after the stop was ordered is the flush.
-   * A piece genuinely closed a moment before the stop can land here too, and
-   * then it is made a second time — the cheaper of the two errors, since the
-   * other one is a hole the viewer sees.
+   * Recorded by WHEN the name arrives, so nothing is read and no span is
+   * measured: a name that arrives after the stop was ordered is the flush and
+   * does not count as proof. A piece genuinely closed in the moment between the
+   * last normal name and the stop is then made a second time — the cheaper of
+   * the two errors, since the other is a hole the viewer sees.
    *
    * @type {string | null}
    */
-  #flushedName = null;
+  #provenName = null;
 
   /**
    * When this run was told to stop, so the death itself can be priced.
@@ -197,6 +199,10 @@ export class EncodeRun {
    *   kept so a failure can quote what produced it.
    * @param {boolean} [params.usesExplicitCuts] - Whether this run cuts at times
    *   it was given, which decides how a segment is judged finished.
+   * @param {(name: string) => number | null} [params.indexOfName] - The number
+   *   a closed piece's name carries. How a piece is named belongs to the format
+   *   that writes it, so it arrives as a plain function rather than this class
+   *   knowing any naming.
    */
   constructor({
     address,
@@ -213,7 +219,8 @@ export class EncodeRun {
     lastSegmentIndex,
     inputUnavailable,
     argsDescribed = "",
-    usesExplicitCuts = false
+    usesExplicitCuts = false,
+    indexOfName
   }) {
     this.address = address;
     this.encoder = encoder;
@@ -232,6 +239,7 @@ export class EncodeRun {
     this.inputUnavailable = typeof inputUnavailable === "function" ? inputUnavailable : () => false;
     this.argsDescribed = argsDescribed;
     this.usesExplicitCuts = usesExplicitCuts === true;
+    this.indexOfName = typeof indexOfName === "function" ? indexOfName : () => null;
     /** The last thing ffmpeg said on stderr, which is what a failure is explained by. */
     this.lastError = "";
   }
@@ -451,8 +459,20 @@ export class EncodeRun {
       if (name.length === 0) {
         continue;
       }
-      if (this.#stopping) {
-        this.#flushedName = name;
+      if (!this.#stopping) {
+        this.#provenName = name;
+      }
+      // WHAT THIS RUN HAS MADE IS THIS RUN'S OWN FACT, and this channel is where
+      // it learns it. It used to be told from outside, by whoever listed the
+      // output directory — which every run of an output shares — so a run
+      // inherited every number any other run had ever left there. Field
+      // 2026-09-06: a run beginning at the piece for 3:39 reported "reached #20
+      // (483 segment(s))", having produced none of them, and its head therefore
+      // described somebody else's work. Both the claim it holds and the cleanup
+      // after it read that head.
+      const index = this.indexOfName(name);
+      if (Number.isInteger(index)) {
+        this.noteProduced(index);
       }
       this.onClosed(name);
     }
@@ -643,7 +663,7 @@ export class EncodeRun {
       from: this.from,
       to: this.to,
       reached: this.reached,
-      flushedName: this.#flushedName,
+      provenName: this.#provenName,
       livedMs,
       // How long dying took, and how long the first output took to appear.
       // Null where the run was never told to stop, or never produced anything:

package/services/encode/SegmentStore.js

@@ -98,6 +98,10 @@ export class SegmentStore {
    */
   #closed = new Map();
 
+  /** Pieces already reported as taken on the successor rule, so one is said
+   * once. @type {Map<string, Set<number>>} */
+  #unreportedSaid = new Map();
+
   /** @type {{ info: Function, warn: Function }} */
   #logger;
 
@@ -308,7 +312,55 @@ export class SegmentStore {
     if (this.#closed.get(key)?.has(index)) {
       return true;
     }
-    return this.refresh(key).byNumber.has(index + 1);
+    const bySuccessor = this.refresh(key).byNumber.has(index + 1);
+    if (bySuccessor) {
+      this.#noteUnreported(key, index);
+    }
+    return bySuccessor;
+  }
+
+  /**
+   * A piece taken as finished because the NEXT one exists, with nothing from a
+   * run to say so.
+   *
+   * The successor rule is for what this process did not watch being written —
+   * pieces from a previous life of it. It is also the one way an unfinished
+   * piece can be served: a file that stops short still has a successor if
+   * anything wrote one, and then its name promises a whole span while it holds
+   * a fraction. Field 2026-09-06: 110 698 bytes served under a name whose
+   * neighbours are 12 MB, 40 ms of film where the playlist declared 10.4 s, and
+   * the player jumped the hole it left.
+   *
+   * That cannot arise from two encoders any more — their stretches no longer
+   * overlap — so what is left is a piece from a process that died without
+   * clearing up. Said once per piece, with its size, so a return of it is
+   * visible rather than inferred.
+   *
+   * @param {string} key
+   * @param {number} index
+   */
+  #noteUnreported(key, index) {
+    let said = this.#unreportedSaid.get(key);
+    if (!said) {
+      said = new Set();
+      this.#unreportedSaid.set(key, said);
+    }
+    if (said.has(index)) {
+      return;
+    }
+    said.add(index);
+    let bytes = -1;
+    try {
+      bytes = statSync(this.pathOf(key, index)).size;
+    } catch {
+      // Gone between the listing and this: nothing to report about it.
+      return;
+    }
+    this.#logger?.info?.(
+      `segment store: #${index} of ${key.slice(0, 60)} is taken as finished because ` +
+      `#${index + 1} exists — no run reported it (${bytes} bytes). Expected only for ` +
+      "pieces left by a previous life of this process."
+    );
   }
 
   /**
@@ -350,12 +402,12 @@ export class SegmentStore {
    * @param {((raw: Buffer) => boolean) | null} [judgeUsable]
    * @returns {Promise<number | null>} The segment number removed, or null.
    */
-  async discardOpenPieceOf(key, within, judgeUsable = null, flushedName = null) {
+  async discardOpenPieceOf(key, within, judgeUsable = null, provenName = null) {
     const format = this.#formats.get(key);
     if (!format) {
       return null;
     }
-    const removed = await discardOpenPiece(this.directoryFor(key), format, within, judgeUsable, flushedName);
+    const removed = await discardOpenPiece(this.directoryFor(key), format, within, judgeUsable, provenName);
     if (removed !== null) {
       this.#held.delete(key);
       this.#logger?.info?.(

package/services/encode/open-piece.js

@@ -23,37 +23,39 @@ import path from "node:path";
  * numbering and convinced the look-ahead to keep the encoder stopped for having
  * "produced" it.
  *
- * Two kinds of file are removed, and the second is the one a viewer feels.
+ * **A piece is whole only if the run PROVED it, and reading it proves nothing.**
  *
- * The first is unreadable — a run that died mid-write. The second READS
- * perfectly and is SHORT: on SIGTERM ffmpeg writes out the piece it had open
- * and names it on the ready channel like any other, so it is a valid fMP4
- * holding film only up to the instant of the stop, under a name that promises
- * the whole span the playlist gives that number. Field 2026-09-06:
+ * The highest-numbered file in a run's stretch is the one it had open. How a
+ * run ends decides what became of that file, and all three outcomes leave it
+ * readable-looking: stopped with SIGTERM, ffmpeg writes it out and names it on
+ * the ready channel exactly as it names a finished one; killed harder, or dying
+ * on its own, it leaves the bytes it had written with no name at all. In every
+ * case the file decodes and holds film only up to the instant the run ended,
+ * under a number whose playlist entry promises a whole span. Field 2026-09-06:
  * `segment-00010.mp4` held 3.92 s of its declared 5.589 s — 96 frames — and the
  * picture jumped 1.5 s at 1:02; the soundtrack did the same at 17.5 s, 2.8 s
- * wide, in the same session. Judging such a file by whether it decodes says
- * yes, which is how both survived.
+ * wide, in the same session. Both decoded, which is how both reached the viewer.
  *
- * Which file that is comes from the run itself — the last name it wrote after
- * being told to stop — and not from reading the pieces, so there is no span to
- * measure and no tolerance to choose.
+ * So the question asked here is not what the file contains but whether the run
+ * named it while it was still running normally. That is a fact the run holds,
+ * so there is no span to measure and no tolerance to choose.
  *
- * A piece that was genuinely finished a moment before the stop can be named
- * here too, and is then made a second time. That is the cheaper error: the
- * other one is a hole the viewer sees.
+ * A piece finished in the moment between the last such name and the end is
+ * then made a second time. That is the cheaper error: the other is a hole the
+ * viewer sees.
  *
  * @param {string | null | undefined} runDirPath
  * @param {{ isSegmentFileName: (name: string) => boolean, segmentIndexFromName: (name: string) => number }} segmentFormat
  * @param {((raw: Buffer) => boolean) | null} judgeUsable - Whether a non-empty
  *   piece carries what it should. Null where nothing can say, and then only an
  *   empty file is removed.
- * @param {string | null} [flushedName] - The piece the encoder wrote out while
- *   shutting down. Removed whether or not it reads, because reading is not the
- *   question about it.
+ * @param {string | null} [provenName] - The last piece the run named while it
+ *   was running normally. A file beyond it was open when the run ended and goes
+ *   whether or not it reads. Null where the run proved nothing, and then every
+ *   piece it left is unproven.
  * @returns {Promise<number | null>} The segment number removed, or null.
  */
-export async function discardOpenPiece(runDirPath, segmentFormat, within, judgeUsable, flushedName = null) {
+export async function discardOpenPiece(runDirPath, segmentFormat, within, judgeUsable, provenName = null) {
   if (!runDirPath || typeof segmentFormat?.isSegmentFileName !== "function") {
     return null;
   }
@@ -63,7 +65,28 @@ export async function discardOpenPiece(runDirPath, segmentFormat, within, judgeU
   // belong to a run that is still going, and removing it would take away a
   // piece somebody is producing.
   const from = Number.isInteger(within?.from) ? within.from : 0;
-  const to = Number.isInteger(within?.to) && within.to >= from ? within.to : Number.MAX_SAFE_INTEGER;
+  // THE RUN'S OWN REACH, which is a fact it holds and needs nothing measured.
+  //
+  // A run cannot have opened a file above the one just past the last it named:
+  // ffmpeg names a piece when it closes it and opens the next, so the open piece
+  // is at most `proven + 1`, and where it named nothing at all the open one is
+  // the first it was given.
+  //
+  // Used only where no end was declared — `to` below `from`, which is how "to
+  // the end of the track" is written everywhere here. Such a run had no bound at
+  // all: the search covered the whole directory and took the highest-numbered
+  // file in it. Every run of an output writes into that one
+  // directory, so what it took was a piece a LIVE run had just finished. Field
+  // 2026-09-06: the piece holding 2:47-2:57 went that way, its number is spent
+  // for good because names only grow, and the picture stood still for 647 s.
+  const provenIndex = typeof provenName === "string" && segmentFormat.isSegmentFileName(provenName)
+    ? segmentFormat.segmentIndexFromName(provenName)
+    : null;
+  const reach = Number.isInteger(provenIndex) && provenIndex >= from ? provenIndex + 1 : from;
+  // The declared end is the bound wherever there is one. The run's own reach is
+  // the bound of LAST RESORT, for a run given none: before it, such a run had no
+  // bound at all and the search covered the whole directory.
+  const to = Number.isInteger(within?.to) && within.to >= from ? within.to : reach;
   let highest = null;
   try {
     for (const name of await readdir(runDirPath)) {
@@ -85,11 +108,11 @@ export async function discardOpenPiece(runDirPath, segmentFormat, within, judgeU
     return null;
   }
   const filePath = path.join(runDirPath, highest.name);
-  // The encoder named this one on its way out, so it holds film up to the stop
-  // and no further. Nothing about its contents can say that — it decodes — so
-  // nothing about its contents is asked.
-  const wasFlushedOnTheWayOut = typeof flushedName === "string" && flushedName === highest.name;
-  let unusable = wasFlushedOnTheWayOut;
+  // Proven finished only if the run said so while it was running. Anything
+  // beyond that name was open when the run ended, and its contents cannot say
+  // so — it decodes.
+  const proven = typeof provenName === "string" && provenName === highest.name;
+  let unusable = !proven;
   try {
     const info = await stat(filePath);
     if (info.size === 0) {

package/services/encode/run-command.js

@@ -208,7 +208,17 @@ export function nearestKeyframeAtOrBefore(keyframeTimes, target) {
 export function seekLandingOffsetFor(material, keyframe) {
   // A re-encode trims to the requested time itself, so it needs no help and
   // must not be pushed past what it was asked for.
-  if (material?.transcodeVideo === true) {
+  //
+  // AN OUTPUT CARRYING ONLY SOUND IS SUCH A RE-ENCODE, and asking about the
+  // picture missed it: the flag says whether the PICTURE is re-encoded, and an
+  // output with no picture answers no. So the whole offset was added to the
+  // soundtrack's own seek, and the sound then played 130 ms ahead of the picture
+  // from every restart onward — reported by the viewer 2026-09-06 as lips out of
+  // step with the voice from two minutes in, and measured: both outputs were
+  // repositioned to the same boundary and both given `-ss 166.963435`, after
+  // which the copied picture landed on the keyframe at 166.833 while the
+  // re-encoded sound began where it was asked.
+  if (material?.transcodeVideo === true || material?.audioOnly === true) {
     return 0;
   }
   // A grid whose times are approximate needs that error added on top, or a name
@@ -504,7 +514,7 @@ export function buildRunCommand({
   if (snappedKeyframe !== null) {
     const residualSeconds = Math.max(0, seekSeconds - snappedKeyframe);
     if (snappedKeyframe > 0) {
-      args.push("-ss", ffmpegSeconds(snappedKeyframe + seekLandingOffsetFor({ transcodeVideo, file }, snappedKeyframe)));
+      args.push("-ss", ffmpegSeconds(snappedKeyframe + seekLandingOffsetFor({ audioOnly, transcodeVideo, file }, snappedKeyframe)));
     }
     args.push("-i", inputUrl);
     // The coarse landing, not the exact target: the residual below is discarded

package/services/hls-session-manager.js

@@ -23,7 +23,6 @@ import { speedFromReadings } from "./encoder-readings.js";
 import { availableShareFrom } from "./available-share.js";
 import { contentionPenalty } from "./contention.js";
 import { minimumBufferFrom } from "./supply-margin.js";
-import { mapForViewer } from "./priority/PriorityMap.js";
 import { PriorityOrchestrator } from "./priority/PriorityOrchestrator.js";
 import { baseDrawFrom, costPerMegabyteFrom } from "./torrent-cost.js";
 import { medianOf, movedBeyondScatter, scatterOf } from "./learned-median.js";
@@ -556,12 +555,6 @@ const SEGMENT_STORE_IDLE_MS = 6 * 60 * 60 * 1000;
 const SEGMENT_STORE_FREE_SHARE = 0.25;
 /** What the store may hold where the free space cannot be read at all. */
 const SEGMENT_STORE_FALLBACK_BYTES = 2 * 1024 * 1024 * 1024;
-/**
- * What it costs to stop an encoder and start another where the material is
- * missing. Measured on the addon host 2026-09-04: a spawn with its input open
- * is 0.12 s there, 0.5-0.6 s on a developer's desktop.
- */
-const RUN_RESTART_COST_SEC = 0.12;
 const DEFAULT_STARTUP_WAIT_MS = 5_000;
 // Realtime budget — runtime downswitch (software encoder only). Periodically
 // check each active software-transcode session's ffmpeg `speed`; when it stays
@@ -1475,6 +1468,7 @@ export class HlsSessionManager {
     // could not be measured, and then nothing is corrected — the alternative
     // is inventing a penalty, which is the same fault as inventing a fill rate.
     contentionPenalties = null,
+    copySpeedX = null,
     tonemapSupported = false,
     getCachedMediaInfo = null,
     getCachedAudioTracks = null,
@@ -1529,6 +1523,10 @@ export class HlsSessionManager {
     this.getSourceStats = typeof getSourceStats === "function" ? getSourceStats : null;
     this.setPriorityMap = typeof setPriorityMap === "function" ? setPriorityMap : null;
     this.contentionPenalties = contentionPenalties instanceof Map ? contentionPenalties : null;
+    // 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.
+    this.copySpeedX = Number.isFinite(copySpeedX) && copySpeedX > 0 ? copySpeedX : null;
     // Totals across every torrent this proxy holds, used to price what the
     // torrent itself costs the machine (item 7). Optional: a proxy wired
     // without it simply never learns that figure.
@@ -1612,6 +1610,7 @@ export class HlsSessionManager {
         benchmark: this.softwarePresetBenchmark,
         decodeModel: this.decodeCostModel,
         contentionPenalties: this.contentionPenalties,
+        copySpeedX: this.copySpeedX,
         availability: this.hostAvailability
       }),
       audioCostKey: (session) => this.#audioCostKey(session),
@@ -1638,7 +1637,8 @@ export class HlsSessionManager {
       maxRunsFor: (address) => this.maxRunsForOutput(address),
       makeRun: ({ address, from, to }) => this.#makeRunAt(address, from, to),
       segmentSeconds: this.segmentDurationSec,
-      restartCostSec: RUN_RESTART_COST_SEC,
+      contentionPenalties: this.contentionPenalties,
+      startingSpeedFor: (address) => this.encodeCost.speedForOutput(address),
       segmentStore: this.segmentStore,
       logger
     });
@@ -3659,63 +3659,6 @@ export class HlsSessionManager {
     return readers;
   }
 
-  /**
-   * One viewer's demand map, translated into this output's segment numbers.
-   *
-   * The map itself is seconds of film and knows nothing about cut grids
-   * (`services/priority/PriorityMap.js`). The translation is this output's own
-   * business, and it is exact: the timeline holds the boundaries.
-   *
-   * Two measurements feed it, and neither is chosen here:
-   *
-   * 1. the allowance below which an interruption reaches the viewer, from this
-   *    file's own recent interruptions (`minimumBufferFrom`). Null until the
-   *    reader has seen two of them, and then only the segment itself counts;
-   * 2. how fast this machine encodes THIS track, from ffmpeg's own progress.
-   *    Below realtime it decides how much has to exist before playback starts;
-   *    above it, nothing beyond the allowance is needed.
-   *
-   * @param {object} session
-   * @param {number} atSegment - Where the viewer is.
-   * @returns {{from: number, to: number, priority: number}[]} In segment
-   *   numbers, both ends inclusive.
-   */
-  #demandZonesFor(session, atSeconds, playing = true) {
-    const boundaries = session.timeline?.boundaries ?? [];
-    const segmentCount = Number(session.timeline?.segmentCount) || 0;
-    // Where they are, in this output's own numbering. The viewer holds seconds;
-    // every cut grid turns them into its own numbers, and two grids of one film
-    // give different numbers for the same second.
-    const atSegment = segmentCount > 0 ? this.#segmentIndexForTime(session, atSeconds) : 0;
-    if (segmentCount <= 0) {
-      // No playlist yet: the only thing that can be said is that they want
-      // where they are.
-      return [{ from: atSegment, to: atSegment, priority: 3 }];
-    }
-    const durationSeconds = Number(boundaries[boundaries.length - 1]) ||
-      segmentCount * this.segmentDurationSec;
-    const zones = mapForViewer({
-      atSeconds,
-      durationSeconds,
-      allowanceSeconds: minimumBufferFrom({
-        segmentSeconds: this.segmentDurationSec,
-        worstSupplyWaitSec: session.supplyFigures?.worstWaitSec
-      })?.seconds ?? this.segmentDurationSec,
-      playing
-    });
-    /** @type {{from: number, to: number, priority: number}[]} */
-    const inSegments = [];
-    for (const zone of zones) {
-      const from = Math.max(atSegment, this.#segmentIndexForTime(session, zone.from));
-      const to = Math.min(segmentCount - 1, this.#segmentIndexForTime(session, zone.to));
-      if (to >= from) {
-        inSegments.push({ from, to, priority: zone.priority });
-      }
-    }
-    return inSegments.length > 0
-      ? inSegments
-      : [{ from: atSegment, to: atSegment, priority: 3 }];
-  }
 
   /**
    * Say what the cushion is, for every session.
@@ -3871,62 +3814,35 @@ export class HlsSessionManager {
       }
       coverage.markReadyAll(this.segmentStore.provenNumbers(address));
       for (const session of sessions) {
-        for (const run of this.#runsOfSession(session)) {
+        for (const run of liveRunsOf(session)) {
           this.encodeOrchestrator.adopt(address, run);
         }
-        // What the viewers of this session are waiting for, as spans. A viewer
-        // wants the segment they are at and the cushion in front of it, which
-        // is what the encoder is steered by everywhere else in this class.
-        //
-        // PRESENCE AND POSITION ARE ASKED SEPARATELY, and that is the whole of
-        // the 2026-09-05 fix. Presence decides whether this viewer states a
-        // want at all; position decides what the want is. Asked as one question
-        // — which is what a single field written only by segment requests
-        // amounted to — a viewer who had just arrived answered "absent", every
-        // encoder on their output was stopped for having nobody, and the
-        // `init.mp4` they were waiting for in order to request their first
-        // segment was therefore never made.
-        for (const [consumerId, viewer] of viewersOf(session)) {
-          if (!viewer.isPresent(now, staleAfterMs)) {
-            this.encodeOrchestrator.release(`${session.id}:${consumerId}`);
-            continue;
-          }
-          // Placed when they arrived, from the position their own request
-          // named. A viewer with no position is one assembled by hand outside
-          // this class; they want the beginning, which is where an output
-          // starts when nobody says otherwise.
-          // SECONDS, and turned into this output's own numbering below. A
-          // segment number taken off the viewer would mean two different
-          // moments of film on the picture and on the soundtrack, which are cut
-          // independently: 454 pieces against 401 on the field file.
-          const at = viewer.positionSeconds() ?? 0;
-          // Their own map, in seconds of film, from measurements: how much must
-          // be ready before they set off so that they never stop — the observed
-          // allowance for this file plus what an encoder at THIS machine's
-          // measured speed will fail to deliver in time — then what it reaches
-          // while they watch that, then the rest of the track. No constant is
-          // consulted: the 120 seconds that used to size this window were the
-          // suspended encoder's threshold, one chosen number answering seven
-          // different questions.
-          for (const zone of this.#demandZonesFor(session, at, viewer.playing !== false)) {
-            this.encodeOrchestrator.want({
-              // The claimant is the PERSON, without the priority in it: their
-              // zones are separate windows, but they leave together, and
-              // `release` matches on this name.
-              claimant: `${session.id}:${consumerId}`,
-              address,
-              from: zone.from,
-              to: zone.to,
-              priority: zone.priority
-            });
-          }
-        }
       }
     }
+    // THE MAP IS BUILT ONCE, IN ITS OWN LAYER, AND BOTH SIDES READ THAT ONE.
+    //
+    // It used to be built twice: once here, per viewer, converted and stated to
+    // the encoding as a window each, and once again inside `publishFor` for the
+    // downloading. Two answers to one question, and the encoding's copy carried
+    // the viewer's NAME as the key of a claim — against the rule that the
+    // encoding and the viewer are not connected at all.
     this.priority.publishFor({
       sessionGroups: byOutput.values(),
       staleAfterMs: this.presenceStaleAfterMs()
     });
+    // Converted into each output's own numbering, because two outputs of one
+    // film are cut independently and the same second is a different number in
+    // each: 454 pieces against 401 on the field file.
+    for (const [address, sessions] of byOutput) {
+      const timeline = sessions[0].timeline;
+      this.encodeOrchestrator.notePriorityMap(
+        address,
+        timeline?.inSegments?.(
+          this.priority.mapFor(sessions[0].sourceKey, sessions[0].fileIndex),
+          Number(timeline?.segmentCount) || 0
+        ) ?? []
+      );
+    }
     this.encodeOrchestrator.reconcile();
   }
 
@@ -3988,34 +3904,6 @@ export class HlsSessionManager {
     }
   }
 
-  /**
-   * This session's run, told what the disk holds before it is asked where it
-   * has got to.
-   *
-   * A run learns of its own segments as they are SERVED, which is not when they
-   * are made — a viewer two minutes behind the encoder has asked for none of
-   * what is in front of them. The store knows, so the run is told, and its head
-   * is then the same figure the look-ahead and the plan have always used.
-   *
-   * @param {HlsSession} session
-   * @returns {import("./encode/EncodeRun.js").EncodeRun[]}
-   */
-  #runsOfSession(session) {
-    const runs = liveRunsOf(session);
-    if (runs.length === 0) {
-      return runs;
-    }
-    const produced = this.producedSegmentNumbers(session);
-    for (const run of runs) {
-      for (const index of produced) {
-        if (index >= run.from) {
-          run.noteProduced(index);
-        }
-      }
-    }
-    return runs;
-  }
-
   /**
    * How many encoders this machine can afford on one output at once.
    *
@@ -4031,19 +3919,10 @@ export class HlsSessionManager {
    * @returns {number}
    */
   maxRunsForOutput(address) {
-    let alone = 0;
-    for (const session of this.sessionsById.values()) {
-      if (session.outputKey !== address || session.state === "disposed") {
-        continue;
-      }
-      const measured = Number(session.recentSpeed?.speed);
-      if (Number.isFinite(measured) && measured > alone) {
-        alone = measured;
-      }
-    }
+    const alone = this.encodeCost.speedForOutput(address);
     if (!(alone > 0)) {
-      // Nothing measured on this output yet. One encoder is what it has, and
-      // what it has is what it keeps until there is a reading to argue with.
+      // The host measured nothing at all, which is a broken startup rather than
+      // a state to plan around. One encoder is what it keeps.
       return 1;
     }
     let affordable = 1;
@@ -5716,6 +5595,7 @@ export class HlsSessionManager {
         session.timeline?.segmentCount > 0 ? session.timeline.segmentCount - 1 : null,
       inputUnavailable: (message) => isInputUnavailable(message),
       onProgress: (report) => this.#noteRunProgress(session, run, report),
+      indexOfName: (name) => session.segmentFormat.segmentIndexFromName(name),
       onClosed: (name) => this.segmentStore.markClosed(session.outputKey ?? "", session.segmentFormat.segmentIndexFromName(name)),
       onEnded: (ended) => this.noteRunEnded(session, run, ended)
     });
@@ -7070,11 +6950,11 @@ export class HlsSessionManager {
     if (!output) {
       return false;
     }
-    const left = this.viewers.leaves(output, consumerId);
-    if (left) {
-      this.encodeOrchestrator.release(`${output.id}:${consumerId}`);
-    }
-    return left;
+    // Nothing to release in the encoding: it holds one map per output, built
+    // from where the viewers are, and the map that arrives next simply does not
+    // have this one in it. A name to release was the last place a viewer
+    // appeared inside the encoding at all.
+    return this.viewers.leaves(output, consumerId);
   }
 
   /**