@torrent-tv/proxy 2.97.15 → 2.97.17

package/package.json

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

package/routes/api/transcode-sessions/net-report/post.js

@@ -19,14 +19,15 @@ import { recordViewerReport } from "../../../../services/viewer/report-intake.js
  *
  * @param {import("fastify").FastifyRequest} req
  * @param {import("fastify").FastifyReply} reply
- * @param {{ outputs: { get: (id: string) => object | undefined }, viewers: object, renditions: { viewerPlays: Function, noteViewerReported: Function }, quality: { noteViewerReported: Function } }} deps -
+ * @param {{ outputs: { get: (id: string) => object | undefined }, viewers: object, renditions: { viewerPlays: Function, noteViewerReported: Function }, quality: { noteViewerReported: Function }, planSoon?: () => void, segmentAt?: (output: object, seconds: number) => number | null }} deps -
  *   The live outputs, the registry of viewers, and the rungs of a picture. The
  *   VIEWER component takes the statement; which rung a stated height is, is the
  *   encoding component's. This route's whole job is turning a request into
  *   those calls and their answer into a status code.
  * @returns {Promise<void>}
  */
-export async function handleApiTranscodeSessionNetReportPost(req, reply, { outputs, viewers, renditions, quality }) {
+export async function handleApiTranscodeSessionNetReportPost(req, reply,
+  { outputs, viewers, renditions, quality, planSoon = () => {}, segmentAt = () => null }) {
   const sessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
   const body = req.body && typeof req.body === "object" && !Array.isArray(req.body) ? req.body : {};
   // WHAT THIS REPORT IS. A statement by one viewer about itself: where the
@@ -100,6 +101,10 @@ export async function handleApiTranscodeSessionNetReportPost(req, reply, { outpu
       Number.isFinite(positionSeconds) && positionSeconds >= 0 ? positionSeconds : undefined
     );
   }
+  // Where they stood and whether they were playing or waiting, before this
+  // report: what the encoders are planned from (`movedForThePlan`).
+  const before = viewers.get?.(consumerId);
+  const was = before ? { seconds: before.position?.seconds ?? null, playing: before.playing, waiting: before.waiting } : null;
   const recorded = recordViewerReport({
     outputs,
     viewers,
@@ -127,6 +132,14 @@ export async function handleApiTranscodeSessionNetReportPost(req, reply, { outpu
   if (!recorded) {
     return reply.code(404).send({ error: "Transcode session was not found." });
   }
+  // A VIEWER WHO MOVED INTO ANOTHER PIECE, or started or stopped playing or
+  // waiting, changed the maps the encoders are placed from; the plan is taken
+  // again now. Recorded and not re-planned, a soundtrack the viewer was
+  // stopped for waited 59 s behind a picture that had long left the urgent
+  // band, because only the end of that picture's run planned again (Home
+  // Assistant 2026-10-12, torrent-tv/meta#178).
+  const after = viewers.get?.(consumerId);
+  if (after && movedForThePlan(was, after, outputs.get(sessionId), segmentAt)) planSoon();
   // After the statement is recorded, so what is judged is what they just said:
   // a move of theirs to another limit may no longer be wanted.
   renditions.noteViewerReported(sessionId, consumerId);
@@ -136,3 +149,23 @@ export async function handleApiTranscodeSessionNetReportPost(req, reply, { outpu
   void quality.noteViewerReported(sessionId, consumerId);
   return reply.code(204).send();
 }
+
+/**
+ * Whether a report changed what the encoders are planned from: the piece the
+ * viewer stands in, or whether they play or wait.
+ *
+ * @param {{ seconds: number | null, playing: boolean, waiting: boolean } | null} was
+ * @param {{ position?: { seconds: number } | null, playing: boolean, waiting: boolean }} now
+ * @param {object | undefined} output
+ * @param {(output: object, seconds: number) => number | null} segmentAt
+ * @returns {boolean}
+ */
+export function movedForThePlan(was, now, output, segmentAt) {
+  if (!was) return true;
+  if (was.playing !== now.playing || was.waiting !== now.waiting) return true;
+  const seconds = now.position?.seconds;
+  if (!Number.isFinite(seconds)) return false;
+  if (!Number.isFinite(was.seconds)) return true;
+  if (!output) return false;
+  return segmentAt(output, was.seconds) !== segmentAt(output, seconds);
+}

package/server.js

@@ -524,6 +524,14 @@ 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 [];
         // WHAT A SEGMENT READS IS WORKED OUT ONCE, not on every publication: its
@@ -547,6 +555,7 @@ export async function startProxyServer({
         // were never asked for (Home Assistant 2026-10-08, torrent-tv/meta#151).
         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).
@@ -559,9 +568,15 @@ export async function startProxyServer({
               value = new SegmentInputs({ index, tracks: wanted }).forInterval({ ...interval, mode: track => modes.get(track) });
             }
           } catch { value = null; }
+          // A zone worked out gives the thread back before the next: worked out
+          // in one stretch, the first pass over a film's 4000 zones held the main
+          // thread 5-7 s while FFmpeg's first open waited for its answers. What
+          // was worked out is kept, so a pass a newer map ends is not lost
+          // (torrent-tv/meta#178).
+          if (value?.kind === "result") segmentSourceRanges.set(rangesKey, value.ranges);
+          await new Promise(resolve => setImmediate(resolve));
           if (!map.isCurrent()) return [];
           if (value?.kind === "result") {
-            segmentSourceRanges.set(rangesKey, value.ranges);
             convert(value.ranges);
             continue;
           }
@@ -572,10 +587,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;
@@ -599,7 +618,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 }) => {
@@ -1288,7 +1307,12 @@ export async function startProxyServer({
       outputs: outputParts.outputs,
       viewers: outputParts.viewers,
       renditions: outputParts.renditions,
-      quality: outputParts.quality
+      quality: outputParts.quality,
+      planSoon: () => outputParts.encodeRuns.planEncodersSoon(),
+      segmentAt: (output, seconds) => {
+        // A cut table not built yet has no pieces to move between.
+        try { return outputParts.outputTimes.segmentIndexForTime(output, seconds); } catch { return null; }
+      }
     })
   );
   app.post("/api/transcode-sessions/:sessionId/fragment-far", async (req, reply) =>

package/services/encode/EncodeOrchestrator.js

@@ -130,6 +130,17 @@ export class EncodeOrchestrator {
    * @type {{ urgent: boolean, priority: number, address: string, index: number } | null}
    */
   #leading = null;
+  /**
+   * Outputs whose start the last plan held back behind a more urgent encoder,
+   * and the band of the number it would have started at. Looked at again
+   * whenever that encoder moves on (`shareTheMachine`), because a closed piece
+   * is what lowers its band: placed only by a full plan, a soundtrack the
+   * viewer was stopped for waited 59 s behind a picture that had long left
+   * the urgent band (Home Assistant 2026-10-12, torrent-tv/meta#178).
+   *
+   * @type {Map<string, { urgent: boolean, priority: number }>}
+   */
+  #heldBack = new Map();
 
   /** What a stop and a start have cost on this host. */
   #costs = new RunCosts();
@@ -689,7 +700,10 @@ export class EncodeOrchestrator {
   shareTheMachine() {
     const leading = this.#leadingBand();
     this.#leading = leading;
-    if (!leading) return;
+    if (!leading) {
+      this.#placeHeldBack(null);
+      return;
+    }
     for (const [address, runs] of this.#runs) {
       for (const run of runs) {
         if (!run.isAlive || run.isStopping || typeof run.pause !== "function") continue;
@@ -702,6 +716,22 @@ export class EncodeOrchestrator {
         }
       }
     }
+    this.#placeHeldBack(leading);
+  }
+
+  /**
+   * Plan again every output whose start was held back behind what is no
+   * longer more urgent than it: the start is placed now, by the same plan,
+   * rather than at whatever event next re-plans everything.
+   *
+   * @param {{ urgent: boolean, priority: number } | null} leading
+   */
+  #placeHeldBack(leading) {
+    for (const [address, band] of [...this.#heldBack]) {
+      if (leading && compareUrgency(band, leading) > 0) continue;
+      this.#heldBack.delete(address);
+      this.#reconcileOne(address);
+    }
   }
 
   /**
@@ -916,6 +946,8 @@ export class EncodeOrchestrator {
     // a 159 090-line file, 31 % of the log, all of one wedge.
     const wanting = firstUnmetWant(coverage, windows);
     const stillRunning = this.runsOn(address).filter((run) => run.isAlive);
+    if (heldBack) this.#heldBack.set(address, this.#bandAt(address, heldBack.from));
+    else this.#heldBack.delete(address);
     if (wanting === null || stillRunning.length > 0) {
       this.#lastUnmet.delete(address);
     } else if (heldBack) {

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

@@ -404,8 +404,19 @@ export class AviContainer extends Container {
           packets.append(track.trackNumber, { pts: stream.times[previous], duration: Math.max(0, end - stream.times[previous]),
             keyframe: true, ranges: [[stream.starts[previous], stream.starts[previous] + stream.lengths[previous] - 1]] });
         };
+        // THE THREAD IS GIVEN BACK at each portion of the file the table
+        // reaches: a two-hour soundtrack is some 300 000 packets, and built in
+        // one stretch it held the main thread with the map's first pass for
+        // 5-7 s while FFmpeg's first open waited for its answers
+        // (torrent-tv/meta#178).
+        let portion = -1;
         for (let at = 0; at < stream.count; at++) {
           if (!stream.lengths[at]) continue;
+          const reached = Math.floor(stream.starts[at] / this.portionBytes);
+          if (Number.isFinite(reached) && reached !== portion) {
+            if (portion >= 0) await new Promise(resolve => setImmediate(resolve));
+            portion = reached;
+          }
           if (previous >= 0) append(stream.times[at]);
           previous = at;
         }

package/services/server/ViewerRequests.js

@@ -646,6 +646,14 @@ export class ViewerRequests {
         processingRanges: liveRuns.map(({ progress }) => ({
           start: progress.startPositionSeconds, end: progress.processedSeconds
         })),
+        // What a run's start costs this output, and the stretches its live
+        // runs were given: the forecast starts a run wherever production meets
+        // bytes that were not held when the run before was admitted.
+        openSeconds: this.#host.openSecondsOf?.(output) ?? null,
+        runSpans: liveRuns.map(run => ({
+          start: output.timeline?.publishedStartOf?.(run.from),
+          end: Number.isInteger(run.to) && run.to >= run.from ? output.timeline?.publishedStartOf?.(run.to + 1) : Number.POSITIVE_INFINITY
+        })),
         bitsPerMediaSecond: Number.isFinite(observedMbps) && observedMbps > 0 ? observedMbps * 1_000_000 :
           this.#host.initialOutputBitsPerMediaSecondOf?.(output) ?? 0,
         readings: trackRates,
@@ -705,7 +713,8 @@ export class ViewerRequests {
     const forecast = withSubtitleReadiness(this.#host.playbackReadiness.predict(input), subtitle,
       subtitle ? this.#host.subtitleReadyFor?.(viewer) !== false : true);
     forecast.operations = outputs.flatMap((output, index) => {
-      const common = { speed: this.#host.playbackReadiness.forecastRate(tracks[index].readings), processedSeconds: tracks[index].processedSeconds };
+      const common = { speed: this.#host.playbackReadiness.forecastRate(tracks[index].readings, now, 0, "piece"),
+        processedSeconds: tracks[index].processedSeconds };
       return [
         ...(output.spec.video ? [{ ...common, track: "video",
           operation: output.spec.transcodesVideo ? "encode" : "copy",
@@ -738,9 +747,49 @@ 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
@@ -815,10 +864,17 @@ export class ViewerRequests {
     const reading = this.#host.encodeSpeedReadingOf?.(output, now) ?? null;
     if (Number.isFinite(reading?.speed) && reading.speed > 0 && Number.isFinite(reading.at)) {
       trend.add(reading.at, reading.speed);
-    } else {
-      const projected = Number(this.#host.projectedEncodeSpeedOf?.(output));
+    } else if (!trend.snapshot()) {
+      // ONLY UNTIL A PIECE IS MEASURED does the prediction stand for the
+      // encoder, and it is not kept among the readings. Added on every poll
+      // between runs, it put the machine's share of that moment — 1 % at a
+      // cold start — on the whole film, and the forecast read 0.03x
+      // (torrent-tv/meta#178).
+      const projected = Number(this.#host.predictedEncodeSpeedOf?.(output) ?? this.#host.projectedEncodeSpeedOf?.(output));
       if (Number.isFinite(projected) && projected > 0) {
-        trend.add(now, projected);
+        const seed = new this.#host.playbackReadiness.RateTrend();
+        seed.add(now, projected);
+        return seed.snapshot();
       }
     }
     return trend.snapshot();

package/services/server/wire-outputs.js

@@ -579,13 +579,16 @@ export function wireOutputs({
     sourceInputsFor: (output, index) => parts.sourceInputsFor?.(output, index),
     encodeSpeedReadingOf: (output) => parts.encodeCost.latestSpeedReadingOf(output),
     projectedEncodeSpeedOf: (output) => parts.encodeCost.projectedSpeedOf(output),
+    // The speed the offer predicted for this output when it chose its mode: a
+    // forecast with no measured piece yet stands on it rather than on the
+    // machine's share of the moment (torrent-tv/meta#178).
+    predictedEncodeSpeedOf: (output) => {
+      const predicted = Number(qualityStateOf(output).predictedSpeedWhenOffered);
+      return Number.isFinite(predicted) && predicted > 0 ? predicted : null;
+    },
     audioDescriptionOf,
-    processingStartupSecondsOf: (output) => output.spec.carries === "audio-only" ?
-      audioReadingFor(audioCalibration, { ...audioDescriptionOf(output),
-        codec: audioDescriptionOf(output)?.codec ?? output.file.media?.audioCodec,
-        transcode: output.spec.audio?.transcode })?.startupSeconds ?? 0 :
-      Math.max(0, (startStopCost?.firstByteWaitSec ?? 0) - parts.segmentDurationSec /
-        parts.encodeCost.projectedSpeedOf(output)),
+    openSecondsOf: (output) => runStartSecondsOf(output),
+    processingStartupSecondsOf: (output) => runStartSecondsOf(output),
     initialOutputBitsPerMediaSecondOf: (output) => {
       const description = audioDescriptionOf(output);
       const reference = audioReadingFor(audioCalibration, { codec: description?.codec, transcode: false });
@@ -1008,7 +1011,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).
@@ -1045,6 +1048,27 @@ export function wireOutputs({
     readFree: freeBytesFor,
     logger
   });
+  /**
+   * What starting a run costs this output before its first piece is encoded:
+   * its own measured open where it has one (`RunCosts.openOf`), else the
+   * host's startup reading of spawn to first piece less that piece's encoding;
+   * for sound, its packaged startup reading.
+   *
+   * @param {object} output
+   * @returns {number}
+   */
+  function runStartSecondsOf(output) {
+    if (output.spec.carries === "audio-only") {
+      return audioReadingFor(audioCalibration, { ...audioDescriptionOf(output),
+        codec: audioDescriptionOf(output)?.codec ?? output.file.media?.audioCodec,
+        transcode: output.spec.audio?.transcode })?.startupSeconds ?? 0;
+    }
+    const open = parts.encodeOrchestrator?.openOf?.(output.outputKey ?? "");
+    if (open?.measured) return open.seconds;
+    return Math.max(0, (startStopCost?.firstByteWaitSec ?? 0) - parts.segmentDurationSec /
+      parts.encodeCost.projectedSpeedOf(output));
+  }
+
   // Realtime-budget monitor: only meaningful for the software encoder with a
   // benchmark (the only path that can pick/step resolution). Cheap no-op scan
   // otherwise.

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/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

@@ -2,9 +2,11 @@ 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).
+ * 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);
 
@@ -225,8 +227,8 @@ export async function readHeldRanges(torrent, fileIndex, ranges, maxBytes, logge
     // 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
+    // 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;

package/services/viewer/playback-readiness.js

@@ -49,8 +49,8 @@ const CLIENT_RANGE_START_TOLERANCE_SECONDS = 0.25;
  * @param {number} horizonSeconds
  * @returns {number | null}
  */
-export function forecastRate(readings, now = Date.now(), horizonSeconds = 0) {
-  const curve = rateCurve(readings, now);
+export function forecastRate(readings, now = Date.now(), horizonSeconds = 0, weighting = "last") {
+  const curve = rateCurve(readings, now, weighting);
   if (!curve) {
     return null;
   }
@@ -192,7 +192,12 @@ export function predictPlaybackReadiness(input = {}) {
       [{ start: at, end: add(at, measured ? nearest(fromSeconds(buffered), unit) :
         rescale(fromSeconds(buffered), unit)), frame: zero }],
     ready: new Set(Array.isArray(track.readySegmentIndices) ? track.readySegmentIndices : []),
-    curve: rateCurve(track.readings, now),
+    // Film made over the encoder's working time, over the readings the trend
+    // keeps: one reading is one closed piece, so the harmonic mean is that
+    // ratio. The last reading alone is one piece's content and machine — a
+    // first piece of credits read 6.49x and started a cold AVI on 2.4 s of
+    // buffer that the next piece, at 0.57x, did not hold (torrent-tv/meta#178).
+    curve: rateCurve(track.readings, now, "piece"),
     bitsPerMediaSecond: averageBitsPerMediaSecond(track, track.segments,
       new Set(Array.isArray(track.readySegmentIndices) ? track.readySegmentIndices : [])),
     segments: segmentsOf[trackIndex]
@@ -211,7 +216,10 @@ export function predictPlaybackReadiness(input = {}) {
     const serviceKey = typeof source.serviceKey === "string" ? source.serviceKey : id;
     let service = sourceServices.get(serviceKey);
     if (!service) {
-      service = { rate: rateCurve(source.downloadRateReadings, now), finish: 0 };
+      // Bytes over time across the readings the trend keeps: the last 5 s of a
+      // swarm moved between 0.97 and 5.8 MB/s and was carried to the end of the
+      // film each time (torrent-tv/meta#178).
+      service = { rate: rateCurve(source.downloadRateReadings, now, "time"), finish: 0 };
       sourceServices.set(serviceKey, service);
     }
     sourceState.set(id, { source, service });
@@ -330,6 +338,22 @@ export function predictPlaybackReadiness(input = {}) {
     }
   }
   const trackFinish = trackState.map(({ track }) => finiteNonNegative(track.startupRemainingSeconds));
+  // WHERE A RUN STARTS, AND WHAT IT COSTS. A run is given the stretch whose
+  // bytes are held when its input is admitted, and the next one starts after
+  // it, when more bytes are held, and opens its input first — 6-10 s on an
+  // OpenDML AVI. Charged once at the first start only, a cold AVI made of runs
+  // of one to five pieces was forecast as one run (torrent-tv/meta#178). So a
+  // piece outside the live runs' stretches whose bytes arrive after the run
+  // the schedule last started was admitted begins a run of its own, admitted
+  // when the piece before it is made and its bytes are held, then opened.
+  // The first run's start is `startupRemainingSeconds`, charged once above; a
+  // stretch's bound by memory and by its copy time is not modelled.
+  const runStarts = trackState.map(({ track }) => ({
+    openSeconds: finiteNonNegative(track.openSeconds),
+    spans: (Array.isArray(track.runSpans) ? track.runSpans : [])
+      .filter(span => Number.isFinite(span?.start) && span.end > span.start),
+    admittedAt: finiteNonNegative(track.startupRemainingSeconds) > 0 ? 0 : null
+  }));
   const sourceByteCoverage = new Map([...sourceByteService].map(([id, ranges]) => [id, numericCoverage(ranges)]));
   const sourceArrivals = new Map([...sourceByteService].map(([id, ranges]) => [id, indexedArrivals(ranges)]));
   let transferFinish = 0;
@@ -386,7 +410,15 @@ export function predictPlaybackReadiness(input = {}) {
     // Production accepts a complete held segment input. It cannot overlap its
     // own source download; reused input retains its original arrival time.
     const processing = trackState[trackIndex].curve;
-    const admittedAt = Math.max(trackFinish[trackIndex], sourceArrivalAt);
+    let admittedAt = Math.max(trackFinish[trackIndex], sourceArrivalAt);
+    if (!job.produced && encodeWork > 0) {
+      const run = runStarts[trackIndex];
+      const live = run.spans.some(span => segment.startSeconds >= span.start && segment.startSeconds < span.end);
+      if (!live && (run.admittedAt === null || sourceArrivalAt > run.admittedAt)) {
+        run.admittedAt = admittedAt;
+        admittedAt += run.openSeconds;
+      }
+    }
     const producedAt = job.produced || encodeWork === 0 ? 0 : processing.finish(encodeWork, admittedAt);
     trackFinish[trackIndex] = Math.max(trackFinish[trackIndex], producedAt);
     productions.push({ at: producedAt, trackIndex, segment, requiresSource: sourceArrivalAt > 0 });
@@ -396,6 +428,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];
@@ -407,7 +449,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.
@@ -425,8 +468,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);
@@ -436,6 +481,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)) {
@@ -767,11 +819,19 @@ function roundedHalfUp(numerator, denominator) {
   return 2n * (numerator - floor * denominator) >= denominator ? floor + 1n : floor;
 }
 
-function rateCurve(readings, now) {
+/**
+ * @param {*} readings - A summary (`RateTrend.snapshot`) or the readings themselves.
+ * @param {number} now
+ * @param {"last" | "piece" | "time"} [weighting] - Which rate the readings
+ *   stand for: the last one; work per working time where each reading is one
+ *   piece of film; or quantity per wall time where each reading holds until
+ *   the next.
+ */
+function rateCurve(readings, now, weighting = "last") {
   if (readings && Number.isFinite(readings.count) && readings.count > 0 &&
     Number.isFinite(readings.lastAt) && Number.isFinite(readings.lastValue) &&
     Number.isFinite(readings.meanValue) && Number.isFinite(readings.spanSeconds)) {
-    return rateCurveFrom(readings, now);
+    return rateCurveFrom(readings, weighting);
   }
   const ordered = (Array.isArray(readings) ? readings : [])
     .filter((reading) => Number.isFinite(reading?.at) && Number.isFinite(reading?.value) && reading.value >= 0)
@@ -782,25 +842,38 @@ function rateCurve(readings, now) {
     return null;
   }
 
-  return rateCurveFrom(summarizeRate(ordered), now);
+  return rateCurveFrom(summarizeRate(ordered), weighting);
 }
 
 function summarizeRate(readings) {
   const latest = readings.at(-1);
+  let weighted = 0;
+  for (let index = 0; index + 1 < readings.length; index += 1) {
+    weighted += readings[index].value * (readings[index + 1].at - readings[index].at);
+  }
+  const spanMs = latest.at - readings[0].at;
   return {
     count: readings.length,
     lastAt: latest.at,
     lastValue: latest.value,
     meanValue: readings.reduce((sum, reading) => sum + reading.value, 0) / readings.length,
-    spanSeconds: (latest.at - readings[0].at) / 1000
+    // Each reading one piece of work: work over the time it took.
+    harmonicValue: readings.some(reading => !(reading.value > 0)) ? 0
+      : readings.length / readings.reduce((sum, reading) => sum + 1 / reading.value, 0),
+    // Each reading holding until the next: quantity over the span.
+    timeWeightedValue: spanMs > 0 ? weighted / spanMs : latest.value,
+    spanSeconds: spanMs / 1000
   };
 }
 
-function rateCurveFrom({ lastValue }) {
-  // Conditional projection of the current measured service. No exponential
+function rateCurveFrom(summary, weighting = "last") {
+  // Conditional projection of the measured service. No exponential
   // relaxation, smoothing time, slope extrapolation or guessed recovery.
   // A new measurement changes the integral; polling does not change its rate.
-  const rate = Math.max(0, lastValue);
+  const value = weighting === "piece" && Number.isFinite(summary.harmonicValue) ? summary.harmonicValue
+    : weighting === "time" && Number.isFinite(summary.timeWeightedValue) ? summary.timeWeightedValue
+      : summary.lastValue;
+  const rate = Math.max(0, value);
   const workBy = (seconds) => rate * Math.max(0, seconds);
   return {
     rateAt: () => rate,