@torrent-tv/proxy 2.97.24 → 2.97.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.97.24",
+  "version": "2.97.26",
   "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/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/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

@@ -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)
   };

package/services/storage/memory-report.js

@@ -468,6 +468,8 @@ export function startMemoryReport({
   /** @type {Record<string, number>} */
   let lastWritten = {};
   let lastWrittenAt = 0;
+  /** The anonymous memory and the time the mappings were last read at. */
+  let mappingsReadAt = null;
   const slug = (label || scope).replace(/[^a-z0-9]+/gi, "-").toLowerCase();
   const directory = snapshotDir || os.tmpdir();
 
@@ -553,13 +555,25 @@ export function startMemoryReport({
           // the reading now happens once a second rather than once a minute.
           const available = availableMemory();
           anonymousBytes = await readAnonymousMemory();
+          // THE MAPPINGS ONLY WHERE THE ANONYMOUS MEMORY THEY BREAK DOWN HAS
+          // MOVED, or once in a quiet interval. The line is written on every
+          // swing of resident memory, which array buffers taken and given back
+          // make every two or three seconds, and each walk of `smaps` cost the
+          // main thread about 70 ms: 15.6 s of it in ten minutes of a cold AVI
+          // on Home Assistant, while segments waited to be sent
+          // (torrent-tv/meta#178).
+          const mappingsDue = mappingsReadAt === null || now - mappingsReadAt.at >= quietMs ||
+            !Number.isFinite(anonymousBytes) || !Number.isFinite(mappingsReadAt.anonymousBytes) ||
+            Math.abs(anonymousBytes - mappingsReadAt.anonymousBytes) >= changeBytes;
+          const mappings = mappingsDue ? await readMappingSummary() : null;
+          if (mappingsDue) mappingsReadAt = { at: now, anonymousBytes };
           log(describeMemory({
             scope,
             label,
             process: processMemory,
             available,
             anonymousBytes,
-            mappings: await readMappingSummary(),
+            mappings,
             diskFreeBytes: diskPath ? await readDiskFree(diskPath) : null,
             stores,
             extra

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/DownloadMaps.js

@@ -87,9 +87,14 @@ export class DownloadMaps {
     // pass that works nothing out — every pass over a film already worked out
     // — states nothing early.
     let stated = Number.POSITIVE_INFINITY;
-    const workingOut = (priority, zones) => {
+    // The zones are asked for only when they are stated: worked out before
+    // every lower zone of a pass, they were the whole pass over again at each
+    // of its 4000 steps, and a cold AVI's start forecast waited 71 s for it
+    // (Home Assistant 2026-10-13, torrent-tv/meta#178).
+    const workingOut = (priority, zonesOf) => {
       if (!(priority < stated)) return;
       stated = priority;
+      const zones = typeof zonesOf === "function" ? zonesOf() : zonesOf;
       if (zones.length === 0 || !isCurrent()) return;
       this.#setZones(file, withRetained(zones, retained));
       this.#emit(file).catch(() => undefined);

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);
+}