@torrent-tv/proxy 2.97.23 → 2.97.25

package/package.json

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

package/server.js

@@ -17,6 +17,7 @@ import { ProbeRequests } from "./services/media/ProbeRequests.js";
 import { IndexMemory } from "./services/storage/IndexMemory.js";
 import { probePackets } from "./services/media/probe-packets.js";
 import { segmentDemands, sourceDeadline } from "./services/viewer/segment-demands.js";
+import { expandToTargetInputs } from "./services/viewer/target-input-expansion.js";
 import { SourcePreparation } from "./services/viewer/SourcePreparation.js";
 import { handleHealthzGet } from "./routes/healthz/get.js";
 import { handleApiDeliverySinkGet } from "./routes/api/delivery-sink/get.js";
@@ -490,11 +491,16 @@ export async function startProxyServer({
       const pieceLength = Number(torrentPool.knownTorrent(map.sourceKey)?.pieceLength);
       const converted = [];
       const demands = [];
+      // What each output's next run would copy, asked of the swarm as one group
+      // with its first segment (`target-input-expansion.js`).
+      const targets = new Map();
+      const expanded = () => expandToTargetInputs(converted, outputKey => targets.get(outputKey) ?? null);
       for (const output of outputParts.outputs.values()) {
         if (output.file.sourceKey !== map.sourceKey) continue;
         const consumers = [...outputParts.viewers.forOutput(output).values()].filter(viewer =>
           viewer.isPresent() && !outputParts.outputs.supersededBy(output, viewer.activeVariantId ?? null));
         if (consumers.length === 0) continue;
+        targets.set(output.outputKey, outputParts.encodeInputs?.targetInputBytes?.(output) ?? null);
         const inventory = outputParts.segmentStore.sizesOf(output.outputKey);
         let bytes = 0, seconds = 0;
         for (const [index, size] of inventory) {
@@ -560,7 +566,7 @@ export async function startProxyServer({
         if (waiting.has(zone.outputKey)) continue;
         // What is resolved so far is stated before a lower zone is worked out
         // (DownloadMaps, torrent-tv/meta#178).
-        map.workingOut?.(zone.priority, converted);
+        map.workingOut?.(zone.priority, expanded());
         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).
@@ -606,7 +612,7 @@ export async function startProxyServer({
         segmentSourceRanges.set(rangesKey, input.ranges);
         convert(input.ranges);
       }
-      return converted;
+      return expanded();
     }
   });
   const mediaReads = new MediaReadRequests({

package/services/encode/EncodeInputs.js

@@ -303,6 +303,23 @@ export class EncodeInputs {
     return this.stretchFor(output)?.bytes ?? null;
   }
 
+  /**
+   * What the next run of this output would be given to copy, whatever has
+   * arrived: the stretch `stretchFor` sizes, within the memory encoder inputs
+   * may hold. The download map asks the swarm for that much as one group
+   * (`viewer/target-input-expansion.js`); a stretch shortened to what is here
+   * would ask only for what is here. Null while it is not known.
+   *
+   * @param {object} output
+   * @returns {number | null}
+   */
+  targetInputBytes(output) {
+    const bytes = this.stretchBytesFor(output);
+    if (bytes === null) return null;
+    const capacity = this.#capacity();
+    return Number.isFinite(capacity) ? Math.min(bytes, capacity) : bytes;
+  }
+
   #prepare(request) {
     request.pending = true;
     request.revision = this.#revision;

package/services/encode/EncodeRuns.js

@@ -291,7 +291,7 @@ export class EncodeRuns {
   inputCacheBytes() {
     let bytes = 0;
     for (const run of this.#runsByInputToken.values()) {
-      if (run.isAlive && run.originalInput) bytes += Math.max(0, Number(run.originalInput.bytes) || 0);
+      if (run.isAlive && run.originalInput?.readThroughCache) bytes += Math.max(0, Number(run.originalInput.bytes) || 0);
     }
     return bytes;
   }
@@ -1024,6 +1024,9 @@ export class EncodeRuns {
     this.#lastInputToken += 1;
     const inputToken = this.#lastInputToken;
     if (admittedInput) admittedInput.runTag = `${startIndex}r${inputToken}`;
+    // Whether this run's FFmpeg keeps what it reads in its cache's file, which
+    // is what the budget counts on that file's disk.
+    if (admittedInput?.original) admittedInput.readThroughCache = this.#host.readsThroughCache?.() === true;
     const buildCommand = admittedInput.original ? buildOriginalCommand : buildAdmittedCommand;
     const built = buildCommand({
       admittedInput,
@@ -1044,7 +1047,8 @@ export class EncodeRuns {
       endIndex: admittedInput.original ? inputEnd
         : Number.isInteger(ordered?.to) ? ordered.to : runEnd >= startIndex ? runEnd : session.timeline.segmentCount - 1,
       videoEncoder: this.#host.videoEncoder,
-      segmentDurationSec: this.#host.segmentDurationSec
+      segmentDurationSec: this.#host.segmentDurationSec,
+      readThroughCache: admittedInput.readThroughCache === true
     });
     const { args, cutTimes } = built;
     // The piece before the start, made only to have its group in hand, is

package/services/encode/input-cache.js

@@ -0,0 +1,63 @@
+/**
+ * @file Whether this machine's FFmpeg can read an encoder's input through its
+ * `cache:` protocol, and on which directory's disk that cache lies.
+ *
+ * FFmpeg's cache (libavformat/cache.c) keeps what it has read in a temporary
+ * file opened by `avpriv_tempfile`, and a Linux build can only open that file
+ * in /tmp (libavutil/file_open.c n8.1, `mkstemp`); a Windows or Android build
+ * opens it where FFmpeg runs. Where no /tmp can be written, every run reading
+ * through the cache fails at its open — checked on Home Assistant with a
+ * read-only root: "ff_tempfile: Cannot open temporary file
+ * /tmp/ffcacheXXXXXX", while the same file read directly opened. So one small
+ * read through the cache is tried at startup with this proxy's own FFmpeg, and
+ * until it has succeeded an input is read directly (torrent-tv/meta#178).
+ */
+
+import { spawn as nodeSpawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+/**
+ * Where FFmpeg keeps its cache's file: /tmp on a build that uses `mkstemp`,
+ * else where FFmpeg runs, which for a run is a directory of the segments.
+ *
+ * @param {string} [platform]
+ * @returns {string | null} null for the segments' own directory.
+ */
+export function inputCacheRoot(platform = process.platform) {
+  return platform === "win32" || platform === "android" ? null : "/tmp";
+}
+
+/**
+ * Read a small file through FFmpeg's cache once.
+ *
+ * @param {object} params
+ * @param {string} params.ffmpegBin
+ * @param {typeof nodeSpawn} [params.spawn]
+ * @param {string} [params.scratch] - Where the file read is written.
+ * @returns {Promise<{ available: boolean, reason: string }>}
+ */
+export async function probeInputCache({ ffmpegBin, spawn = nodeSpawn, scratch = os.tmpdir() }) {
+  let directory = null;
+  try {
+    directory = await mkdtemp(path.join(scratch, "ttv-input-cache-"));
+    const file = path.join(directory, "input.bin");
+    await writeFile(file, randomBytes(64 * 1024));
+    const { code, error } = await new Promise((resolve) => {
+      let stderr = "";
+      const child = spawn(ffmpegBin, ["-v", "error", "-nostdin", "-f", "data", "-i", `cache:file:${file}`,
+        "-map", "0", "-c", "copy", "-f", "null", "-"], { stdio: ["ignore", "ignore", "pipe"], windowsHide: true });
+      child.stderr?.on("data", (chunk) => { stderr += chunk; });
+      child.once("error", (failure) => resolve({ code: null, error: failure.message }));
+      child.once("close", (exitCode) => resolve({ code: exitCode, error: stderr.trim().split(/\r?\n/).pop() ?? "" }));
+    });
+    return code === 0 ? { available: true, reason: "a read through it completed" }
+      : { available: false, reason: `FFmpeg ${code === null ? "did not start" : `exited ${code}`}: ${error || "no message"}` };
+  } catch (error) {
+    return { available: false, reason: `the file to read could not be prepared: ${error instanceof Error ? error.message : String(error)}` };
+  } finally {
+    if (directory) await rm(directory, { recursive: true, force: true }).catch(() => undefined);
+  }
+}

package/services/encode/quality/HostLoad.js

@@ -31,7 +31,15 @@ function threadSays(now, previous) {
   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;
+  // Whether our own selection held the swarm back over the interval, and what
+  // it gave in the time it did not (`SelectionLimit`, torrent-tv/meta#178).
+  const ms = (now.selection?.ms ?? 0) - (previous.selection?.ms ?? 0);
+  const freeMs = (now.selection?.freeMs ?? 0) - (previous.selection?.freeMs ?? 0);
+  const freeBytes = (now.selection?.freeBytes ?? 0) - (previous.selection?.freeBytes ?? 0);
+  const held = ms > 0 && freeMs >= 0 && freeMs <= ms
+    ? `; our selection held a peer back ${Math.round((1 - freeMs / ms) * 100)}% of the time` +
+      (freeMs > 0 ? `, the rest gave ${(freeBytes / freeMs / 1000).toFixed(2)} MB/s` : "") : "";
+  return loop + reads + held;
 }
 
 export class HostLoad {
@@ -211,6 +219,7 @@ export class HostLoad {
         readerReads: totals?.readerReads ?? null,
         loopP99Ms: totals?.loopP99Ms ?? null,
         loopMaxMs: totals?.loopMaxMs ?? null,
+        selection: totals?.selection ?? null,
         metadata: this.#host.readMetadataActivity?.()
       };
       this.#learnThreadCost(now);
@@ -482,7 +491,8 @@ export class HostLoad {
       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"),
-        readerMs: read("readerMs"), readerReads: read("readerReads"), loopP99Ms: read("loopP99Ms"), loopMaxMs: read("loopMaxMs") };
+        readerMs: read("readerMs"), readerReads: read("readerReads"), loopP99Ms: read("loopP99Ms"), loopMaxMs: read("loopMaxMs"),
+        selection: totals?.selection ?? null };
     } catch {
       return null; // the pool is busy or gone; a reading missed is not a fault
     }

package/services/encode/source-command.js

@@ -278,7 +278,10 @@ export function buildOriginalCommand(params) {
   // the pieces were the same to the byte, on FFmpeg 6.1 and 8.1.2 (Home
   // Assistant 2026-10-13, torrent-tv/meta#178). The cache's file holds what
   // FFmpeg read and is counted by the budget (`EncodeRuns.inputCacheBytes`).
-  const url = source => `cache:${new URL(`/encode-input/${inputToken}/${source.fileIndex}`, baseUrl).href}`;
+  // Only where a read through it has worked on this machine
+  // (`encode/input-cache.js`); elsewhere the input is read directly.
+  const readThroughCache = params.readThroughCache !== false;
+  const url = source => `${readThroughCache ? "cache:" : ""}${new URL(`/encode-input/${inputToken}/${source.fileIndex}`, baseUrl).href}`;
   // The container named the bytes FFmpeg's stream search reads for this much
   // media time; the search is told the same, whatever its own default.
   const openArgs = source => Number.isFinite(source.input.streamSearchSeconds)

package/services/server/ViewerRequests.js

@@ -880,15 +880,31 @@ export class ViewerRequests {
     return trend.snapshot();
   }
 
+  /**
+   * What the swarm can give this source. A rate measured while our own
+   * selection held a connection back measures our asking: on a cold Matroska
+   * it read 0.4-1.3 MB/s while the same swarm later gave 12-14 MB/s, and the
+   * forecast swung from 0.9 s to 19 075 s (torrent-tv/meta#178). So it is read
+   * from the time no connection was held back (`SelectionLimit`), and a later
+   * such reading lowers it as readily as it raises it. Until there is one, the
+   * rate delivered stands, which is the least the swarm can give.
+   */
   #sourceRateReadings(state, id, stats, now) {
-    let trend = state.sources.get(id);
-    if (!trend) {
-      trend = new this.#host.playbackReadiness.RateTrend(this.#host.lookaheadSeconds);
-      state.sources.set(id, trend);
+    let source = state.sources.get(id);
+    if (!source) {
+      const { RateTrend } = this.#host.playbackReadiness;
+      source = { delivered: new RateTrend(this.#host.lookaheadSeconds), free: new RateTrend(this.#host.lookaheadSeconds), limit: null };
+      state.sources.set(id, source);
     }
     if (Number.isFinite(stats?.downloadSpeed) && stats.downloadSpeed >= 0) {
-      trend.add(now, stats.downloadSpeed);
+      source.delivered.add(now, stats.downloadSpeed);
     }
-    return trend.snapshot();
+    const limit = stats?.selectionLimit;
+    if (limit && source.limit && limit.freeMs > source.limit.freeMs) {
+      source.free.add(now, Math.max(0, limit.freeBytes - source.limit.freeBytes) * 1000 / (limit.freeMs - source.limit.freeMs));
+    }
+    // Totals that went back belong to a torrent added again: read on from them.
+    if (limit) source.limit = limit;
+    return source.free.snapshot() ?? source.delivered.snapshot();
   }
 }

package/services/server/wire-outputs.js

@@ -93,7 +93,7 @@ import { audioReadingFor } from "../encode/audio-work-rate.js";
 import { wireMachineBudget } from "../storage/wire.js";
 import { Returns } from "../storage/returns.js";
 import { freeBytesFor } from "../storage/free.js";
-import { existsSync } from "node:fs";
+import { inputCacheRoot, probeInputCache } from "../encode/input-cache.js";
 import path from "node:path";
 import { contentOf, LocalObservations, PROXY_ROOT } from "../encode/LocalObservations.js";
 import { configurationKeyOf } from "../encode/fingerprint.js";
@@ -254,6 +254,7 @@ export function wireOutputs({
     directoryFor: (address, format) => parts.segmentStore.directoryFor(address, format),
     publish: (address, makingName, format, read) => parts.segmentStore.publish(address, makingName, format, read),
     closedBytesOf: (address, makingName) => parts.segmentStore.closedBytesOf(address, makingName),
+    writtenAtOf: (address, makingName) => parts.segmentStore.writtenAtOf(address, makingName),
     mediaRangesOf: (address, index, where) => parts.segmentStore.mediaRangesOf(address, index, where),
     remove: (address, index, because) => parts.segmentStore.remove(address, index, because)
   };
@@ -341,6 +342,7 @@ export function wireOutputs({
     get outputs() { return parts.outputs; },
     get priority() { return parts.priority; },
     get segmentDurationSec() { return parts.segmentDurationSec; },
+    readsThroughCache: () => parts.inputCacheAvailable === true,
     segmentFiles,
     get videoEncoder() { return parts.encoders.current; },
     get encoders() { return parts.encoders; },
@@ -627,6 +629,16 @@ export function wireOutputs({
   parts.coldStarts = new ColdStarts();
   parts.enabled = Boolean(enabled);
   parts.ffmpegBin = ffmpegBin;
+  // Whether a run may read its input through FFmpeg's cache: once a read
+  // through it has worked with this FFmpeg, and directly until then
+  // (`encode/input-cache.js`).
+  parts.inputCacheAvailable = false;
+  if (parts.enabled && ffmpegBin) {
+    void probeInputCache({ ffmpegBin }).then(({ available, reason }) => {
+      parts.inputCacheAvailable = available;
+      logger.info(`encoder input: ${available ? "read through FFmpeg's cache" : "read directly"} — ${reason}`);
+    });
+  }
   parts.sourceInputsFor = typeof sourceInputsFor === "function" ? sourceInputsFor : null;
   parts.keyframeTables = keyframeTables;
   // Where measurements about this host are kept between runs. Empty means
@@ -1045,9 +1057,9 @@ export function wireOutputs({
     memory: parts.memoryClaimant,
     encodeInputs: parts.encodeInputs,
     indexMemory,
-    // FFmpeg puts its temporary files in /tmp, or where it runs when there is
-    // none — an output directory of the segments.
-    inputCaches: { held: () => parts.encodeRuns?.inputCacheBytes() ?? 0, root: existsSync("/tmp") ? "/tmp" : null },
+    // FFmpeg's cache keeps its file in /tmp, or where FFmpeg runs on a build
+    // without `mkstemp` — an output directory of the segments.
+    inputCaches: { held: () => parts.encodeRuns?.inputCacheBytes() ?? 0, root: inputCacheRoot() },
     policy: parts.budgetPolicy ?? undefined,
     readFree: freeBytesFor,
     logger

package/services/torrent/download/FutureDownload.js

@@ -16,7 +16,7 @@ export async function futureDownload(entries, { now = Date.now(), findStore = pi
   const forecasts = new Map();
   const pending = [];
   let steps = 0;
-  for (const { torrent, register } of entries) {
+  for (const { torrent, register, limit = null } of entries) {
     if (torrent.destroyed || torrent.ready === false) continue;
     const wanted = new Map();
     for (const window of register.windows()) {
@@ -81,7 +81,10 @@ export async function futureDownload(entries, { now = Date.now(), findStore = pi
       const remaining = piece?.missing;
       const speed = (torrent.wires ?? []).reduce((sum, wire) => {
         if (wire.destroyed || !wire.peerPieces?.get(index)) return sum;
-        const rate = Number(wire.downloadSpeed?.());
+        // What it carried with its queue kept full, where it has been seen so:
+        // its speed while our selection gave it little measures our asking
+        // (`SelectionLimit`, torrent-tv/meta#178).
+        const rate = Number(limit?.capacityOf?.(wire) ?? wire.downloadSpeed?.());
         return Number.isFinite(rate) && rate > 0 ? sum + rate : sum;
       }, 0);
       pending.push({ arrivals, index, ...band, seconds:

package/services/torrent/download/SelectionLimit.js

@@ -0,0 +1,161 @@
+/**
+ * @file Whether what this proxy let the swarm send was what held it back.
+ *
+ * A download rate measured while we asked for too little describes our asking,
+ * not the swarm: on a cold Matroska the forecast read 0.4-1.3 MB/s, swung from
+ * 0.9 s to 19 075 s, and the same swarm later gave 12-14 MB/s
+ * (torrent-tv/meta#178). So the rate is split by cause, here, on the torrent's
+ * thread, where the connections are.
+ *
+ * A connection was held back by our selection when three things held at once:
+ *
+ * 1. the peer let us download (it was not choking us);
+ * 2. its queue was short of what WebTorrent keeps on it — the blocks half a
+ *    second of its speed carries, at most what the peer accepts (2.8.5
+ *    `getBlockPipelineLength` with `PIPELINE_MIN_DURATION`), below which
+ *    `_updateWire` asks for more;
+ * 3. the peer held a piece the priority map wants and we lack, outside what
+ *    the selection states — something it could have sent had we asked.
+ *
+ * A request still queued does not make a connection busy; a queue topped up is
+ * what does. A peer that lacks every piece the map wants, or chokes us, or
+ * slows down, is the swarm's own limit and stays in the measurement.
+ *
+ * An interval of time takes the state found at its start. Totals only grow:
+ * whoever reads them takes differences over its own span, so this owner keeps
+ * no window of its own. Per connection, the rate it carried while its queue was
+ * kept full is kept as what it can carry, for the forecast of single pieces.
+ */
+
+import { piecesOf } from "../demand/pieces.js";
+
+const BLOCK_BYTES = 16 * 1024;
+/** WebTorrent 2.8.5 `PIPELINE_MIN_DURATION`: the queue is refilled below this many seconds of speed. */
+const PIPELINE_MIN_SECONDS = 0.5;
+
+/**
+ * Whether WebTorrent would ask this connection for more right now.
+ *
+ * @param {object} wire
+ * @returns {boolean}
+ */
+export function queueIsShort(wire) {
+  let length = 2 + Math.ceil(PIPELINE_MIN_SECONDS * (Number(wire.downloadSpeed?.()) || 0) / BLOCK_BYTES);
+  const reqq = wire.peerExtendedHandshake?.reqq;
+  if (typeof reqq === "number" && reqq > 0) length = Math.min(length, reqq);
+  return (wire.requests?.length ?? 0) < length;
+}
+
+export class SelectionLimit {
+  #torrent;
+  #register;
+  #selection;
+  #now;
+  /** The last sample: when, the torrent's bytes then, and whether it was held back. */
+  #last = null;
+  #totals = { bytes: 0, ms: 0, freeBytes: 0, freeMs: 0, heldBackMs: 0 };
+  /** Per connection: its bytes at the last sample, whether its queue was full, what it carried full. */
+  #wires = new WeakMap();
+  /** The last sample's held-back connections, for the log. */
+  heldBack = 0;
+
+  /**
+   * @param {object} params
+   * @param {object} params.torrent
+   * @param {import("../demand/index.js").DemandRegister} params.register
+   * @param {{ statedRanges: () => Array<{ from: number, to: number }> }} params.selection
+   * @param {() => number} [params.now]
+   */
+  constructor({ torrent, register, selection, now = Date.now }) {
+    this.#torrent = torrent;
+    this.#register = register;
+    this.#selection = selection;
+    this.#now = now;
+  }
+
+  /**
+   * Look at every connection once, close the interval since the last look, and
+   * open the next with what is found.
+   *
+   * @returns {void}
+   */
+  sample() {
+    const torrent = this.#torrent;
+    if (!torrent || torrent.destroyed) return;
+    const at = this.#now();
+    const downloaded = Number(torrent.downloaded) || 0;
+    if (this.#last !== null && at > this.#last.at) {
+      const ms = at - this.#last.at;
+      const bytes = Math.max(0, downloaded - this.#last.downloaded);
+      this.#totals.bytes += bytes;
+      this.#totals.ms += ms;
+      if (this.#last.heldBack) this.#totals.heldBackMs += ms;
+      else {
+        this.#totals.freeBytes += bytes;
+        this.#totals.freeMs += ms;
+      }
+    }
+    const unasked = this.#unaskedWants();
+    let heldBack = 0;
+    for (const wire of torrent.wires ?? []) {
+      if (wire.destroyed) continue;
+      const short = queueIsShort(wire);
+      const seen = this.#wires.get(wire);
+      const wireBytes = Number(wire.downloaded) || 0;
+      // What a connection carries while its queue stays topped up is what it
+      // can carry; a stretch it was short in measures our asking.
+      if (seen && seen.full && !short && at > seen.at) {
+        seen.capacity = Math.max(0, wireBytes - seen.bytes) * 1000 / (at - seen.at);
+      }
+      this.#wires.set(wire, { at, bytes: wireBytes, full: !wire.peerChoking && !short, capacity: seen?.capacity ?? null });
+      if (wire.peerChoking || !short || unasked.length === 0) continue;
+      if (unasked.some(piece => wire.peerPieces?.get?.(piece))) heldBack += 1;
+    }
+    this.heldBack = heldBack;
+    this.#last = { at, downloaded, heldBack: heldBack > 0 };
+  }
+
+  /**
+   * Grow-only totals: every byte and millisecond sampled, those of intervals
+   * no connection was held back in, and the time some was.
+   *
+   * @returns {{ at: number | null, bytes: number, ms: number, freeBytes: number, freeMs: number, heldBackMs: number }}
+   */
+  totals() {
+    return { at: this.#last?.at ?? null, ...this.#totals };
+  }
+
+  /**
+   * What a connection carried while its queue was kept full, in bytes per
+   * second; null until it has been seen so.
+   *
+   * @param {object} wire
+   * @returns {number | null}
+   */
+  capacityOf(wire) {
+    return this.#wires.get(wire)?.capacity ?? null;
+  }
+
+  /** Pieces the map wants, missing here, that the selection does not state, in map order. */
+  #unaskedWants() {
+    const torrent = this.#torrent;
+    const stated = this.#selection.statedRanges();
+    const pieces = [];
+    const seen = new Set();
+    for (const window of this.#register.windows()) {
+      const file = torrent.files?.[window.fileIndex];
+      if (!file) continue;
+      const range = piecesOf({ fileOffset: Number(file.offset), byteStart: window.byteStart,
+        byteEnd: Math.min(window.byteEnd, Number(file.length) - 1), pieceLength: Number(torrent.pieceLength) });
+      if (!range) continue;
+      for (let piece = range.from; piece <= range.to; piece++) {
+        if (seen.has(piece)) continue;
+        seen.add(piece);
+        if (torrent.bitfield?.get?.(piece)) continue;
+        if (stated.some(one => piece >= one.from && piece <= one.to)) continue;
+        pieces.push(piece);
+      }
+    }
+    return pieces;
+  }
+}

package/services/torrent/download/registry.js

@@ -17,6 +17,7 @@
 
 import { DemandRegister } from "../demand/DemandRegister.js";
 import { SwarmSelection } from "./SwarmSelection.js";
+import { SelectionLimit } from "./SelectionLimit.js";
 import { futureDownload } from "./FutureDownload.js";
 import { urgencyName } from "../demand/index.js";
 
@@ -56,7 +57,8 @@ export function demandFor(torrent) {
     return held;
   }
   const register = new DemandRegister();
-  const entry = { torrent, register, selection: new SwarmSelection({ torrent, register }), withdrawalRevision: 0 };
+  const selection = new SwarmSelection({ torrent, register });
+  const entry = { torrent, register, selection, limit: new SelectionLimit({ torrent, register, selection }), withdrawalRevision: 0 };
   byTorrent.set(torrent, entry);
   live.add(entry);
   entry.onBytesChanged = () => reconcileAll();
@@ -105,6 +107,16 @@ export function forgetTorrent(torrent) {
   live.delete(held);
 }
 
+/**
+ * Whether this proxy's own selection held the swarm back, as grow-only totals
+ * (`SelectionLimit`); null for a torrent nothing has been stated about.
+ *
+ * @param {object} torrent
+ */
+export function selectionLimitOf(torrent) {
+  return byTorrent.get(torrent)?.limit.totals() ?? null;
+}
+
 /** What the swarm was last told to fetch first: the level, its priority and the pieces per torrent. */
 export function firstClassStatement() {
   return firstClassStated;
@@ -142,6 +154,9 @@ export function reconcileAll() {
   } finally {
     publishingSelections = false;
   }
+  // Each torrent's connections looked at under what it has just been told:
+  // on every verified piece and on the pool's timer.
+  for (const entry of entries) entry.limit.sample();
   // What the swarm is told to fetch FIRST, said when it changes. Lower classes
   // are withheld because a wire with no first-class piece would fall through.
   const said = entries.map(entry => `${String(entry.torrent.infoHash ?? "").slice(0, 8)}: ` +

package/services/torrent/torrent-pool.js

@@ -18,7 +18,7 @@ import { logger } from "../../utils/logger.js";
 import { pieceStoreOf } from "./piece-store-of.js";
 import { demandProgress } from "./demand-progress.js";
 import { Urgency, urgencyName } from "./demand/index.js";
-import { demandFor, firstClassStatement, forgetTorrent, reconcileAll, hasUnmetDemand } from "./download/registry.js";
+import { demandFor, firstClassStatement, forgetTorrent, reconcileAll, hasUnmetDemand, selectionLimitOf } from "./download/registry.js";
 import { applyDownloadRate } from "./download/throttle.js";
 import { withdrawClaim } from "./download/withdraw-claim.js";
 import { deadlineOfMapZone, levelOfMapZone, priorityOfMapZone } from "./map-zones.js";
@@ -2057,6 +2057,9 @@ export class TorrentPool {
       numPeers,
       downloadSpeed,
       uploadSpeed,
+      // Bytes and time split by whether our own selection held a connection
+      // back: what the swarm can give is read from the rest (`SelectionLimit`).
+      selectionLimit: selectionLimitOf(torrent),
       connectedPeers: reach.connectedPeers,
       deliveringPeers: reach.deliveringPeers,
       knownPeers: reach.knownPeers,

package/services/torrent/worker/worker.js

@@ -28,7 +28,7 @@ import { Readable } from "node:stream";
 import { heldFileBytes } from "./held-file-bytes.js";
 import { createSendStream } from "./channel.js";
 import { readFragments, supplyFiguresFor } from "./piece-reader.js";
-import { demandFor, forecastDownloads } from "../download/registry.js";
+import { demandFor, forecastDownloads, selectionLimitOf } from "../download/registry.js";
 import { heldRangesOf, ownsItsMemory, readHeldBytes, readHeldRanges } from "./held-bytes.js";
 import { CompletedFiles, completedFilesRoot } from "../../storage/files/CompletedFiles.js";
 import { pieceFromWholeFiles, pieceIsInWholeFiles } from "../../storage/files/piece-from-whole-file.js";
@@ -435,11 +435,16 @@ async function runCommand(command, params, id) {
       // be.
       let downloaded = 0;
       let uploaded = 0;
+      // Over every torrent: the time our own selection held a connection back,
+      // and the bytes and time of the rest (`SelectionLimit`).
+      const selection = { ms: 0, heldBackMs: 0, freeBytes: 0, freeMs: 0 };
       for (const torrent of pool.client?.torrents ?? []) {
         const gotBytes = Number(torrent?.downloaded);
         const sentBytes = Number(torrent?.uploaded);
         downloaded += Number.isFinite(gotBytes) ? gotBytes : 0;
         uploaded += Number.isFinite(sentBytes) ? sentBytes : 0;
+        const limit = selectionLimitOf(torrent);
+        if (limit) for (const key of Object.keys(selection)) selection[key] += limit[key];
       }
       // This thread's own processor time, read in the same moment as the
       // bytes, so the price of a downloaded byte is taken over one interval
@@ -450,7 +455,7 @@ async function runCommand(command, params, id) {
       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 };
+        readerMs, readerReads, loopP99Ms, loopMaxMs, selection };
     }
 
 

package/services/viewer/target-input-expansion.js

@@ -0,0 +1,88 @@
+/**
+ * @file The next run's whole input, asked of the swarm as one group.
+ *
+ * While anything urgent is missing, the swarm is told only the first class
+ * (`torrent/download/SwarmSelection.js`), and at a cold start the map's first
+ * class is one segment's input. A peer holding none of its pieces then has
+ * nothing to send, and a run is admitted only as far as its input has arrived
+ * (`encode/EncodeInputs.js`), so it opens again a few seconds of film later.
+ *
+ * WebTorrent 2.8.5 keeps no order between several non-zero selections — it
+ * rotates them (`shufflePriority`) — so the run's input is not stated as a
+ * second group behind the first: the segments it covers take the first
+ * segment's place in the map, and the swarm is told them as one group. How
+ * far that reaches is what `EncodeInputs` would copy for the run, from its
+ * copy rate, its open and the memory allowed; it is not worked out again here.
+ * A read stopped on its bytes is stated at a level of its own above any of
+ * this, and a seek, which moves the map's first segment, moves this with it
+ * (torrent-tv/meta#178).
+ */
+
+/**
+ * Bytes covered by a list of inclusive ranges, each byte counted once: the
+ * declarations and indexes every segment of an original file names are held
+ * once by the run that reads them.
+ *
+ * @param {Array<[number, number]>} ranges
+ * @returns {number}
+ */
+function coveredBytes(ranges) {
+  let total = 0;
+  let end = -1;
+  for (const [start, last] of [...ranges].sort((left, right) => left[0] - right[0])) {
+    if (last <= end) continue;
+    total += last - Math.max(start, end + 1) + 1;
+    end = last;
+  }
+  return total;
+}
+
+/**
+ * The map's byte zones with each output's next run input raised to its first
+ * segment's place.
+ *
+ * @template {{ outputKey: string, index: number, priority: number, urgent?: boolean, behind?: boolean, deferred?: boolean, byteStart: number, byteEnd: number }} Zone
+ * @param {Zone[]} zones - One or more per segment, as the map's pass made them.
+ * @param {(outputKey: string) => number | null} targetBytesOf - What the
+ *   output's next run would be given to copy; nothing is raised without it.
+ * @returns {Zone[]} In their order; raised zones are copies.
+ */
+export function expandToTargetInputs(zones, targetBytesOf) {
+  /** @type {Map<string, Map<number, Zone[]>>} */
+  const byOutput = new Map();
+  for (const zone of zones) {
+    let segments = byOutput.get(zone.outputKey);
+    if (!segments) byOutput.set(zone.outputKey, segments = new Map());
+    const list = segments.get(zone.index);
+    if (list) list.push(zone);
+    else segments.set(zone.index, [zone]);
+  }
+  /** @type {Map<Zone, Zone>} */
+  const raised = new Map();
+  for (const [outputKey, segments] of byOutput) {
+    const target = targetBytesOf(outputKey);
+    if (!(target > 0)) continue;
+    let first = null;
+    for (const [index, list] of segments) {
+      const priority = Math.max(...list.map(zone => zone.priority));
+      if (first === null || priority > first.priority || (priority === first.priority && index < first.index)) {
+        first = { index, priority, zone: list.find(zone => zone.priority === priority) };
+      }
+    }
+    if (first === null) continue;
+    const held = segments.get(first.index).map(zone => [zone.byteStart, zone.byteEnd]);
+    // The run's input is a stretch of consecutive segments: one already made,
+    // or not yet worked out, ends it.
+    for (let index = first.index + 1; segments.has(index); index++) {
+      const list = segments.get(index);
+      const ranges = [...held, ...list.map(zone => [zone.byteStart, zone.byteEnd])];
+      if (coveredBytes(ranges) > target) break;
+      held.push(...list.map(zone => [zone.byteStart, zone.byteEnd]));
+      for (const zone of list) {
+        raised.set(zone, { ...zone, priority: first.priority, urgent: first.zone.urgent,
+          behind: first.zone.behind, deferred: first.zone.deferred });
+      }
+    }
+  }
+  return raised.size === 0 ? zones : zones.map(zone => raised.get(zone) ?? zone);
+}