@torrent-tv/proxy 2.97.13 → 2.97.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.97.13",
+  "version": "2.97.15",
   "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).
@@ -489,17 +526,18 @@ export async function startProxyServer({
         typeof container?.readSourceRanges === "function" ? container : null;
       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,7 +545,6 @@ 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 (direct) {

package/services/encode/EncodeInputs.js

@@ -461,6 +461,17 @@ export class EncodeInputs {
         if (this.#requests.get(request.key) !== request) return undefined;
       }
       const chosen = stretches.get(end);
+      // EVERY BYTE IS HERE BEFORE THE RUN IS ANSWERED. The stretch is copied
+      // after the answer (`OriginalInput.js`), so a stretch that is not all
+      // downloaded would start an encoder whose input then fails; checked here,
+      // it waits for the bytes as one read of everything used to. Field
+      // 2026-10-12: a cold MKV's first piece was answered, its stretch read
+      // found pieces missing, and the run was refused for good (torrent-tv/meta#178).
+      if (this.#heldRanges !== null && !await this.#present(chosen.sources, held, request.timing)) {
+        const [first] = chosen.sources;
+        return { kind: "needs-bytes", sourceKey: first.sourceKey, fileIndex: first.fileIndex, ranges: first.input.ranges };
+      }
+      if (this.#requests.get(request.key) !== request) return undefined;
       this.#wanted.set(request.key, { wanted: chosen.bytes, required: chosen.bytes });
       result = await admitOriginalInput({ sources: chosen.sources, readRanges: this.#read, now: this.#now,
         reserve: async bytes => this.#hold(request, bytes) });

package/services/encode/EncodeRuns.js

@@ -1088,7 +1088,10 @@ export class EncodeRuns {
       // torrent cannot tell them apart.
       lastSegmentIndex: () =>
         run.to,
-      inputUnavailable: (message) => isInputUnavailable(message),
+      // A stretch whose copy failed after the run started — a piece left the
+      // store between the check and the copy — is an input that went away, not
+      // a fault of the input: the plan asks for it again (torrent-tv/meta#178).
+      inputUnavailable: (message) => isInputUnavailable(message) || admittedInput?.copyFailed?.() === true,
       onProgress: (report) => this.#noteRunProgress(session, run, report),
       // A closed piece moves this encoder forward, perhaps out of the band that
       // led; who has the processor is decided again at once.
@@ -1370,7 +1373,8 @@ export class EncodeRuns {
     // been dead code — which is also why nothing ever stopped the restart loop
     // recorded in the field the same day.
     const wasCurrent = this.runsOf(session).includes(run);
-    const inputFailed = run.admittedInputKeys && failedAdmittedInput(ended,
+    // A stretch that could not be copied says nothing of the input itself.
+    const inputFailed = run.admittedInputKeys && run.originalInput?.copyFailed?.() !== true && failedAdmittedInput(ended,
       session.spec.transcodesVideo && this.#host.videoEncoder.kind !== "software");
     if (inputFailed) {
       const index = run.head;

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/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);
@@ -736,6 +741,55 @@ export class ViewerRequests {
     return forecast;
   }
 
+  /**
+   * 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

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/torrent/worker/held-bytes.js

@@ -1,5 +1,13 @@
 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`, four unless set). 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 +220,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`, four by
+    // default); 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 +256,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;
       }
@@ -534,6 +546,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 +715,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) &&