@torrent-tv/proxy 2.97.11 → 2.97.13

package/package.json

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

package/routes/encode-input/get.js

@@ -1,7 +1,7 @@
 import { parseRange } from "../../utils/parse-range.js";
 
 /** FFmpeg reads only original byte ranges already owned by its live run. */
-export function handleEncodeInputGet(req, reply, { inputOf, refused = () => {} }) {
+export async function handleEncodeInputGet(req, reply, { inputOf, refused = () => {} }) {
   const address = req.raw?.socket?.remoteAddress;
   if (!["127.0.0.1", "::1", "::ffff:127.0.0.1"].includes(address)) return reply.code(403).send();
   const token = Number(req.params.token), fileIndex = Number(req.params.fileIndex);
@@ -29,7 +29,15 @@ export function handleEncodeInputGet(req, reply, { inputOf, refused = () => {} }
   // and a byte past it is refused, which from 7.1 on ends the run: every read
   // FFmpeg makes, its stream search at open included, must be named by the
   // container (torrent-tv/meta#165).
-  const held = input.read(fileIndex, range.start, range.end, true);
+  // A read inside the stretch of film waits for its copy, which goes on while
+  // FFmpeg opens (`OriginalInput.js`); the answer is then whole, as any other.
+  const held = await input.read(fileIndex, range.start, range.end, true);
+  if (!held && input.copyFailed?.()) {
+    // The copy of the stretch failed: a piece left the store between the
+    // check that it was there and the copy. The run ends on this refusal, and
+    // the failure is said where the copy is accounted for (`EncodeInputs.js`).
+    return reply.code(503).send({ error: "Original input bytes could not be copied." });
+  }
   if (!held) {
     // FFmpeg asked for a byte the run was not given: the container named too
     // little. Said, because FFmpeg itself reports only a failed seek or read.

package/services/encode/EncodeInputs.js

@@ -187,6 +187,33 @@ export class EncodeInputs {
     this.#retryMemory();
   }
 
+  /**
+   * Withdraw what is being prepared or held for a start the plan no longer
+   * places: `starts` holds every start the last plan of this output placed or
+   * held back, and the number after each run it left alive. `retain` withdrew
+   * such a copy only once it was held, and only when a run was started; while
+   * it was being made it shared the torrent thread with the copy the viewer
+   * was waiting for. Field 2026-10-12: after a seek back, the next stretch of
+   * the run the seek had stopped went on being copied beside the one for the
+   * new position, 127.5 and 126.5 MB in 16 s each, and was withdrawn only once
+   * it was done (torrent-tv/meta#178).
+   *
+   * @param {object} output
+   * @param {Set<number>} starts
+   */
+  withdrawUnplaced(output, starts) {
+    for (const [key, request] of this.#requests) {
+      if (request.output !== output || request.result?.kind === "terminal" || starts.has(request.from)) continue;
+      this.#note(request, "withdrawn: the plan places no run there");
+      this.#requests.delete(key);
+      this.#wanted.delete(key);
+      // A copy already answered may still be copying its stretch; released,
+      // the stretch is dropped when its read returns.
+      request.result?.release?.();
+    }
+    this.#retryMemory();
+  }
+
   /**
    * The input of a run starting at `from`, once it is prepared.
    *
@@ -306,7 +333,9 @@ export class EncodeInputs {
       if (result.kind === "result" && result.to > request.to) result.to = Math.max(request.from, request.to);
       request.result = result;
       this.#note(request, result.kind === "result" ? `ready #${result.from}..#${result.to}, ${result.bytes ?? "?"} bytes` +
-        (Number.isFinite(result.copyMs) ? `, copied in ${result.copyMs}ms` : "")
+        (Number.isFinite(result.copyMs) ? (result.deferredBytes > 0
+          ? `, opening part copied in ${result.copyMs}ms, ${result.deferredBytes} bytes of the stretch copied while the run opens`
+          : `, copied in ${result.copyMs}ms`) : "")
         : `${result.kind}${result.reason ? ` ${result.reason}` : ""}${Number.isFinite(result.bytes) ? ` ${result.bytes} bytes` : ""}`,
       describeTiming(request.timing, this.#now()));
       if (result.kind === "result" || result.kind === "terminal") this.#changed(request.output, result);
@@ -444,7 +473,16 @@ export class EncodeInputs {
     if (result.kind === "needs-memory") this.#wanted.set(request.key, { wanted: minimum, required: minimum });
     if (result.kind === "result") {
       Object.assign(result, { from, to: end });
-      if (result.copyMs > 0) keep(this.#copyRates, result.bytes / result.copyMs);
+      // The stretch is copied after the answer, while the run opens; the rate
+      // is the whole copy's, learned once it is done.
+      const copied = result.whole ?? Promise.resolve(true);
+      void copied.then(whole => {
+        if (whole && result.copyMs > 0) keep(this.#copyRates, result.bytes / result.copyMs);
+        this.#log(`encode input #${from}..#${end} of ${addressOf(output)}: ` + (whole
+          ? `stretch copied, ${result.bytes} bytes in ${result.copyMs}ms of copying since it was admitted`
+          : result.copyFailed?.() ? "the stretch could not be copied: a piece it needs is no longer held"
+            : "released before its stretch was copied"));
+      });
     }
     return result;
   }

package/services/encode/EncodeOrchestrator.js

@@ -228,6 +228,7 @@ export class EncodeOrchestrator {
     segmentCoverage = null,
     planSoon = null,
     inputDemandChanged = null,
+    inputsUnplaced = null,
     describeWaits = null,
     admission = null,
     logger,
@@ -264,6 +265,9 @@ export class EncodeOrchestrator {
     // loop that calls it. Absent in a test, where the clock is the test's own.
     this.planSoon = typeof planSoon === "function" ? planSoon : () => undefined;
     this.inputDemandChanged = typeof inputDemandChanged === "function" ? inputDemandChanged : () => undefined;
+    // Told, after each plan of an output, where that plan places runs and
+    // where the runs it kept end, so inputs prepared for anywhere else go back.
+    this.inputsUnplaced = typeof inputsUnplaced === "function" ? inputsUnplaced : () => undefined;
   }
 
   /**
@@ -882,6 +886,20 @@ export class EncodeOrchestrator {
       coverage.claim(action.run, action.from, endOfRun({ from: action.from, to: action.to }));
     }
 
+    // AN INPUT IS PREPARED ONLY FOR A START THIS PLAN PLACES: one it starts or
+    // holds back (a copied picture's input may begin one number earlier), or
+    // the number after a run it left alive, whose next stretch is copied while
+    // it works. Any other copy shares the torrent thread with the one a viewer
+    // waits for (torrent-tv/meta#178).
+    const starts = new Set();
+    for (const action of actions) {
+      if (action.type !== "start" && action.type !== "move") continue;
+      starts.add(action.from);
+      starts.add(action.from - 1);
+    }
+    for (const run of this.runsOn(address)) if (run.isAlive) starts.add(run.to + 1);
+    this.inputsUnplaced(address, starts);
+
     // NOBODY IS MAKING WHAT SOMEBODY IS WAITING FOR. Said here, with the numbers
     // the decision was taken from, because it is the one state in which a viewer
     // waits for ever and every line above it reads as a healthy proxy.

package/services/encode/EncodeRuns.js

@@ -1178,7 +1178,16 @@ export class EncodeRuns {
       // 48.9 s after run #1..#32 ended, then the start of #33..#892, and the
       // viewer stood 69 s (torrent-tv/meta#166). Asked now, it is copied while
       // this run works and is ready when the plan places the next run there.
-      if (inputEnd < mayReach) this.#host.encodeInputs?.take(session, inputEnd + 1, mayReach);
+      // It waits for this run's own stretch to be copied: that copy goes on
+      // while the run opens and FFmpeg's reads wait for it, and a second copy
+      // beside it on the same thread would slow it (torrent-tv/meta#178).
+      if (inputEnd < mayReach) {
+        const askNext = () => {
+          if (this.isLive(session) && run.isAlive) this.#host.encodeInputs?.take(session, inputEnd + 1, mayReach);
+        };
+        if (admittedInput.whole) void admittedInput.whole.then(whole => { if (whole) askNext(); });
+        else askNext();
+      }
     } else if (admittedInput) {
       run.admittedInputKeys = new Map([[safeIndex, inputKey]]);
       let nextIndex = startIndex + 1;
@@ -1252,10 +1261,14 @@ export class EncodeRuns {
     const pieceSeconds = Number(grid?.[run.from + 1]) - Number(grid?.[run.from]);
     const speed = run.speedX > 0 ? run.speedX : this.#host.encodeOrchestrator.speedOn?.(session.outputKey) ?? 0;
     if (!Number.isFinite(ended.firstNamedMs) || !(pieceSeconds > 0) || !(speed > 0)) return;
-    const openSeconds = Math.max(0, ended.firstNamedMs / 1000 - pieceSeconds / speed);
+    // FFmpeg's reads may have waited for the stretch being copied; that wait
+    // is the copy's, and the stretch is sized from the open (torrent-tv/meta#178).
+    const waitedMs = Number.isFinite(ended.firstNamedWallMs) ? run.originalInput?.waitedBefore?.(ended.firstNamedWallMs) ?? 0 : 0;
+    const openSeconds = Math.max(0, (ended.firstNamedMs - waitedMs) / 1000 - pieceSeconds / speed);
     this.#host.encodeOrchestrator.noteOpen?.(session.outputKey ?? "", openSeconds);
     this.#host.logger.info(`encode input of run #${run.from}..#${run.to} on ${session.outputKey}: opened in ` +
-      `${openSeconds.toFixed(2)}s (first piece named at ${ended.firstNamedMs}ms, ${pieceSeconds.toFixed(3)}s of film at ${speed.toFixed(2)}x)`);
+      `${openSeconds.toFixed(2)}s (first piece named at ${ended.firstNamedMs}ms, ${pieceSeconds.toFixed(3)}s of film at ${speed.toFixed(2)}x` +
+      `${waitedMs > 0 ? `, ${waitedMs}ms of it waiting for the stretch to be copied, not counted` : ""})`);
   }
 
   /**

package/services/encode/OriginalInput.js

@@ -3,6 +3,15 @@ import { createHash } from "node:crypto";
 /** Retain complete original byte ranges under the encoder's input allowance.
  * The available-only reader acquires complete pieces atomically before copying;
  * owned buffers then outlive torrent eviction without keeping duplicate pins.
+ *
+ * THE RUN STARTS ONCE WHAT FFMPEG OPENS WITH IS COPIED. Each source's largest
+ * range — the stretch of film — is copied after the rest, and the answer comes
+ * back before it: FFmpeg's start and its reads of the header and the index then
+ * overlap that copy, and a read inside the stretch waits for it. Field
+ * 2026-10-12, after a seek back: 126.5 MB copied in 16.3 s before the encoder
+ * was started, then 10.1 s of its own open, and the viewer stood 33 s
+ * (torrent-tv/meta#178). `whole` settles when everything is copied — true — or
+ * when the copy failed or the input was released first — false.
  */
 export async function admitOriginalInput({ sources, reserve, readRanges, now = Date.now }) {
   const bytes = originalInputBytes(sources);
@@ -15,27 +24,72 @@ export async function admitOriginalInput({ sources, reserve, readRanges, now = D
   // How long the copy itself took, apart from any wait for memory or bytes
   // before it: the figure a run's stretch is sized from, read where the copy is.
   let copyMs = 0;
+  // Per source, the range copied after the answer: its position in the
+  // source's ranges, and the copy's promise once it has begun.
+  const later = [];
+  const read = async (source, ranges) => {
+    const startedAt = now();
+    const buffers = await readRanges(source, ranges, bytes);
+    copyMs += Math.max(0, now() - startedAt);
+    if (buffers === null) return null;
+    if (!Array.isArray(buffers) || buffers.length !== ranges.length || buffers.some((buffer, index) =>
+      !Buffer.isBuffer(buffer) || buffer.length !== ranges[index][1] - ranges[index][0] + 1)) {
+      throw new Error("Original input reader returned incomplete ranges.");
+    }
+    return buffers;
+  };
   try {
     for (const source of sources) {
-      const startedAt = now();
-      const buffers = await readRanges(source, source.input.ranges, bytes);
-      copyMs += Math.max(0, now() - startedAt);
-      if (buffers === null) return { kind: "needs-bytes", sourceKey: source.sourceKey, fileIndex: source.fileIndex, ranges: source.input.ranges };
-      if (!Array.isArray(buffers) || buffers.length !== source.input.ranges.length || buffers.some((buffer, index) =>
-        !Buffer.isBuffer(buffer) || buffer.length !== source.input.ranges[index][1] - source.input.ranges[index][0] + 1)) {
-        throw new Error("Original input reader returned incomplete ranges.");
-      }
+      const { ranges } = source.input;
+      const largest = ranges.reduce((best, range, index) =>
+        range[1] - range[0] > ranges[best][1] - ranges[best][0] ? index : best, 0);
+      const deferred = ranges.length > 1 ? largest : -1;
+      const first = ranges.filter((_, index) => index !== deferred);
+      const buffers = await read(source, first);
+      if (buffers === null) return { kind: "needs-bytes", sourceKey: source.sourceKey, fileIndex: source.fileIndex, ranges };
       // THE INPUT IS NAMED BY WHAT IT IS, NOT BY ITS BYTES. Every source is a
       // torrent whose pieces are verified before they are stored, and a read
       // gives every byte or none, so the same source, file, ranges and
       // selections are the same bytes. Hashing the bytes as well took 13.45 s
       // of 180 s of the main thread on a Matroska film whose picture and sound
       // copy the same ~30 MB a piece (torrent-tv/meta#178).
-      hash.update(JSON.stringify([source.sourceKey, source.fileIndex, source.input.ranges, source.input.selections]));
-      held.set(source.fileIndex, { source, buffers });
+      hash.update(JSON.stringify([source.sourceKey, source.fileIndex, ranges, source.input.selections]));
+      const entry = { source, buffers: ranges.map((_, index) => index === deferred ? null : buffers[index - (deferred >= 0 && index > deferred ? 1 : 0)]) };
+      held.set(source.fileIndex, entry);
+      if (deferred >= 0) later.push({ entry, position: deferred });
     }
     let released = false;
+    let failed = false;
     retained = true;
+    // ONE READ FOR THE STRETCH. Copied a torrent piece per read (2.97.12), a
+    // stretch took 33.1 s for 83.9 MB on the field's AVI against 126.5 MB in
+    // 16.3 s as one read beside another copy (torrent-tv/meta#178): each read
+    // waits its turn on two busy threads, and the stretch paid that once per
+    // piece. A release therefore discards the stretch when its read returns.
+    const copyLater = job => read(job.entry.source, [job.entry.source.input.ranges[job.position]]).then(buffers => {
+      if (buffers === null) { failed = true; return false; }
+      if (released) return false;
+      job.entry.buffers[job.position] = buffers[0];
+      return true;
+    }, () => { failed = true; return false; });
+    // The stretches, one source after another: they share one reader, and the
+    // first source's stretch is the one FFmpeg reaches first.
+    const whole = (async () => {
+      for (const job of later) {
+        if (released) return false;
+        job.copy = job.copy ?? copyLater(job);
+        if (!await job.copy) return false;
+      }
+      return !released;
+    })();
+    // A read of a stretch waits for its copy, which begins at once for the
+    // stretch asked for even when another is still being copied before it.
+    const copied = (entry, position) => {
+      const job = later.find(candidate => candidate.entry === entry && candidate.position === position);
+      if (!job) return Promise.resolve(entry.buffers[position] !== null);
+      job.copy = job.copy ?? copyLater(job);
+      return job.copy;
+    };
     // What FFmpeg asked of this input, for the run's own account of where its
     // time went: field 2026-10-08, a run took 6-9 s for a piece FFmpeg makes in
     // 1.6 s from a file, and nothing said whether it was waiting on its input.
@@ -45,12 +99,38 @@ export async function admitOriginalInput({ sources, reserve, readRanges, now = D
     // whether all of it was (torrent-tv/meta#177).
     /** @type {{ fileIndex: number, start: number, end: number, written: number, handedOver: boolean, at: number }[]} */
     const answers = [];
+    // When FFmpeg's reads waited for a stretch still being copied.
+    /** @type {{ from: number, to: number | null }[]} */
+    const waits = [];
+    const answer = (entry, position, start, stop) => {
+      const now = Date.now();
+      reads.count += 1;
+      reads.bytes += stop - start + 1;
+      reads.firstAt ||= now;
+      reads.lastAt = now;
+      const [from] = entry.source.input.ranges[position];
+      return { length: entry.source.input.fileLength, end: stop, bytes: entry.buffers[position].subarray(start - from, stop - from + 1) };
+    };
     return {
-      kind: "result", original: true, sources, bytes, copyMs, fingerprint: hash.digest("hex"),
+      kind: "result", original: true, sources, bytes, fingerprint: hash.digest("hex"),
+      // What the copy took so far; final once `whole` has settled.
+      get copyMs() { return copyMs; },
+      whole,
+      // Bytes of the stretches still to be copied when the answer was given.
+      deferredBytes: later.reduce((sum, job) => {
+        const [first, last] = job.entry.source.input.ranges[job.position];
+        return sum + last - first + 1;
+      }, 0),
+      copyFailed: () => failed,
       // No track's own end: the container names the bytes an interval needs,
       // not where each track stops. The final piece is judged by the input
       // reaching the end of the file instead (`piece-completeness.js`).
       tracks: sources.flatMap(source => (source.input.selections ?? []).map(selection => ({ track: selection.track }))),
+      /**
+       * The answer to a read from `start`, or null when it lies outside what
+       * the run holds. Inside a stretch still being copied the answer is a
+       * promise of the same, settled once the stretch is copied.
+       */
       read(fileIndex, start, end, partial = false) {
         if (released) return null;
         const entry = held.get(fileIndex);
@@ -61,12 +141,22 @@ export async function admitOriginalInput({ sources, reserve, readRanges, now = D
         const position = ranges.findIndex(([from, to]) => from <= start && (partial ? start : stop) <= to);
         if (position < 0) return null;
         stop = Math.min(stop, ranges[position][1]);
-        const now = Date.now();
-        reads.count += 1;
-        reads.bytes += stop - start + 1;
-        reads.firstAt ||= now;
-        reads.lastAt = now;
-        return { length: fileLength, end: stop, bytes: entry.buffers[position].subarray(start - ranges[position][0], stop - ranges[position][0] + 1) };
+        if (entry.buffers[position] !== null) return answer(entry, position, start, stop);
+        const wait = { from: Date.now(), to: null };
+        waits.push(wait);
+        return copied(entry, position).then(ok => {
+          wait.to = Date.now();
+          return ok && !released ? answer(entry, position, start, stop) : null;
+        });
+      },
+      /**
+       * Wall-clock milliseconds FFmpeg's reads spent waiting for a stretch to
+       * be copied before `until`. A run's open is measured from its first piece,
+       * and this wait is the copy's, not the open's: counted in, the stretch
+       * sized from the open would grow by its own copy time.
+       */
+      waitedBefore(until) {
+        return waits.reduce((sum, wait) => sum + Math.max(0, Math.min(wait.to ?? until, until) - wait.from), 0);
       },
       lengthOf: fileIndex => held.get(fileIndex)?.source.input.fileLength ?? null,
       reads: () => ({ ...reads, answers: describeAnswers(answers) }),

package/services/encode/quality/HostLoad.js

@@ -8,6 +8,7 @@
  */
 
 import os from "node:os";
+import { monitorEventLoopDelay } from "node:perf_hooks";
 import { logger } from "../../../utils/logger.js";
 import { availableShareFrom } from "../available-share.js";
 import { baseDrawFrom, costPerMegabyteFrom } from "../torrent-cost.js";
@@ -15,6 +16,24 @@ import { medianOf, movedBeyondScatter, READINGS_KEPT, scatterOf } from "../learn
 import { ENCODE_RUN_STATE, processCanBeSignalled } from "../encode-run-state.js";
 import { SourceFiles } from "../../media/SourceFile.js";
 
+/**
+ * What the torrent thread says of itself over one interval: how late its event
+ * loop ran, and how long reads for readers took inside it, from a command's
+ * arrival to its answer (torrent-tv/meta#178). Empty where it says nothing.
+ *
+ * @param {{ readerMs: number | null, readerReads: number | null, loopP99Ms: number | null, loopMaxMs: number | null }} now
+ * @param {{ readerMs: number | null, readerReads: number | null }} previous
+ * @returns {string}
+ */
+function threadSays(now, previous) {
+  const loop = Number.isFinite(now.loopP99Ms) && Number.isFinite(now.loopMaxMs)
+    ? `; its loop late p99=${Math.round(now.loopP99Ms)}ms max=${Math.round(now.loopMaxMs)}ms` : "";
+  const reads = Number.isFinite(now.readerReads) && Number.isFinite(previous.readerReads) && now.readerReads > previous.readerReads
+    && Number.isFinite(now.readerMs) && Number.isFinite(previous.readerMs)
+    ? `; ${now.readerReads - previous.readerReads} read(s) for readers took ${Math.round(now.readerMs - previous.readerMs)}ms in it` : "";
+  return loop + reads;
+}
+
 export class HostLoad {
   /** What this reads and asks of the rest of the proxy, and nothing else. @type {object} */
   #host;
@@ -35,6 +54,8 @@ export class HostLoad {
 
   /** The previous reading of the torrent thread's processor and the bytes downloaded. */
   #torrentSample = null;
+  /** This thread's event-loop lateness, begun at the first machine reading. */
+  #mainLoop = null;
 
   /** A reading of the torrent thread is under way; it asks the worker, which may not answer. */
   #readingTorrent = false;
@@ -186,6 +207,10 @@ export class HostLoad {
         uploaded: totals?.uploaded ?? null,
         served: totals?.served ?? null,
         threadCpuSeconds: totals?.threadCpuSeconds ?? null,
+        readerMs: totals?.readerMs ?? null,
+        readerReads: totals?.readerReads ?? null,
+        loopP99Ms: totals?.loopP99Ms ?? null,
+        loopMaxMs: totals?.loopMaxMs ?? null,
         metadata: this.#host.readMetadataActivity?.()
       };
       this.#learnThreadCost(now);
@@ -241,7 +266,7 @@ export class HostLoad {
         `torrent: downloaded ${(megabytes / elapsedSec).toFixed(2)} MB/s, sent to peers ${rateOf("uploaded")}, ` +
         `handed to readers ${rateOf("served")} over ${elapsedSec.toFixed(1)}s, ` +
         `limit ${Number.isFinite(limit) ? `${(limit / 1e6).toFixed(2)} MB/s` : "none"}; ` +
-        `its thread drew ${Math.round(cpuSeconds / elapsedSec * 100)}% of the machine`
+        `its thread drew ${Math.round(cpuSeconds / elapsedSec * 100)}% of the machine` + threadSays(now, previous)
       );
     }
     if (megabytes === 0) {
@@ -456,7 +481,8 @@ export class HostLoad {
     try {
       const totals = await this.#host.getTorrentTotals();
       const read = (key) => { const value = Number(totals?.[key]); return Number.isFinite(value) ? value : null; };
-      return { downloaded: read("downloaded"), uploaded: read("uploaded"), served: read("served"), threadCpuSeconds: read("threadCpuSeconds") };
+      return { downloaded: read("downloaded"), uploaded: read("uploaded"), served: read("served"), threadCpuSeconds: read("threadCpuSeconds"),
+        readerMs: read("readerMs"), readerReads: read("readerReads"), loopP99Ms: read("loopP99Ms"), loopMaxMs: read("loopMaxMs") };
     } catch {
       return null; // the pool is busy or gone; a reading missed is not a fault
     }
@@ -525,6 +551,16 @@ export class HostLoad {
    */
   async #sayMachine(share, proxyShare, running, suspended) {
     const machine = await this.#host.readMachineState();
+    // HOW LATE THIS THREAD'S LOOP RAN over the interval: every answer to FFmpeg
+    // and every hand-over of a copy waits for it (torrent-tv/meta#178). Begun at
+    // the first reading, so a check that never reads the machine starts no timer.
+    if (!this.#mainLoop) {
+      this.#mainLoop = monitorEventLoopDelay({ resolution: 20 });
+      this.#mainLoop.enable();
+    }
+    const late = this.#mainLoop.count > 0
+      ? ` loop p99=${Math.round(this.#mainLoop.percentile(99) / 1e6)}ms max=${Math.round(this.#mainLoop.max / 1e6)}ms` : "";
+    this.#mainLoop.reset();
     const asPercent = (value) => (value === null || value === undefined ? "n/a" : `${Math.round(value * 100)}%`);
     const free = Number.isFinite(share.systemShare) ? Math.max(0, 1 - share.systemShare) : null;
     logger.info(
@@ -536,7 +572,7 @@ 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)}`
+      ` available=${asPercent(this.hostAvailability.share)} free=${asPercent(free)}` + late
     );
   }
 

package/services/server/wire-outputs.js

@@ -959,6 +959,9 @@ export function wireOutputs({
     inputDemandChanged: (address, windows) => {
       for (const output of parts.outputs.outputsOn(address)) parts.encodeInputs?.retain(output, windows);
     },
+    inputsUnplaced: (address, starts) => {
+      for (const output of parts.outputs.outputsOn(address)) parts.encodeInputs?.withdrawUnplaced(output, starts);
+    },
     admission: parts.admission,
     // What the viewers actually waited for, by band. The ledger is the
     // priority layer's; the encoding is handed a way to ask it.

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

@@ -167,7 +167,7 @@ export async function readHeldBytes(torrent, fileIndex, start, end, logger = nul
 const missingSaid = new WeakMap();
 
 /** Acquire every input piece before copying any of the segment's ranges. */
-export async function readHeldRanges(torrent, fileIndex, ranges, maxBytes, logger = null) {
+export async function readHeldRanges(torrent, fileIndex, ranges, maxBytes, logger = null, onRead = null) {
   const file = torrent?.files?.[fileIndex];
   const pieceLength = Number(torrent?.pieceLength);
   const store = pieceStoreOf(torrent);
@@ -223,6 +223,7 @@ export async function readHeldRanges(torrent, fileIndex, ranges, maxBytes, logge
         });
       });
       if (!buffer || buffer.length !== length) return null;
+      onRead?.(length);
       for (const { rangeIndex, absoluteStart, absoluteEnd } of span.ranges) {
         const from = Math.max(absoluteStart, pieceStart);
         const to = Math.min(absoluteEnd, pieceStart + pieceLength - 1);

package/services/torrent/worker/worker.js

@@ -23,6 +23,7 @@
 import { isUsableTorrentHandle, requireCurrentTorrent } from "./handle-state.js";
 import "./install-webrtc-shim.js";
 import { parentPort, workerData } from "node:worker_threads";
+import { monitorEventLoopDelay, performance } from "node:perf_hooks";
 import { Readable } from "node:stream";
 import { heldFileBytes } from "./held-file-bytes.js";
 import { createSendStream } from "./channel.js";
@@ -108,6 +109,18 @@ const openReads = new Map();
  */
 let servedBytes = 0;
 
+/**
+ * How long reads for readers took inside this thread, from the command's
+ * arrival to its answer, and how many there were; and how late this thread's
+ * event loop ran. A copy for an encoder took 16.3 s for 126.5 MB as one read
+ * and 33.1 s for 83.9 MB as one read per piece on the field's AVI, and nothing
+ * said whether the time was spent here or on the way (torrent-tv/meta#178).
+ */
+let readerMs = 0;
+let readerReads = 0;
+const loopDelay = monitorEventLoopDelay({ resolution: 20 });
+loopDelay.enable();
+
 /**
  * Shorthand for this file. The same path as `logger.info` anywhere else in the
  * thread — kept only because it reads better at the hundred call sites here.
@@ -432,7 +445,12 @@ async function runCommand(command, params, id) {
       // bytes, so the price of a downloaded byte is taken over one interval
       // whether or not anything encodes (torrent-tv/meta#178).
       const usage = process.threadCpuUsage();
-      return { downloaded, uploaded, served: servedBytes, threadCpuSeconds: (usage.user + usage.system) / 1e6 };
+      // The loop's lateness over the interval since the last reading, in ms.
+      const loopP99Ms = loopDelay.count > 0 ? loopDelay.percentile(99) / 1e6 : null;
+      const loopMaxMs = loopDelay.count > 0 ? loopDelay.max / 1e6 : null;
+      loopDelay.reset();
+      return { downloaded, uploaded, served: servedBytes, threadCpuSeconds: (usage.user + usage.system) / 1e6,
+        readerMs, readerReads, loopP99Ms, loopMaxMs };
     }
 
 
@@ -528,8 +546,11 @@ async function runCommand(command, params, id) {
     case Command.READ_HELD: {
       const known = resolvedTorrents.get(params.sourceKey);
       const torrent = isUsableTorrentHandle(known) ? known : null;
+      const startedAt = performance.now();
       const bytes = await readWhileInUse(openReads, id, torrent, params.fileIndex,
         () => readHeldBytes(torrent, params.fileIndex, params.start, params.end, logger));
+      readerMs += performance.now() - startedAt;
+      readerReads += 1;
       servedBytes += bytes?.length ?? 0;
       return { bytes };
     }
@@ -537,9 +558,13 @@ async function runCommand(command, params, id) {
     case Command.READ_HELD_RANGES: {
       const known = resolvedTorrents.get(params.sourceKey);
       const torrent = isUsableTorrentHandle(known) ? known : null;
+      const startedAt = performance.now();
+      // Counted as each piece is read, so a long copy lands in the intervals
+      // it was made in rather than in the one it ended in.
       const buffers = await readWhileInUse(openReads, id, torrent, params.fileIndex,
-        () => readHeldRanges(torrent, params.fileIndex, params.ranges, params.maxBytes, logger));
-      for (const buffer of buffers ?? []) servedBytes += buffer?.length ?? 0;
+        () => readHeldRanges(torrent, params.fileIndex, params.ranges, params.maxBytes, logger, (length) => { servedBytes += length; }));
+      readerMs += performance.now() - startedAt;
+      readerReads += 1;
       return { buffers };
     }