@torrent-tv/proxy 2.97.14 → 2.97.16

package/package.json

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

package/server.js

@@ -180,6 +180,7 @@ export async function startProxyServer({
       indexMemory.forget(sourceKey);
       downloadMaps.retire(sourceKey);
       for (const key of segmentSourceRanges.keys()) if (key.startsWith(`${sourceKey}:`)) segmentSourceRanges.delete(key);
+      for (const key of segmentReadings.keys()) if (key.startsWith(`${sourceKey}:`)) segmentReadings.delete(key);
       outputParts.encodeInputs?.bytesChanged();
     },
     // Pieces arriving is ANNOUNCED by the thread that owns the swarm; what is
@@ -426,6 +427,42 @@ export async function startProxyServer({
   // Readers never start their own downloads or wait for source bytes.
   /** Source byte ranges of one segment interval, by file and interval; forgotten with the source. */
   const segmentSourceRanges = new Map();
+  /**
+   * What one segment of an output reads — its tracks, its interval and the key
+   * its bytes are kept under — by output and segment, until the tracks, the
+   * file's start time, the segment's interval or the choices of the output
+   * change; forgotten with the source.
+   */
+  const segmentReadings = new Map();
+  const segmentReadingOf = (zone, trackList, shift, map) => {
+    const choicesKey = zone.tracks.map(choice => `${choice.type}/${choice.index}/${choice.mode}`).join(",");
+    const key = `${map.sourceKey}:${map.fileIndex}:${zone.outputKey}:${zone.index}`;
+    const kept = segmentReadings.get(key);
+    if (kept && kept.trackList === trackList && kept.shift === shift && kept.choicesKey === choicesKey &&
+      kept.from === zone.sourceInterval.from && kept.to === zone.sourceInterval.to) return kept.reading;
+    const selected = zone.tracks.map(choice => ({ choice, track: choice.type === "video"
+      ? ContainerTrack.firstUsable(trackList, "video")
+      : trackList.filter(track => track.type === choice.type)[choice.index] }));
+    let reading = null;
+    if (!selected.some(({ track }) => !track)) {
+      const wanted = selected.map(({ track }) => track);
+      const modes = new Map(selected.map(({ choice, track }) => [track, choice.mode]));
+      const interval = { ...zone.sourceInterval, trackIds: wanted.map(track => track.trackNumber),
+        modes: Object.fromEntries(wanted.map(track => [track.trackNumber, modes.get(track)])) };
+      reading = { wanted, modes, interval, rangesKey: `${map.sourceKey}:${map.fileIndex}:${JSON.stringify(interval)}` };
+    }
+    segmentReadings.set(key, { trackList, shift, choicesKey, from: zone.sourceInterval.from, to: zone.sourceInterval.to, reading });
+    return reading;
+  };
+  /** A segment's ranges joined at the precision the torrent fetches, once per kept list and piece length. */
+  const joinedRanges = new WeakMap();
+  const joinedRangesOf = (ranges, pieceLength) => {
+    const kept = joinedRanges.get(ranges);
+    if (kept && kept.pieceLength === pieceLength) return kept.joined;
+    const joined = joinedWithinPieces(ranges, pieceLength);
+    if (ranges !== null && typeof ranges === "object") joinedRanges.set(ranges, { pieceLength, joined });
+    return joined;
+  };
   const downloadMaps = new DownloadMaps({
     // The ranges a picture reads at open are named again by every segment;
     // only the zone the swarm would rank first is sent (torrent-tv/meta#166).
@@ -487,19 +524,28 @@ export async function startProxyServer({
       if (!map.isCurrent()) return [];
       const direct = navigated.kind === "result" && navigated.value === true &&
         typeof container?.readSourceRanges === "function" ? container : null;
+      // An output whose file-level reading is not there in this pass — the
+      // index or Cues that say where a segment is, not yet downloaded, or the
+      // table its segments read, refused memory — answers its other segments
+      // the same way. One unanswered request is kept to be retried when the
+      // bytes or the memory change, and the map is built again when it
+      // answers; asking every segment held the main thread for 3.3 s on a cold
+      // two-hour AVI (torrent-tv/meta#178).
+      const waiting = new Set();
       for (const zone of demands) {
         if (!map.isCurrent()) return [];
-        const selected = zone.tracks.map(choice => ({ choice, track: choice.type === "video"
-          ? ContainerTrack.firstUsable(tracks.value, "video")
-          : tracks.value.filter(track => track.type === choice.type)[choice.index] }));
-        if (selected.some(({ track }) => !track)) continue;
-        const wanted = selected.map(({ track }) => track);
-        const modes = new Map(selected.map(({ choice, track }) => [track, choice.mode]));
-        const interval = { ...zone.sourceInterval, trackIds: wanted.map(track => track.trackNumber),
-          modes: Object.fromEntries(wanted.map(track => [track.trackNumber, modes.get(track)])) };
+        // WHAT A SEGMENT READS IS WORKED OUT ONCE, not on every publication: its
+        // tracks, its interval and the key its bytes are kept under depend on
+        // the output, the segment and the file's start time, none of which a
+        // new map changes. Rebuilt for every segment of the film on every map,
+        // this pass held the main thread up to 1.5 s at a time on Home
+        // Assistant (torrent-tv/meta#178).
+        const reading = segmentReadingOf(zone, tracks.value, shift, map);
+        if (!reading) continue;
+        const { wanted, modes, interval, rangesKey } = reading;
         const { tracks: _choices, owner: _owner, sourceInterval: _sourceInterval, ...demand } = zone;
         const convert = ranges => {
-          for (const [byteStart, byteEnd] of joinedWithinPieces(ranges, pieceLength)) converted.push({ ...demand,
+          for (const [byteStart, byteEnd] of joinedRangesOf(ranges, pieceLength)) converted.push({ ...demand,
             downloadInterval: { from: zone.owner.from, to: zone.owner.to }, byteStart, byteEnd });
         };
         // The bytes one segment needs are a fact of the file and the output, so
@@ -507,9 +553,9 @@ export async function startProxyServer({
         // the map changes every few seconds; worked out afresh on every change,
         // a pass over a two-hour AVI never finished and the next segment's bytes
         // were never asked for (Home Assistant 2026-10-08, torrent-tv/meta#151).
-        const rangesKey = `${map.sourceKey}:${map.fileIndex}:${JSON.stringify(interval)}`;
         const known = segmentSourceRanges.get(rangesKey);
         if (known) { convert(known); continue; }
+        if (waiting.has(zone.outputKey)) continue;
         if (direct) {
           // Asked per zone too: a soundtrack of an AVI is read from its own
           // packets, which the same index states (torrent-tv/meta#166).
@@ -535,10 +581,14 @@ export async function startProxyServer({
         if (!map.isCurrent()) return [];
         if (!intervalParams) continue;
         const navigation = await containerOrchestrator.inspect(intervalParams, "source-navigation");
-        if (navigation.kind !== "result") continue;
+        if (navigation.kind !== "result") {
+          if (navigation.kind === "needs-ranges" || navigation.kind === "needs-memory") waiting.add(zone.outputKey);
+          continue;
+        }
         const originalRanges = navigation.value;
         const packets = await containerOrchestrator.inspect(intervalParams, originalRanges ? "source-ranges" : "packets");
         if (!map.isCurrent()) return [];
+        if (packets.kind === "needs-memory") waiting.add(zone.outputKey);
         if (packets.kind !== "result") continue;
         const input = originalRanges ? packets.value : new SegmentInputs({ index: packets.value, tracks: wanted }).forInterval({ ...interval, mode: track => modes.get(track) });
         if (input.kind !== "result") continue;
@@ -562,7 +612,7 @@ export async function startProxyServer({
     failed: (request, error) => logger.warn(`media request=${request.key} probe failed: ${error?.message ?? error}`)
   });
   const indexMemory = new IndexMemory({
-    reviseBudget: () => { void outputParts.machineBudget.revise().catch(error => logger.warn(`packet index budget: ${error.message}`)); },
+    reviseBudget: () => { void outputParts.machineBudget.revise("memory", "media metadata").catch(error => logger.warn(`packet index budget: ${error.message}`)); },
     changed: () => { mediaReads.memoryChanged(); probeReads.memoryChanged(); outputParts.encodeInputs?.memoryChanged(); }
   });
   const containerOver = async ({ sourceKey, fileIndex, requestId, packetInterval, demand }) => {

package/services/encode/LocalObservations.js

@@ -197,7 +197,11 @@ export class LocalObservations {
    * @param {import("./output/OutputSpec.js").OutputSpec} params.spec
    * @param {ContentDescriptor | null} params.content - What it was encoded from.
    * @param {number | null} params.aloneSpeedX - Seconds of film per second,
-   *   measured with nothing else encoding.
+   *   measured with nothing else encoding and filed as if on a quiet machine
+   *   (`EncodeCost.learnFrom`), the unit the startup prediction it replaces
+   *   is in. Readings kept before torrent-tv/meta#178 were filed as read,
+   *   lower by what the machine was doing; the slowest is used, so they err
+   *   toward the viewer until newer ones replace them.
    * @param {{ averageKbps: number, peakKbps: number } | null} params.segmentKbps
    * @returns {void}
    */

package/services/encode/available-share.js

@@ -19,12 +19,28 @@
  * step was refused, and the quality menu emptied itself down to the one copied
  * height (fixed in 2.21.1).
  *
- * So: our own encoders are priced by the concurrency arithmetic, and the
- * proxy's own work — the torrent, the hashing, the delivery — is priced per
- * megabyte moved. Both are already in the budget. What is NOT in it is
- * everything else the machine does: the kernel, the container runtime, whatever
- * else the owner runs on their box. That is what is subtracted here, and
- * nothing more.
+ * So: our own encoders are priced by the concurrency arithmetic. The proxy's
+ * own work — the torrent thread, the hashing, the delivery, the copies of
+ * encoder inputs — was to be priced per megabyte moved, and that price is not
+ * established: since 2.97.9 it is measured for the log only, and nothing
+ * charges the proxy's processor to an encoder. An encoder therefore gets what
+ * other processes AND the proxy itself leave (`forEncoders`), the proxy's
+ * share as measured over the same interval, taken off once here and nowhere
+ * else (torrent-tv/meta#178). The field case of 2026-08-17 below: a step
+ * predicted at 1.83x on a quiet box ran at 1.01-1.12x while ffmpeg had 56 %,
+ * the proxy 20 % and the machine 99 %; what other processes leave predicts
+ * 1.41x, what the proxy leaves as well predicts 1.04x.
+ *
+ * Once means in the readings too. A speed a running encoder is seen at already
+ * contains what the machine left it then, so it is filed as if alone on a
+ * quiet machine — divided by `leftForEncoders` at the reading, the unit the
+ * startup measurements are filed in — and multiplied by what is left now when
+ * it is used. Filed as read, the proxy's draw at the reading was taken off a
+ * second time by every prediction made from it, which is the 2.21.0 failure.
+ *
+ * `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.
  */
 
 /**
@@ -34,24 +50,42 @@
  *   `shareOfMachine` reports them.
  * @param {number | null} reading.systemBusy - Everything the machine is doing.
  * @param {number | null} reading.encoderShare - Our own ffmpeg processes.
- * @param {number | null} reading.proxyShare - The proxy process itself.
- * @returns {{ share: number, unattributed: number, known: boolean }}
- *   `known` is false when the host does not report its own load — then the
- *   share is 1 and the caller must say it is uncorrected rather than pretend.
+ * @param {number | null} reading.proxyShare - The proxy process itself, every
+ *   thread of it.
+ * @returns {{ share: number, forEncoders: number, unattributed: number, known: boolean }}
+ *   `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.
  */
 export function availableShareFrom(reading = {}) {
   const systemBusy = finite(reading.systemBusy);
   if (systemBusy === null) {
     // No reading at all: not every host has /proc. An uncorrected prediction is
     // the honest answer, and the caller says so.
-    return { share: 1, unattributed: 0, known: false };
+    return { share: 1, forEncoders: 1, unattributed: 0, known: false };
   }
-  const ours = (finite(reading.encoderShare) ?? 0) + (finite(reading.proxyShare) ?? 0);
+  const encoders = finite(reading.encoderShare) ?? 0;
+  const ours = encoders + (finite(reading.proxyShare) ?? 0);
   // 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);
-  return { share: clamp(1 - unattributed, 0, 1), unattributed, known: true };
+  return { share: clamp(1 - unattributed, 0, 1), forEncoders: clamp(1 - (systemBusy - encoders), 0, 1),
+    unattributed, known: true };
+}
+
+/**
+ * The share of the machine an encoder gets: what other processes and the
+ * proxy leave, or 1 for a host that does not report its load.
+ *
+ * @param {{ share: number, forEncoders?: number, known: boolean } | null | undefined} availability
+ * @returns {number}
+ */
+export function leftForEncoders(availability) {
+  if (!availability?.known) {
+    return 1;
+  }
+  return Number.isFinite(availability.forEncoders) ? availability.forEncoders : availability.share;
 }
 
 /**
@@ -61,17 +95,14 @@ export function availableShareFrom(reading = {}) {
  * `share` of itself produces `share ×` the speed the benchmark measured alone.
  *
  * @param {number} predictedSpeed - From the quiet-host benchmark.
- * @param {{ share: number, known: boolean }} availability
+ * @param {{ share: number, forEncoders?: number, known: boolean }} availability
  * @returns {number}
  */
 export function correctForAvailability(predictedSpeed, availability) {
   if (!Number.isFinite(predictedSpeed) || predictedSpeed <= 0) {
     return predictedSpeed;
   }
-  if (!availability?.known) {
-    return predictedSpeed;
-  }
-  return predictedSpeed * availability.share;
+  return predictedSpeed * leftForEncoders(availability);
 }
 
 /**

package/services/encode/quality/EncodeCost.js

@@ -52,7 +52,7 @@ export function costKindForSession(session) {
   return session?.spec?.transcodesVideo === true ? "decode" : "copy";
 }
 
-import { correctForAvailability } from "../available-share.js";
+import { correctForAvailability, leftForEncoders } from "../available-share.js";
 import { medianOf, movedBeyondScatter, READINGS_KEPT } from "../learned-median.js";
 import { contentionPenalty } from "../contention.js";
 import { ENCODE_RUN_STATE, liveRunsOf, processCanBeSignalled } from "../encode-run-state.js";
@@ -366,7 +366,7 @@ export class EncodeCost {
     const outputs = this.#outputs.outputsOn(address);
     let measured = 0;
     for (const session of outputs) {
-      const speed = Number(qualityStateOf(session).lastAloneSpeed);
+      const speed = correctForAvailability(Number(qualityStateOf(session).lastAloneSpeed), this.#host().availability);
       if (Number.isFinite(speed) && speed > measured) {
         measured = speed;
       }
@@ -649,7 +649,7 @@ export class EncodeCost {
     /** @type {Map<number, number>} */
     const speeds = new Map();
     for (const session of this.#outputs.familyOf(base)) {
-      const speed = qualityStateOf(session).lastAloneSpeed;
+      const speed = correctForAvailability(qualityStateOf(session).lastAloneSpeed, this.#host().availability);
       if (!session.spec.transcodesVideo || !Number.isFinite(speed)) {
         continue;
       }
@@ -874,6 +874,17 @@ export class EncodeCost {
     if (speed === null) {
       return;
     }
+    // What this would have done alone on a quiet machine: the reading divided
+    // by what the machine left encoders while it was taken, the unit every
+    // price here is in. A prediction multiplies it by what is left NOW, so the
+    // proxy's own draw at the reading is not taken off a second time
+    // (torrent-tv/meta#178). A machine that left encoders nothing says nothing
+    // about that.
+    const left = leftForEncoders(this.#host().availability);
+    if (!(left > 0)) {
+      return;
+    }
+    const quietSpeed = speed / left;
     const state = qualityStateOf(session);
     const kind = costKindForSession(session);
     // A reading taken beside another encoder contains that other encoder's
@@ -906,10 +917,11 @@ export class EncodeCost {
     }
     // What this encode did with the machine to itself — the one figure a live
     // reading is authority on, and what withdraws a quality step that has been
-    // seen failing without letting it speak for steps nobody has run. The time
-    // the input waited for the swarm is not in it, so a starved run no longer
-    // reads as a slow machine.
-    state.lastAloneSpeed = speed;
+    // seen failing without letting it speak for steps nobody has run, judged
+    // at what the machine leaves encoders now. The time the input waited for
+    // the swarm is not in it, so a starved run no longer reads as a slow
+    // machine.
+    state.lastAloneSpeed = quietSpeed;
     // What the offer predicted for this very step, against what it then did
     // with the machine to itself. The prediction is corrected for the share of
     // the machine that was free at the time, so this ratio is the error that
@@ -936,7 +948,7 @@ export class EncodeCost {
       // What is left after the work that was already accounted for. `null` when
       // the subtraction leaves nothing positive, which means the reading says
       // less than the noise in it.
-      const ownCostSec = 1 / speed - othersCostSec;
+      const ownCostSec = 1 / quietSpeed - othersCostSec;
       if (!(ownCostSec > 0) || !Number.isFinite(ownCostSec)) {
         return;
       }
@@ -944,10 +956,10 @@ export class EncodeCost {
       return;
     }
     if (kind === "decode") {
-      this.#learnDecodeCost(session, speed);
+      this.#learnDecodeCost(session, quietSpeed);
       return;
     }
-    await this.#learnCopyCost(session, speed);
+    await this.#learnCopyCost(session, quietSpeed);
   }
 
   async #learnCopyCost(session, speed) {

package/services/encode/quality/HostLoad.js

@@ -572,7 +572,8 @@ export class HostLoad {
       ` over=${share.elapsedSec.toFixed(1)}s` +
       // What the offer will multiply a prediction by, in the same line as the
       // readings it comes from.
-      ` available=${asPercent(this.hostAvailability.share)} free=${asPercent(free)}` + late
+      ` available=${asPercent(this.hostAvailability.share)} for-encoders=${asPercent(this.hostAvailability.forEncoders)}` +
+      ` free=${asPercent(free)}` + late
     );
   }
 

package/services/encode/quality/QualityOffer.js

@@ -31,6 +31,7 @@ import { chooseOutputFps, computeOutputDimensions, TRANSCODE_FPS } from "../args
 import { processCanBeSignalled } from "../encode-run-state.js";
 import { sourceDecodeCharacteristics } from "../../media/SourceFile.js";
 import { qualityStateOf } from "./OutputQualityState.js";
+import { leftForEncoders } from "../available-share.js";
 
 export class QualityOffer {
   #cost;
@@ -39,6 +40,7 @@ export class QualityOffer {
   #supplyFor;
   #stateFor;
   #occupancyKnownFor;
+  #availability;
 
   /**
    * @param {{
@@ -69,8 +71,13 @@ export class QualityOffer {
     // Whether every other output holding a place has a measured price. The
     // pool must not be told this host can serve a file while existing work is
     // unpriced (roadmap item 97, step 14).
-    occupancyKnownFor = () => true
+    occupancyKnownFor = () => true,
+    // WHAT THIS MACHINE LEAVES AN ENCODER, as the host last measured it
+    // (`available-share.js`): read into the answer, so a change of it reaches
+    // the menu (torrent-tv/meta#178).
+    availability = () => null
   }) {
+    this.#availability = availability;
     this.#occupiedCostSec = occupiedCostSec;
     this.#occupancyKnownFor = occupancyKnownFor;
     this.#cost = encodeCost;
@@ -164,14 +171,24 @@ export class QualityOffer {
     // whole film; while rounding alone would hide the 0.995-1.005 crossing,
     // which is exactly the band a step spends its time in when the host is
     // marginal. The flag carries the crossing, the rounded cost carries the
-    // rest.
+    // rest. The speed is filed as if alone on a quiet machine; the crossing is
+    // judged at what the machine leaves encoders now.
+    // WHAT THE MACHINE LEAVES AN ENCODER divides every prediction the answer is
+    // made of, and it moves with the download and everything else this process
+    // does. Left out, a menu computed while the proxy was quiet stood for the
+    // whole film: `fast` at a predicted 1.0x ran at 0.9-1.1x once the swarm
+    // delivered, and the picture stood at nearly every piece after a seek
+    // (Home Assistant 2026-10-12, torrent-tv/meta#178). To a hundredth of the
+    // machine, the finest the predictions it divides are compared at.
+    const availability = this.#availability();
+    const left = leftForEncoders(availability);
     const measured = this.#outputs.familyOf(owner)
       .map((member) => {
         const speed = qualityStateOf(member).lastAloneSpeed;
         if (!Number.isFinite(speed) || !(speed > 0)) {
           return "-";
         }
-        return `${speed < 1 ? "slow" : "ok"}${(1 / speed).toFixed(2)}`;
+        return `${speed * left < 1 ? "slow" : "ok"}${(1 / speed).toFixed(2)}`;
       })
       .join(",");
     // The bar the answer is judged against, and the rate the torrent's price is
@@ -185,7 +202,7 @@ export class QualityOffer {
     const version =
       `${observed?.version ?? 0}:${playing}:${copyVersion}:${torrentCost.toFixed(6)}:` +
       `${audioVersion}:${running}:${measured}:${(demanded ?? 0).toFixed(2)}:` +
-      `${(movingMegabytes ?? 0).toFixed(2)}`;
+      `${(movingMegabytes ?? 0).toFixed(2)}:${left.toFixed(2)}`;
     const state = qualityStateOf(owner);
     if (Array.isArray(state.offeredHeightsCache) && state.offeredHeightsVersion === version) {
       return state.offeredHeightsCache;

package/services/media/MediaReadRequests.js

@@ -1,6 +1,22 @@
-/** Retry unfinished statements when their missing resource changes. */
+/**
+ * Retry unfinished statements when their missing resource changes.
+ *
+ * ONE REFUSAL OF MEMORY ANSWERS THE STATEMENT, not one request of it. The
+ * table a statement reserves belongs to the file — a soundtrack's packet table
+ * is one table for every segment of it — so once a read of a statement has
+ * been refused memory, the other requests of the same statement of the same
+ * file wait for memory to change instead of being read and refused one by one.
+ * Read one by one, a cold two-hour AVI's 1943 soundtrack segments were refused
+ * in turn when the index's last piece arrived, which held the main thread for
+ * 3.3 s and the budget revision that would have given the memory behind it
+ * (Home Assistant 2026-10-12, torrent-tv/meta#178). A retry wave therefore
+ * reads one request of each statement first and the others once it has
+ * answered.
+ */
 export class MediaReadRequests {
   #requests = new Map();
+  /** File and statement → the memory revision at which a read of it was refused memory. */
+  #refusedMemory = new Map();
   #read;
   #failed;
   #versions = new Map();
@@ -39,6 +55,7 @@ export class MediaReadRequests {
       this.#notify(params.sourceKey, params.fileIndex, result);
       return this.#requests.delete(key);
     }
+    if (result.kind === "needs-memory") this.#refusedMemory.set(statementKey(params, statement), memoryRevision);
     const existing = this.#requests.get(key);
     if (existing) { existing.params = params; existing.kind = result.kind; }
     else this.#requests.set(key, { params, statement, kind: result.kind, running: false, changed: false });
@@ -54,24 +71,49 @@ export class MediaReadRequests {
 
   memoryChanged() {
     this.#memoryVersion++;
+    const wave = [];
     for (const request of this.#requests.values()) {
       if (request.kind !== "needs-memory") continue;
       // The retried statement announces its result. A memory event is not a
       // source change for another statement still waiting for missing bytes.
       request.changed = true;
-      if (!request.running) void this.#retry(request);
+      if (!request.running) wave.push(request);
     }
+    this.#retryWave(wave);
   }
 
   bytesChanged(sourceKey, fileIndex) {
     const fileKey = `${sourceKey}:${fileIndex}`;
     this.#versions.set(fileKey, this.revision(sourceKey, fileIndex) + 1);
     this.#notify(sourceKey, fileIndex, { kind: "bytes-changed" });
+    const wave = [];
     for (const request of this.#requests.values()) {
       if (request.params.sourceKey !== sourceKey || request.params.fileIndex !== fileIndex) continue;
       if (request.kind !== "needs-ranges") continue;
       request.changed = true;
-      if (!request.running) void this.#retry(request);
+      if (!request.running) wave.push(request);
+    }
+    this.#retryWave(wave);
+  }
+
+  /**
+   * Retry `requests`: one of each statement of each file first, the others of
+   * that statement once it has answered.
+   *
+   * @param {object[]} requests
+   */
+  #retryWave(requests) {
+    const groups = new Map();
+    for (const request of requests) {
+      const key = statementKey(request.params, request.statement);
+      const group = groups.get(key);
+      if (group) group.push(request);
+      else groups.set(key, [request]);
+    }
+    for (const [head, ...rest] of groups.values()) {
+      void this.#retry(head).then(() => {
+        for (const request of rest) if (!request.running) void this.#retry(request);
+      });
     }
   }
 
@@ -90,6 +132,10 @@ export class MediaReadRequests {
     for (const key of this.#versions.keys()) {
       if (fileIndex === undefined ? key.startsWith(`${sourceKey}:`) : key === `${sourceKey}:${fileIndex}`) this.#versions.delete(key);
     }
+    for (const key of [...this.#refusedMemory.keys()]) {
+      const [refusedSource, refusedFile] = JSON.parse(key);
+      if (refusedSource === sourceKey && (fileIndex === undefined || refusedFile === fileIndex)) this.#refusedMemory.delete(key);
+    }
   }
 
   retain(sourceKey, fileIndex, wanted) {
@@ -105,6 +151,12 @@ export class MediaReadRequests {
     try {
       while (request.changed && this.#requests.get(key) === request) {
         request.changed = false;
+        if (this.#refusedMemory.get(statementKey(request.params, request.statement)) === this.#memoryVersion) {
+          // The same statement of the same file was refused memory in this
+          // very state of memory: so is this one, without reading it.
+          request.kind = "needs-memory";
+          break;
+        }
         await this.#read(request.params, request.statement);
       }
     } catch (error) {
@@ -118,3 +170,7 @@ export class MediaReadRequests {
 function requestKey(params, statement) {
   return JSON.stringify([params.sourceKey, params.fileIndex, statement, params.requestId ?? null]);
 }
+
+function statementKey(params, statement) {
+  return JSON.stringify([params.sourceKey, params.fileIndex, statement]);
+}

package/services/media/container/AviContainer.js

@@ -167,7 +167,7 @@ export class AviContainer extends Container {
     if (!index) return false;
     const picture = ContainerTrack.firstUsable(await this.readTracks(), "video");
     if (picture && interval?.trackIds?.length && !interval.trackIds.includes(picture.trackNumber)) return false;
-    return !picture || index.keyframeTimes(picture.trackNumber).length > 0;
+    return !picture || index.hasKeyframes(picture.trackNumber);
   }
 
   async readMappedSourceRanges(interval) { return this.readSourceRanges(interval); }

package/services/media/container/avi-index.js

@@ -296,6 +296,16 @@ class AviIndex {
     return keys;
   }
 
+  /**
+   * Whether a stream states any keyframe. Asked for every segment while a map
+   * is turned into bytes; answered from the times it built a list of every
+   * keyframe of the film each time, 6.1 s at once on Home Assistant
+   * (torrent-tv/meta#178).
+   */
+  hasKeyframes(stream) {
+    return this.#keyframesOf(stream).length > 0;
+  }
+
   /** Keyframe times of a stream, ascending. */
   keyframeTimes(stream) {
     const packets = this.packets[stream];

package/services/server/ViewerRequests.js

@@ -26,6 +26,21 @@ function isWarmupTimeoutError(error) {
  * @param {string} fileName
  * @returns {number | null}
  */
+/**
+ * Whether two lists of a piece's torrent inputs state the same bytes: the
+ * download map hands out new lists around the ranges it keeps, so the ranges
+ * themselves are compared.
+ *
+ * @param {Array<{ sourceId: string, ranges: object[] }> | undefined} left
+ * @param {Array<{ sourceId: string, ranges: object[] }> | undefined} right
+ * @returns {boolean}
+ */
+function sameInputs(left, right) {
+  if (left === right) return true;
+  if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
+  return left.every((input, index) => input.sourceId === right[index].sourceId && input.ranges === right[index].ranges);
+}
+
 function segmentAddressOf(output, fileName) {
   const format = output.segmentFormat;
   if (!format) {
@@ -45,6 +60,8 @@ export class ViewerRequests {
   #host;
   /** @type {WeakMap<object, Map<string, object>>} */
   #rateStateBySession = new WeakMap();
+  /** The pieces of each output as the start forecast read them last; see `#segmentsOf`. */
+  #forecastPieces = new WeakMap();
 
   /**
    * @param {object} host - `opening`, `activeOutputFor`, `viewerSecondsOn`, `minimumBufferSecondsFor`, `getSourceStats`, `disposeSession`, `planEncodersSoon`, `waitUntilReady`, `encodeRuns`, `encodeSpeedReadingOf`, `outputTimes`, `outputs`, `lookaheadSeconds`, `quality`, `qualityOffer`, `renditions`, `segmentDurationSec`, `segmentStore`, `sourceFiles`, `startupWaitMs`, `viewers`, `acceptsGeneration`, `generationOfRequest`, `noteGivenOutput`, `holdForResponse`, `noteServingVerdict`, `servingVerdictOf`
@@ -561,10 +578,7 @@ export class ViewerRequests {
     for (const output of outputs) {
       const trackProgress = output === session ? progress : this.#host.encodeRuns.progressOf(output);
       const trackRates = this.#trackRateReadings(measurement, output, now);
-      const timeline = output.timeline;
       const trackName = output === session ? "video" : "audio";
-      const nativeRanges = Array.from({ length: timeline?.segmentCount ?? 0 }, (_, index) =>
-        this.#host.encodeRuns.finishedMediaRangesOf(output, index));
       // The page states the offset its player applied to this track, and the
       // init it applied it to is the session's. Until both are known, the
       // pieces stay on their own presentation timeline: there is nothing yet
@@ -573,17 +587,9 @@ export class ViewerRequests {
       const servedInit = Number.isFinite(playerOffset) ? this.#host.segmentStore.initOf(output.outputKey) : null;
       const placedByPlayer = Boolean(servedInit?.length);
       const sessionInit = placedByPlayer ? servedInit : null;
-      const segments = Array.from({ length: timeline?.segmentCount ?? 0 }, (_, index) => {
-        const ranges = nativeRanges[index];
-        return {
-          index,
-          startSeconds: timeline.publishedStartOf(index),
-          endSeconds: timeline.publishedStartOf(index + 1),
-          sourceInputs: this.#host.sourceInputsFor?.(output, index) ?? undefined,
-          mediaRanges: ranges && output.segmentFormat?.servedMediaRanges ?
-            output.segmentFormat.servedMediaRanges(ranges, { initBytes: sessionInit }) : undefined
-        };
-      });
+      const inventory = this.#host.segmentStore.sizesOf(output.outputKey);
+      const segments = this.#segmentsOf(output, sessionInit, inventory, Number.isFinite(viewerReading?.positionSeconds)
+        ? viewerReading.positionSeconds : this.#host.viewerSecondsOn(session, consumerId, now));
       const sourceIndexes = [...output.spec.sourceFileIndexes];
       if (sourceIndexes.length === 0) {
         sourceIndexes.push(output.file.fileIndex);
@@ -622,7 +628,6 @@ export class ViewerRequests {
         });
       }
 
-      const inventory = this.#host.segmentStore.sizesOf(output.outputKey);
       const observedMbps = output === session
         ? outputMbps
         : await this.#host.quality.observedStreamMbps(output);
@@ -733,9 +738,98 @@ export class ViewerRequests {
         }))
       })}`);
     }
+    this.#sayHolding(session, consumerId, measurement, forecast, input, now);
     return forecast;
   }
 
+  /**
+   * What holds a waiting viewer's start, said when it changes: which piece,
+   * its production or its delivery, when it comes against the media before it,
+   * and the rates the forecast used. Said again when the delay has moved by a
+   * second, at most once a second; a hold that changes nothing says nothing.
+   *
+   * @param {object} session
+   * @param {string} consumerId
+   * @param {object} measurement - This viewer's forecast state.
+   * @param {object} forecast
+   * @param {object} input
+   * @param {number} now
+   */
+  #sayHolding(session, consumerId, measurement, forecast, input, now) {
+    const holding = forecast.holdingBy;
+    if (!holding) {
+      measurement.held = null;
+      return;
+    }
+    const key = `${holding.kind}:${holding.track}:${holding.segment}`;
+    const delay = Number.isFinite(forecast.delaySeconds) ? forecast.delaySeconds : null;
+    const said = measurement.held;
+    if (said && said.key === key && (delay === null || said.delay === null || Math.abs(delay - said.delay) < 1 ||
+      now - said.at < 1000)) return;
+    measurement.held = { key, delay, at: now };
+    const seconds = value => Number.isFinite(value) ? value.toFixed(2) : "?";
+    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;
+      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 ` +
+      (holding.kind === "position-not-held" ? "the position, which nothing buffered covers" :
+        `the ${holding.kind} of ${holding.track} #${holding.segment} in ${seconds(holding.atSeconds)}s against ` +
+        `${seconds(holding.aheadSeconds)}s of media before it${holding.requiresSource ? ", its input still downloading" : ""}`) +
+      `; buffered ${seconds(forecast.bufferedSeconds)}s; rates ${rates.join(", ") || "none"}; download ${downloads.join(", ") || "none"}`);
+  }
+
+  /**
+   * The pieces of one output as the start forecast reads them, kept between
+   * polls: a piece whose playlist edges, read ranges and torrent inputs have
+   * not changed is the same object it was, so what the forecast derived from it
+   * once — its exact edges, its joined ranges — is not derived again. An unread
+   * piece that is not made and ends before the viewer is not listed: the
+   * forecast reads nothing from it. Building the whole film anew on every poll
+   * was part of what held the main thread for seconds (torrent-tv/meta#178).
+   *
+   * @param {object} output
+   * @param {Buffer | null} sessionInit
+   * @param {Map<number, number>} inventory - Made pieces and their sizes.
+   * @param {number} positionSeconds
+   * @returns {object[]}
+   */
+  #segmentsOf(output, sessionInit, inventory, positionSeconds) {
+    const timeline = output.timeline;
+    const count = timeline?.segmentCount ?? 0;
+    let kept = this.#forecastPieces.get(output);
+    if (!kept) {
+      kept = [];
+      this.#forecastPieces.set(output, kept);
+    }
+    const segments = [];
+    for (let index = 0; index < count; index++) {
+      const endSeconds = timeline.publishedStartOf(index + 1);
+      const ranges = this.#host.encodeRuns.finishedMediaRangesOf(output, index);
+      const mediaRanges = ranges && output.segmentFormat?.servedMediaRanges ?
+        output.segmentFormat.servedMediaRanges(ranges, { initBytes: sessionInit }) : undefined;
+      if (index !== 0 && mediaRanges === undefined && !inventory.has(index) &&
+        Number.isFinite(endSeconds) && Number.isFinite(positionSeconds) && endSeconds <= positionSeconds) {
+        continue;
+      }
+      const startSeconds = timeline.publishedStartOf(index);
+      const sourceInputs = this.#host.sourceInputsFor?.(output, index) ?? undefined;
+      const previous = kept[index];
+      if (previous && previous.startSeconds === startSeconds && previous.endSeconds === endSeconds &&
+        previous.mediaRanges === mediaRanges && sameInputs(previous.sourceInputs, sourceInputs)) {
+        segments.push(previous);
+        continue;
+      }
+      const segment = { index, startSeconds, endSeconds, sourceInputs, mediaRanges };
+      kept[index] = segment;
+      segments.push(segment);
+    }
+    if (kept.length > count) kept.length = count;
+    return segments;
+  }
+
   #rateStateFor(session, consumerId) {
     let byViewer = this.#rateStateBySession.get(session);
     if (!byViewer) {

package/services/server/wire-outputs.js

@@ -860,6 +860,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,
     outputs: parts.outputs,
     stateFor: (session) => parts.encodeRuns.runStateOf(session),
     // WHICH HEIGHTS A LIVE VIEWER HAS ON SCREEN, as numbers. Who is watching
@@ -1007,7 +1008,7 @@ export function wireOutputs({
     resolve: resolveEncodeInput,
     readRanges: readEncodeRanges,
     heldRanges: readEncodeHeldRanges,
-    reviseBudget: () => parts.machineBudget.revise(),
+    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
     // readings (torrent-tv/meta#184).

package/services/storage/MachineBudget.js

@@ -77,6 +77,14 @@ import { OtherDemand, divideAllowance } from "./allowance.js";
 export class MachineBudget {
   #revisionPromise = null;
   #reviseAgain = false;
+  /**
+   * The resources the next pass reads: `null` for every one, else their names.
+   * A claimant short of memory asks for memory alone; reading the disks first
+   * made its answer wait for them (torrent-tv/meta#178).
+   *
+   * @type {Set<string> | null}
+   */
+  #againScope = null;
   /**
    * The revision in hand, for its own line: when it was first asked for, how
    * many asks joined it, and which pass this is. At a cold start on the addon
@@ -151,32 +159,45 @@ export class MachineBudget {
   }
 
   /**
-   * Read every resource, divide each, and tell each claimant its share.
+   * Read the resources, divide each, and tell each claimant its share.
    *
+   * @param {string | null} [resource] - One resource to read and divide; every
+   *   resource when absent. The others keep their last division.
+   * @param {string | null} [because] - Who asked, said in the revision's line.
    * @returns {Promise<Map<string, { freeBytes: number, allowanceBytes: number, shares: object[] }>>}
    */
-  revise() {
+  revise(resource = null, because = null) {
+    const scope = resource === null ? null : new Set([resource]);
     if (this.#revisionPromise) {
       this.#reviseAgain = true;
+      this.#againScope = this.#againScope === null || scope === null ? null : new Set([...this.#againScope, ...scope]);
       this.#revision.asks += 1;
       return this.#revisionPromise;
     }
-    this.#revision = { askedAt: Date.now(), asks: 1, pass: 0 };
+    this.#revision = { askedAt: Date.now(), asks: 1, pass: 0, because };
+    this.#againScope = scope;
     this.#revisionPromise = (async () => {
       do {
+        const passScope = this.#againScope;
+        this.#againScope = new Set();
         this.#reviseAgain = false;
         this.#revision.pass += 1;
-        await this.#readRevision();
+        await this.#readRevision(passScope);
       } while (this.#reviseAgain);
       return this.#last;
     })().finally(() => { this.#revisionPromise = null; });
     return this.#revisionPromise;
   }
 
-  async #readRevision() {
+  /** @param {Set<string> | null} scope */
+  async #readRevision(scope) {
     const passFrom = Date.now();
     let readingMs = 0;
+    const readings = [];
     for (const [name, resource] of this.#resources) {
+      if (scope !== null && !scope.has(name)) {
+        continue;
+      }
       const claimants = this.#claimants.filter((one) => one.resource === name);
       if (claimants.length === 0) {
         continue;
@@ -185,6 +206,7 @@ export class MachineBudget {
       const readFrom = Date.now();
       const free = await resource.readFree();
       readingMs += Date.now() - readFrom;
+      readings.push(`${name} ${Date.now() - readFrom}ms`);
       // WITHOUT A READING, NOTHING IS ALLOWED TO GROW. A resource whose free
       // space cannot be read is not a resource with room; answering "unbounded"
       // there is how the spill file came to have no limit in the first place.
@@ -213,8 +235,9 @@ export class MachineBudget {
     }
     const revision = this.#revision;
     this.#logger?.info?.(`${this.describe()}` + (revision
-      ? ` (pass ${revision.pass} of a revision asked ${revision.asks} time(s), first ${Date.now() - revision.askedAt}ms ago; ` +
-        `this pass ${Date.now() - passFrom}ms, ${readingMs}ms of it reading what is free)`
+      ? ` (pass ${revision.pass} of a revision asked ${revision.asks} time(s), first ${Date.now() - revision.askedAt}ms ago` +
+        `${revision.because ? `, first by ${revision.because}` : ""}; ` +
+        `this pass ${Date.now() - passFrom}ms, ${readingMs}ms of it reading what is free: ${readings.join(", ") || "nothing"})`
       : ""));
     return this.#last;
   }

package/services/storage/piece-store/shared-piece-store.js

@@ -1786,6 +1786,47 @@ export class SharedPieceStore {
     write().then(() => callback(null), (error) => callback(error));
   }
 
+  /**
+   * What `get` answers, written into `target` (exactly `length` bytes long)
+   * instead of a buffer of its own, by the same three routes: memory, disk,
+   * whole file. A reader copying a stretch of film into memory it already holds
+   * then needs nothing beside it while several pieces are read at once
+   * (torrent-tv/meta#178). Answers whether `target` was filled.
+   *
+   * @param {number} index
+   * @param {number} offset - Within the piece.
+   * @param {Buffer} target
+   * @returns {Promise<boolean>}
+   */
+  async getInto(index, offset, target) {
+    if (this.#closed) throw new Error("Piece store is closed.");
+    const length = target.length;
+    if (offset < 0 || offset + length > this.#lengthOf(index)) return false;
+    const fromMemory = () => {
+      const resident = this.#buffers.get(index);
+      if (resident === undefined) return false;
+      this.#lru.touch(index);
+      this.#counters.fromMemory += 1;
+      Buffer.from(resident, offset, length).copy(target);
+      return true;
+    };
+    if (fromMemory()) return true;
+    // A spill that is still being written owns the only copy there is.
+    const spill = this.#evicting.get(index);
+    if (spill) await spill.catch(() => undefined);
+    if (fromMemory()) return true;
+    if (this.#disk.has(index)) {
+      const bytesRead = await this.#disk.read(index, target, offset);
+      this.#counters.fromDisk += 1;
+      return bytesRead === length;
+    }
+    const whole = await this.#fromWholeFiles(index);
+    if (!whole || whole.length < offset + length) return false;
+    this.#counters.fromWholeFile += 1;
+    whole.copy(target, 0, offset, offset + length);
+    return true;
+  }
+
   get(index, options, callback) {
     if (typeof options === "function") {
       return this.get(index, undefined, options);

package/services/storage/wire.js

@@ -153,8 +153,9 @@ export function wireMachineBudget({
     });
   }
 
+  let evidenceOn = null;
   if (diagnostics) {
-    const evidenceOn = diagnosticsRoot ? deviceOf(diagnosticsRoot) : segmentsOn;
+    evidenceOn = diagnosticsRoot ? deviceOf(diagnosticsRoot) : segmentsOn;
     defineDisk(evidenceOn, diagnosticsRoot || segmentStore.root);
     budget.register({
       name: "diagnostics",
@@ -169,11 +170,22 @@ export function wireMachineBudget({
 
   return {
     capacityOf: name => budget.capacityOf(name),
-    revise: async () => {
-      // Re-read the evidence before dividing: it is the one claimant whose
-      // bytes are written by something that never reports them.
-      await diagnostics?.measure();
-      return budget.revise();
+    /**
+     * @param {string | null} [resource] - One resource to revise; all when absent.
+     * @param {string | null} [because] - Who asked, for the revision's line.
+     */
+    revise: async (resource = null, because = null) => {
+      // Re-read the evidence before dividing its disk: it is the one claimant
+      // whose bytes are written by something that never reports them. Only
+      // there: a claimant short of memory asks for memory alone, and walking
+      // the evidence's directory first made every memory answer wait for it —
+      // 3.7 s on a cold AVI behind 1943 other reads (torrent-tv/meta#178).
+      if (diagnostics && (resource === null || resource === evidenceOn)) {
+        const from = Date.now();
+        await diagnostics.measure();
+        because = `${because ?? "a full revision"}, after the evidence was measured in ${Date.now() - from}ms`;
+      }
+      return budget.revise(resource, because);
     },
     segmentBytes: () => segmentBytes,
     diagnostics: diagnostics ?? null,

package/services/torrent/worker/held-bytes.js

@@ -1,5 +1,15 @@
 import { pieceStoreOf } from "../piece-store-of.js";
 
+/**
+ * How many pieces one read for a reader asks of the store at once: the threads
+ * libuv runs file operations on (`UV_THREADPOOL_SIZE`). The proxy's entry point
+ * sets 64 where the deployment states none (`bin/thread-pool.js`), and libuv's
+ * own default of four applies only to code run without it, such as the
+ * checks. A piece from disk is three of their operations, and more at once
+ * would only wait behind them (torrent-tv/meta#178).
+ */
+const FILE_READS_AT_ONCE = Math.max(1, Number.parseInt(process.env.UV_THREADPOOL_SIZE ?? "", 10) || 4);
+
 /**
  * @file What of a file the torrent already HOLDS, and reading it without
  * asking the swarm for anything.
@@ -212,17 +222,35 @@ export async function readHeldRanges(torrent, fileIndex, ranges, maxBytes, logge
   }
   try {
     const result = ranges.map(([start, end]) => Buffer.allocUnsafeSlow(end - start + 1));
-    for (const [index, span] of pieceSpans) {
+    // SEVERAL PIECES AT ONCE, each written straight into the copy. One after
+    // another, every read from disk waited for this thread's loop on its own,
+    // and the loop runs 0.3-0.7 s late while the swarm delivers 7-14 MB/s: a
+    // 210 MB stretch took 11 s here (Home Assistant 2026-10-12,
+    // torrent-tv/meta#178). As many are in flight as the runtime has threads
+    // for file operations (libuv's pool, `UV_THREADPOOL_SIZE`, 64 as the proxy
+    // starts); more would only queue behind them and ahead of everything else
+    // this process reads or writes.
+    const readOne = async ([index, span]) => {
       const pieceStart = index * pieceLength;
       const offset = span.start - pieceStart;
       const length = span.end - span.start + 1;
+      const [only] = span.ranges;
+      // A piece holding one range alone is read into the copy itself; one
+      // shared by several ranges is read once and divided, as before.
+      if (span.ranges.length === 1 && typeof store.getInto === "function") {
+        const from = Math.max(only.absoluteStart, pieceStart);
+        const filled = await store.getInto(index, offset, result[only.rangeIndex].subarray(from - only.absoluteStart, from - only.absoluteStart + length));
+        if (!filled) return false;
+        onRead?.(length);
+        return true;
+      }
       const buffer = await new Promise((resolve, reject) => {
         store.get(index, { offset, length }, (error, value) => {
           if (error) reject(error);
           else resolve(value);
         });
       });
-      if (!buffer || buffer.length !== length) return null;
+      if (!buffer || buffer.length !== length) return false;
       onRead?.(length);
       for (const { rangeIndex, absoluteStart, absoluteEnd } of span.ranges) {
         const from = Math.max(absoluteStart, pieceStart);
@@ -230,8 +258,27 @@ export async function readHeldRanges(torrent, fileIndex, ranges, maxBytes, logge
         const sourceStart = from - span.start;
         result[rangeIndex].set(buffer.subarray(sourceStart, sourceStart + to - from + 1), from - absoluteStart);
       }
-    }
-    return result;
+      return true;
+    };
+    const spans = [...pieceSpans];
+    let next = 0;
+    let whole = true;
+    const reader = async () => {
+      while (whole && next < spans.length) {
+        try {
+          if (!await readOne(spans[next++])) whole = false;
+        } catch (error) {
+          whole = false;
+          throw error;
+        }
+      }
+    };
+    // Every read has returned before the pieces are let go, a failed one too:
+    // a read still in flight would otherwise read a piece nothing holds.
+    const outcomes = await Promise.allSettled(Array.from({ length: Math.min(spans.length, FILE_READS_AT_ONCE) }, reader));
+    const failed = outcomes.find((outcome) => outcome.status === "rejected");
+    if (failed) throw failed.reason;
+    return whole ? result : null;
   } catch (error) {
     logger?.info?.(`held ranges read ${fileIndex} failed: ${error?.message ?? error}`);
     return null;

package/services/viewer/playback-readiness.js

@@ -31,7 +31,6 @@ import {
   rescale,
   addRange as addMediaRange,
   commonTimescale,
-  scale,
   subtract,
   toSeconds,
   ZERO
@@ -120,7 +119,16 @@ export class RateTrend {
  */
 export function predictPlaybackReadiness(input = {}) {
   const now = Number.isFinite(input.now) ? input.now : Date.now();
-  const tracks = Array.isArray(input.tracks) ? input.tracks : [];
+  // WHAT IS BEHIND THE VIEWER IS NOT PLANNED AGAIN. The forecast runs on every
+  // progress poll of a waiting viewer, and it converted every piece of the film
+  // to exact time before dropping those already played: 5.1 s of the proxy's
+  // main thread at once after a seek back on Home Assistant, every second of
+  // which FFmpeg's input and the page's pieces waited (torrent-tv/meta#178).
+  // 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).
+  const tracks = (Array.isArray(input.tracks) ? input.tracks : []).map((track) =>
+    Array.isArray(track.segments) ? { ...track, segments: piecesThatMatter(track, finiteNonNegative(input.positionSeconds)) } : 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`).
@@ -138,13 +146,13 @@ export function predictPlaybackReadiness(input = {}) {
     ...reported.flatMap((ranges) => (ranges ?? []).flatMap(({ start, end }) => [start, end])),
     ...tracks.flatMap((track) => (Array.isArray(track.segments) ? track.segments : []).flatMap((segment) => [
       ...(segment.mediaRanges?.timescale ? [mediaTime(0n, segment.mediaRanges.timescale)] : []),
-      ...[segment.startSeconds, segment.endSeconds].filter(Number.isFinite).map(fromSeconds)
+      ...exactBoundsOf(segment)
     ]))
   ]);
   const zero = mediaTime(0n, unit);
   const segmentsOf = tracks.map((track, trackIndex) => predictedMediaSegments(
     (Array.isArray(track.segments) ? track.segments : []).map((segment) => ({
-      ...segment, ranges: playerRanges(segment.mediaRanges, rescale(clocks[trackIndex], unit), unit)
+      ...segment, exact: exactTimesOf(segment), ranges: playerRanges(segment.mediaRanges, rescale(clocks[trackIndex], unit), unit)
     })), unit));
   const origin = latest(zero, ...segmentsOf.map((segments) =>
     segments.find(({ index }) => index === 0)?.ranges?.[0]?.start ?? zero));
@@ -362,11 +370,15 @@ export function predictPlaybackReadiness(input = {}) {
           const stillMissing = uncoveredIntervals(pieceRange, sourceByteCoverage.get(sourceId) ?? []);
           for (const part of stillMissing) {
             finish = rate.finish(part.end - part.start, finish);
-            service.push({ start: part.start, end: part.end, begin: finish, finish });
+            const arrival = { start: part.start, end: part.end, begin: finish, finish };
+            service.push(arrival);
             sourceArrivalAt = Math.max(sourceArrivalAt, finish);
+            // Joined in place, as the whole list would join: pieces arrive in
+            // media order, so each one extends the end. Sorting the whole list
+            // again after every piece was most of the forecast's time.
+            sourceByteCoverage.set(sourceId, withCoverage(sourceByteCoverage.get(sourceId) ?? [], arrival));
+            sourceArrivals.set(sourceId, withArrival(sourceArrivals.get(sourceId) ?? [], arrival, service));
           }
-          sourceByteCoverage.set(sourceId, numericCoverage(service));
-          sourceArrivals.set(sourceId, indexedArrivals(service));
         }
         sourceService.finish = finish;
       }
@@ -384,6 +396,16 @@ export function predictPlaybackReadiness(input = {}) {
   }
 
   const constraints = [];
+  // WHICH CONSTRAINT HOLDS THE START, said with the answer: the delay is the
+  // largest of thousands, and the log could only say that some term was
+  // positive while the picture stood for 17 s (torrent-tv/meta#178).
+  let holding = null;
+  const constrain = (value, kind, trackIndex, segment, atSeconds, aheadSeconds, requiresSource) => {
+    constraints.push(value);
+    if (value > 0 && (holding === null || value > holding.value)) {
+      holding = { value, kind, trackIndex, segment, atSeconds, aheadSeconds, requiresSource };
+    }
+  };
   const end = rescale(fromSeconds(duration), unit);
   for (let trackIndex = 0; trackIndex < trackState.length; trackIndex += 1) {
     const state = trackState[trackIndex];
@@ -395,7 +417,8 @@ export function predictPlaybackReadiness(input = {}) {
       const before = contiguousEnd(delivered, at);
       for (const range of completion.segment.ranges) addMediaRange(delivered, range);
       const after = contiguousEnd(delivered, at);
-      constraints.push(completion.at - secondsAhead(earliest(before, trackEnd), at));
+      const ahead = secondsAhead(earliest(before, trackEnd), at);
+      constrain(completion.at - ahead, "delivery", trackIndex, completion.segment.index, completion.at, ahead, false);
       if (compare(after, before) <= 0 && completion.segment.ranges.some(({ start }) => compare(start, before) > 0)) {
         // A timestamp hole cannot be repaired by waiting longer. Keep it
         // distinct from an unavailable rate or a slow but finite service.
@@ -413,8 +436,10 @@ 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.
-      constraints.push(production.at - Math.max(0, secondsAhead(before, at) -
-        Math.min(reserve, secondsAhead(trackEnd, before)) * Number(production.requiresSource)));
+      const ahead = Math.max(0, secondsAhead(before, at) -
+        Math.min(reserve, secondsAhead(trackEnd, before)) * Number(production.requiresSource));
+      constrain(production.at - ahead, "production", trackIndex, production.segment.index, production.at, ahead,
+        production.requiresSource);
     }
   }
   const delay = Math.max(0, ...constraints);
@@ -424,6 +449,13 @@ export function predictPlaybackReadiness(input = {}) {
     Math.max(0, reserve - buffered), ready ? 'trajectory-safe-now' :
       Number.isFinite(delay) ? 'minimum-safe-delay' : 'service-not-advancing', preparedSegments);
   return { ...forecast, measuredAt: now, predictedStartAt: Number.isFinite(delay) ? now + delay * 1000 : null,
+    // The piece whose `kind` — its production, or its delivery to the page —
+    // comes `atSeconds` from now while the media before it lasts
+    // `aheadSeconds`: the difference is the delay.
+    holdingBy: ready ? null : holding === null ? (originReady ? null : { kind: "position-not-held" })
+      : { kind: holding.kind, track: tracks[holding.trackIndex]?.id ?? holding.trackIndex,
+        segment: holding.segment, atSeconds: holding.atSeconds, aheadSeconds: holding.aheadSeconds,
+        requiresSource: holding.requiresSource },
     preparedUntilSeconds: Math.min(duration, ...trackState.map((state, index) => {
       const ranges = state.clientRanges.map((range) => ({ ...range }));
       for (const item of productions.filter((item) => item.trackIndex === index && item.at <= delay)) {
@@ -534,6 +566,95 @@ function heldRanges(ranges, segments, unit, position) {
   return held;
 }
 
+/**
+ * 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.
+ *
+ * @param {{ segments: object[], readySegmentIndices?: number[] }} track
+ * @param {number} position - Seconds.
+ * @returns {object[]}
+ */
+function piecesThatMatter(track, position) {
+  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));
+  return kept.length === track.segments.length ? track.segments : kept;
+}
+
+/**
+ * The exact times of a piece's playlist edges, converted once per piece and
+ * kept with it: the playlist's cut times do not change between polls, and
+ * converting them again on every one was a fifth of the forecast's time.
+ *
+ * @type {WeakMap<object, { startSeconds: number, endSeconds: number, start: import("./media-time.js").MediaTime | null, end: import("./media-time.js").MediaTime | null }>}
+ */
+const exactBounds = new WeakMap();
+
+function exactTimesOf(segment) {
+  let bounds = exactBounds.get(segment);
+  if (!bounds || bounds.startSeconds !== segment.startSeconds || bounds.endSeconds !== segment.endSeconds) {
+    bounds = {
+      startSeconds: segment.startSeconds,
+      endSeconds: segment.endSeconds,
+      start: Number.isFinite(segment.startSeconds) ? fromSeconds(segment.startSeconds) : null,
+      end: Number.isFinite(segment.endSeconds) ? fromSeconds(segment.endSeconds) : null
+    };
+    exactBounds.set(segment, bounds);
+  }
+  return bounds;
+}
+
+/** The exact edges a piece carries from the forecast, or converts once. */
+function timesOf(segment) {
+  return segment.exact ?? exactTimesOf(segment);
+}
+
+/** @returns {import("./media-time.js").MediaTime[]} The finite playlist edges of a piece, exactly. */
+function exactBoundsOf(segment) {
+  const { start, end } = exactTimesOf(segment);
+  return [start, end].filter(Boolean);
+}
+
+/**
+ * `coverage` (sorted, joined; this forecast's own list) with `range` added in
+ * place, as `numericCoverage` of the whole list would give it: found by halves,
+ * joined with every neighbour it reaches or touches. Bytes held further on —
+ * a piece of the file read for another viewer — sit after the place pieces are
+ * added in media order, so adding only at the end did not hold.
+ */
+function withCoverage(coverage, range) {
+  let low = 0, high = coverage.length;
+  while (low < high) {
+    const middle = (low + high) >>> 1;
+    if (coverage[middle].end < range.start) low = middle + 1;
+    else high = middle;
+  }
+  const joined = { start: range.start, end: range.end };
+  let last = low;
+  while (last < coverage.length && coverage[last].start <= joined.end) {
+    joined.start = Math.min(joined.start, coverage[last].start);
+    joined.end = Math.max(joined.end, coverage[last].end);
+    last += 1;
+  }
+  coverage.splice(low, last - low, joined);
+  return coverage;
+}
+
+/** `arrivals` (this forecast's own list) with `range` indexed, as `indexedArrivals` of the whole list would give it. */
+function withArrival(arrivals, range, all) {
+  if (!(range.finish > 0)) return arrivals;
+  const last = arrivals.at(-1);
+  if (!last || range.start > last.start || (range.start === last.start && range.end >= last.end)) {
+    arrivals.push({ ...range, maximumEnd: Math.max(last?.maximumEnd ?? 0, range.end) });
+    return arrivals;
+  }
+  return indexedArrivals(all);
+}
+
 /** Coverage is joined once per resource, independently of arrival times. */
 function numericCoverage(ranges) {
   const joined = [];
@@ -614,30 +735,58 @@ function sourcePiecesFor(ranges, source) {
  */
 function predictedMediaSegments(segments, unit) {
   const zero = mediaTime(0n, unit);
-  const anchors = segments.filter(({ ranges }) => ranges?.length > 0);
+  // In order of index, searched by halves: each unread piece looked through
+  // every read one for its neighbours, a cost of pieces times read pieces.
+  const anchors = segments.filter(({ ranges }) => ranges?.length > 0)
+    .sort((left, right) => left.index - right.index);
+  const firstAfter = (index) => {
+    let low = 0, high = anchors.length;
+    while (low < high) {
+      const middle = (low + high) >>> 1;
+      if (anchors[middle].index <= index) low = middle + 1;
+      else high = middle;
+    }
+    return low;
+  };
   return segments.map((segment) => {
     if (segment.ranges !== undefined) return segment;
+    const times = timesOf(segment);
     if (anchors.length === 0) {
-      return { ...segment, ranges: [{ start: rescale(fromSeconds(segment.startSeconds), unit),
-        end: rescale(fromSeconds(segment.endSeconds), unit), frame: zero }] };
+      return { ...segment, ranges: [{ start: rescale(times.start, unit), end: rescale(times.end, unit), frame: zero }] };
     }
-    const previous = anchors.findLast(({ index }) => index < segment.index);
-    const next = anchors.find(({ index }) => index > segment.index);
-    const nominalLeft = fromSeconds(previous?.endSeconds ?? next.startSeconds);
+    const after = firstAfter(segment.index);
+    let before = after - 1;
+    while (before >= 0 && anchors[before].index >= segment.index) before -= 1;
+    const previous = before >= 0 ? anchors[before] : undefined;
+    const next = anchors[after];
+    const nominalLeft = previous ? timesOf(previous).end : timesOf(next).start;
     const actualLeft = previous?.ranges.at(-1).end ?? next.ranges[0].start;
-    const nominalRight = next ? fromSeconds(next.startSeconds) : nominalLeft;
+    const nominalRight = next ? timesOf(next).start : nominalLeft;
     const actualRight = next?.ranges[0].start ?? actualLeft;
     const nominalSpan = subtract(nominalRight, nominalLeft);
-    const place = (seconds) => {
-      const fromLeft = subtract(fromSeconds(seconds), nominalLeft);
-      return nearest(add(actualLeft, nominalSpan.ticks > 0n
-        ? scale(fromLeft, subtract(actualRight, actualLeft), nominalSpan)
-        : fromLeft), unit);
+    // `nearest(actualLeft + fromLeft * (actualRight - actualLeft) / nominalSpan)`
+    // in ticks of `unit`, as one fraction: both actual edges are already whole
+    // ticks of it, so only the scaled part is rounded, and no common
+    // denominator is sought for every piece (most of the forecast's time).
+    const actualSpan = actualRight.ticks - actualLeft.ticks;
+    const place = (time) => {
+      const fromLeft = subtract(time, nominalLeft);
+      const [numerator, denominator] = nominalSpan.ticks > 0n
+        ? [fromLeft.ticks * nominalSpan.timescale * actualSpan, fromLeft.timescale * nominalSpan.ticks]
+        : [fromLeft.ticks * unit, fromLeft.timescale];
+      return { ticks: actualLeft.ticks + roundedHalfUp(numerator, denominator), timescale: unit };
     };
-    return { ...segment, ranges: [{ start: place(segment.startSeconds), end: place(segment.endSeconds), frame: zero }] };
+    return { ...segment, ranges: [{ start: place(times.start), end: place(times.end), frame: zero }] };
   });
 }
 
+/** `numerator / denominator` to the nearest whole number, halves up, as `nearest` rounds; `denominator` positive. */
+function roundedHalfUp(numerator, denominator) {
+  const quotient = numerator / denominator;
+  const floor = numerator - quotient * denominator < 0n ? quotient - 1n : quotient;
+  return 2n * (numerator - floor * denominator) >= denominator ? floor + 1n : floor;
+}
+
 function rateCurve(readings, now) {
   if (readings && Number.isFinite(readings.count) && readings.count > 0 &&
     Number.isFinite(readings.lastAt) && Number.isFinite(readings.lastValue) &&