@torrent-tv/proxy 2.98.14 → 2.98.16

package/package.json

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

package/services/encode/host-load.js

@@ -92,6 +92,34 @@ export async function readProcessCpuSeconds(pid) {
   }
 }
 
+/**
+ * The CPU time every child of this process that has ended has used, from the
+ * `cutime` and `cstime` of `/proc/self/stat`: the kernel adds a child's time
+ * there when the child is waited for, which Node does as soon as it exits.
+ *
+ * What a process that started and ended between two readings of its own pid
+ * cost, which no reading of that pid can say: on Home Assistant a run of one
+ * piece started and ended between two readings 5 s apart, used 6.65 s of CPU,
+ * and both readings said `ffmpeg=0%` (r41, torrent-tv/meta#178).
+ *
+ * @returns {Promise<number | null>} Seconds of CPU, or null where there is no `/proc`.
+ */
+export async function readEndedChildrenCpuSeconds() {
+  try {
+    const text = await readFile("/proc/self/stat", "utf8");
+    const afterComm = text.slice(text.lastIndexOf(")") + 2).trim().split(/\s+/);
+    // After the comm and state fields, cutime is index 13 and cstime index 14.
+    const cutime = Number(afterComm[13]);
+    const cstime = Number(afterComm[14]);
+    if (!Number.isFinite(cutime) || !Number.isFinite(cstime)) {
+      return null;
+    }
+    return (cutime + cstime) / CLOCK_TICKS_PER_SECOND;
+  } catch {
+    return null; // not Linux, or /proc is not mounted
+  }
+}
+
 /**
  * Is this still the machine the benchmarks were taken on: its clock and its
  * temperature.

package/services/encode/quality/HostLoad.js

@@ -11,6 +11,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 { encoderCpuBetween } from "./encoder-cpu.js";
 import { baseDrawFrom, costPerMegabyteFrom } from "../torrent-cost.js";
 import { medianOf, movedBeyondScatter, READINGS_KEPT, scatterOf } from "../learned-median.js";
 import { ENCODE_RUN_STATE, processCanBeSignalled } from "../encode-run-state.js";
@@ -532,17 +533,23 @@ export class HostLoad {
    * the only thing that would have taken the next reading.
    */
   async #learnIdleAvailability(watched, suspended) {
-    const system = (await this.#host.readSystemCpu?.()) ?? null;
-    const sample = { takenAt: Date.now(), system, proxyCpuSeconds: this.#host.readProxyCpuSeconds() };
+    const [system, endedChildren] = await Promise.all([
+      this.#host.readSystemCpu?.() ?? null,
+      this.#host.readEndedChildrenCpuSeconds?.() ?? null
+    ]);
+    const sample = { takenAt: Date.now(), system, endedChildren, byPid: new Map(), proxyCpuSeconds: this.#host.readProxyCpuSeconds() };
     const previous = this.#idleAvailabilitySample;
     this.#idleAvailabilitySample = sample;
     if (previous === null) {
       this.hostAvailability = availableShareFrom({});
       return;
     }
+    // Nothing runs at either reading, and a run may still have run between
+    // them: what it used is in the ended-children time (`encoder-cpu.js`).
+    const encoders = encoderCpuBetween(previous, sample);
     const share = this.#host.shareOfMachine(
       { takenAt: previous.takenAt, processCpuSeconds: 0, system: previous.system },
-      { takenAt: sample.takenAt, processCpuSeconds: 0, system: sample.system }
+      { takenAt: sample.takenAt, processCpuSeconds: encoders?.seconds ?? 0, system: sample.system }
     );
     const proxyShare = this.#setAvailability(share, previous, sample);
     // Said while something is watched, so what is free while every encoder
@@ -559,7 +566,7 @@ export class HostLoad {
    * and the processor share divide; `free` is what nothing used over the
    * interval. Unknown stays `n/a`, never zero.
    */
-  async #sayMachine(share, proxyShare, running, suspended) {
+  async #sayMachine(share, proxyShare, running, suspended, incomplete = false) {
     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
@@ -574,7 +581,8 @@ export class HostLoad {
     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(
-      `host-load: ffmpeg=${asPercent(share.processShare)} proxy=${asPercent(proxyShare)} ` +
+      `host-load: ffmpeg=${incomplete ? `at least ${asPercent(share.processShare)} (a run was not read; availability kept)` : asPercent(share.processShare)} ` +
+      `proxy=${asPercent(proxyShare)} ` +
       `system=${asPercent(share.systemShare)} ` +
       `iowait=${asPercent(share.iowaitShare)} cpu=${machine.megahertz === null ? "n/a" : `${machine.megahertz}MHz`} ` +
       `temp=${machine.celsius === null ? "n/a" : `${machine.celsius}C`} ` +
@@ -646,22 +654,28 @@ export class HostLoad {
     // alone would print something like `ffmpeg=-598%`. Only pids present in
     // BOTH readings are counted, so a process that came or went contributes
     // nothing rather than a lie.
-    const pids = encoding.flatMap((session) => this.#host.liveRunsOf(session).map((run) => run.process?.pid ?? null)).filter((pid) => pid !== null);
-    const [system, ...cpuReadings] = await Promise.all([
+    const runs = encoding.flatMap((session) => this.#host.liveRunsOf(session)).filter((run) => Number.isInteger(run.process?.pid));
+    const [system, endedChildren, ...cpuReadings] = await Promise.all([
       this.#host.readSystemCpu(),
-      ...pids.map((pid) => this.#host.readProcessCpuSeconds(pid))
+      this.#host.readEndedChildrenCpuSeconds?.() ?? null,
+      ...runs.map((run) => this.#host.readProcessCpuSeconds(run.process.pid))
     ]);
     /** @type {Map<number, number>} */
     const byPid = new Map();
-    pids.forEach((pid, index) => {
+    /** @type {Map<number, number>} */
+    const startedAt = new Map();
+    runs.forEach((run, index) => {
       const seconds = cpuReadings[index];
       if (seconds !== null) {
-        byPid.set(pid, seconds);
+        byPid.set(run.process.pid, seconds);
+        startedAt.set(run.process.pid, run.startedAt);
       }
     });
     const sample = {
       takenAt: Date.now(),
       byPid,
+      startedAt,
+      endedChildren,
       system,
       // The proxy's own CPU, across every thread: the torrent, the hashing, the
       // piece store and the delivery. None of it is in the encode budget, and
@@ -674,20 +688,14 @@ export class HostLoad {
     if (previous === null) {
       return false; // the first reading is only something to compare against
     }
-    // Summed over the pids both readings hold, so nothing is measured against a
-    // process that was not there before. Unknown stays unknown: on a host with
-    // no `/proc` there are no readings at all, and the share is null rather
-    // than a confident zero.
-    let encoderDelta = null;
-    for (const [pid, seconds] of sample.byPid) {
-      const before = previous.byPid?.get(pid);
-      if (before !== undefined && seconds >= before) {
-        encoderDelta = (encoderDelta ?? 0) + (seconds - before);
-      }
-    }
+    // Every process counted once, including runs that started or ended between
+    // the readings (`encoder-cpu.js`). Unknown stays unknown: on a host with no
+    // `/proc` there are no readings at all, and the share is null rather than a
+    // confident zero.
+    const encoders = encoderCpuBetween(previous, sample);
     const share = this.#host.shareOfMachine(
-      { takenAt: previous.takenAt, processCpuSeconds: encoderDelta === null ? null : 0, system: previous.system },
-      { takenAt: sample.takenAt, processCpuSeconds: encoderDelta, system: sample.system }
+      { takenAt: previous.takenAt, processCpuSeconds: encoders === null ? null : 0, system: previous.system },
+      { takenAt: sample.takenAt, processCpuSeconds: encoders?.seconds ?? null, system: sample.system }
     );
     if (share === null) {
       this.hostAvailability = availableShareFrom({});
@@ -701,6 +709,12 @@ export class HostLoad {
     // they stopped).
     const suspended = encoding.filter((session) => this.#host.runStateOf(session) === ENCODE_RUN_STATE.SUSPENDED).length;
     const running = encoding.length - suspended;
+    if (encoders && !encoders.complete) {
+      // A lower bound of our own load is not a reading of what other work left
+      // us: the last availability stands, and the line says so.
+      await this.#sayMachine(share, null, running, suspended, true);
+      return false;
+    }
     // Kept for the quality offer, which predicts from a benchmark taken on a
     // QUIET host: the same reading that is printed here says how much of the
     // machine a new encoder could actually have. Only what nobody has been

package/services/encode/quality/encoder-cpu.js

@@ -0,0 +1,66 @@
+/**
+ * @file The CPU this proxy's FFmpeg processes used between two readings of the
+ * machine (torrent-tv/meta#178).
+ *
+ * A process's own counter says what it used since it started, and is gone once
+ * it has ended. Counting only processes present in both readings left out every
+ * run that started or ended between them: on Home Assistant a run of one piece
+ * started and ended between two readings 5 s apart, used 6.65 s of CPU, and
+ * both readings said `ffmpeg=0%` (r41). The availability left to encoders is
+ * the machine's load less theirs, so an encoder left out made the machine look
+ * busier with other work than it was.
+ *
+ * So three parts, each counted once:
+ *  1. a process in both readings: what its counter moved;
+ *  2. a process started after the first reading: its whole counter;
+ *  3. a process that ended between them: what the kernel added to this
+ *     process's ended-children time (`cutime + cstime`), less what the first
+ *     reading already counted of it.
+ * A part that cannot be told — a process that was there but unread, an
+ * ended-children time that went back, no such time at all while a process
+ * ended — makes the answer incomplete: a lower bound, never a measured zero.
+ */
+
+/**
+ * @typedef {object} EncoderReading
+ * @property {number} takenAt - Wall clock, ms.
+ * @property {Map<number, number>} byPid - CPU seconds of each live FFmpeg process read.
+ * @property {Map<number, number>} [startedAt] - When each of them was spawned, wall clock ms.
+ * @property {number | null} endedChildren - This process's ended-children CPU seconds.
+ */
+
+/**
+ * @param {EncoderReading} previous
+ * @param {EncoderReading} sample
+ * @returns {{ seconds: number, complete: boolean } | null} Null when nothing at all was read.
+ */
+export function encoderCpuBetween(previous, sample) {
+  const endedKnown = Number.isFinite(previous.endedChildren) && Number.isFinite(sample.endedChildren);
+  if (sample.byPid.size === 0 && previous.byPid.size === 0 && !endedKnown) return null;
+  let seconds = 0, complete = true;
+  for (const [pid, now] of sample.byPid) {
+    const before = previous.byPid.get(pid);
+    if (before !== undefined) {
+      if (now >= before) seconds += now - before;
+      else complete = false;
+    } else if (sample.startedAt?.get(pid) > previous.takenAt) {
+      seconds += now;
+    } else {
+      complete = false;
+    }
+  }
+  let countedOfEnded = 0, ended = 0;
+  for (const [pid, before] of previous.byPid) {
+    if (sample.byPid.has(pid)) continue;
+    countedOfEnded += before;
+    ended += 1;
+  }
+  if (endedKnown) {
+    const rest = sample.endedChildren - previous.endedChildren - countedOfEnded;
+    if (rest >= 0) seconds += rest;
+    else complete = false;
+  } else if (ended > 0) {
+    complete = false;
+  }
+  return { seconds, complete };
+}

package/services/media/ContainerOrchestrator.js

@@ -136,10 +136,15 @@ export class ContainerOrchestrator {
     let lifetime = this.#lifetimes.get(key);
     if (!lifetime) this.#lifetimes.set(key, lifetime = {});
     const isCurrent = () => this.#lifetimes.get(key) === lifetime && params.isCurrent?.() !== false;
-    const previous = this.#reads.get(key) ?? Promise.resolve();
     // Reads of one file run one after another, so an answer can wait for every
     // read asked before it. Told to whoever asked, apart from the read itself,
     // because the two call for different remedies (torrent-tv/meta#166).
+    // A statement answered from what was already read reads and parses
+    // nothing, so it is answered beside the queue and holds nobody up: the
+    // picture's first input of an AVI waited about 4 s behind the sound's
+    // table of the whole film it does not use (r38, torrent-tv/meta#178).
+    const aside = this.#answersWithoutReading(key, statement);
+    const previous = aside ? Promise.resolve() : this.#reads.get(key) ?? Promise.resolve();
     const askedAt = Date.now();
     const reading = previous.catch(() => undefined).then(async () => {
       if (!isCurrent()) return { result: { kind: "terminal", reason: "request-obsolete", requestId: params.requestId } };
@@ -149,7 +154,7 @@ export class ContainerOrchestrator {
       params.onTimed?.(statement, startedAt - askedAt, Date.now() - startedAt);
       return { result, revision };
     });
-    this.#reads.set(key, reading);
+    if (!aside) this.#reads.set(key, reading);
     try {
       const { result, revision } = await reading;
       if (!isCurrent()) return { kind: "terminal", reason: "request-obsolete", requestId: params.requestId };
@@ -162,6 +167,12 @@ export class ContainerOrchestrator {
     }
   }
 
+  /** Whether a statement of this file is answered from what was already read: its track table kept here, or the container's word. */
+  #answersWithoutReading(key, statement) {
+    if (statement === "tracks" && this.tracks.has(key)) return true;
+    return this.cache.get(key)?.answersWithoutReading?.(statement) === true;
+  }
+
   async #inspectRead(params, statement) {
     const requestId = params.requestId ?? `${params.sourceKey}:${params.fileIndex}:${statement}`;
     this.#activityEpoch++;

package/services/media/container/AviContainer.js

@@ -42,6 +42,8 @@ export class AviContainer extends Container {
   #workTags = null;
   /** The index alone: undefined until read, null when the file states none. */
   #index = undefined;
+  /** The index while it is being read, so two asks read it once. */
+  #indexReading = null;
   #layout = null;
   /** The first RIFF's `idx1`: undefined until looked for, null when there is none. */
   #idx1Chunk = undefined;
@@ -167,6 +169,38 @@ export class AviContainer extends Container {
    */
   async #readIndex() {
     if (this.#index !== undefined) return this.#index;
+    // One reading for every asker: a read of the picture's ranges may now be
+    // answered beside the sound's table (`answersWithoutReading`), and two
+    // asks at once would each read the index and each hold its memory.
+    this.#indexReading ??= this.#readIndexOnce().finally(() => { this.#indexReading = null; });
+    return this.#indexReading;
+  }
+
+  /**
+   * Whether `statement` is answered from what this container has already
+   * read, without reading or parsing anything more — so it may be answered
+   * beside a read of the same file still in progress
+   * (`ContainerOrchestrator.inspect`). Field r38 (Home Assistant, 2026-10-14):
+   * the picture's first input waited about 4 s behind the sound's packet table
+   * of the whole film, which it does not use — its ranges are named from the
+   * index alone (`readSourceRanges`), while the table is the sound's
+   * (`readPacketIndex`), built in portions that give the thread back
+   * (torrent-tv/meta#178).
+   *
+   * Once the index has been read, so have the tracks and the place of `movi`
+   * it was read with, and the picture's statements read nothing else.
+   *
+   * @param {string} statement
+   * @returns {boolean}
+   */
+  answersWithoutReading(statement) {
+    if (statement === "media-info") return Boolean(this.mediaInfo);
+    if (statement === "source-navigation" || statement === "source-ranges") return this.#index !== undefined;
+    return false;
+  }
+
+  /** The index, read from the file; see `#readIndex`. */
+  async #readIndexOnce() {
     const tracks = await this.readTracks();
     const { streams } = await this.#readHeaders();
     const { movi } = await this.#topLevel();

package/services/server/wire-outputs.js

@@ -11,7 +11,7 @@
 import { logger } from "../../utils/logger.js";
 import { KeyframeTables } from "../media/KeyframeTables.js";
 import { waits } from "./WaitLedger.js";
-import { readMachineState, readProcessCpuSeconds, readProxyCpuSeconds, readSystemCpu, shareOfMachine } from "../encode/host-load.js";
+import { readEndedChildrenCpuSeconds, readMachineState, readProcessCpuSeconds, readProxyCpuSeconds, readSystemCpu, shareOfMachine } from "../encode/host-load.js";
 import { minimumBufferFrom } from "../torrent/supply-margin.js";
 import { PriorityOrchestrator } from "../viewer/PriorityOrchestrator.js";
 import { urgentOutputsReady } from "../viewer/urgent-output-ready.js";
@@ -290,6 +290,7 @@ export function wireOutputs({
   // What the torrent and the proxy itself spend on this host, and how fast each watched torrent moves.
   parts.hostLoad = new HostLoad({
     readMetadataActivity,
+    readEndedChildrenCpuSeconds,
     readMachineState,
     readProcessCpuSeconds,
     readProxyCpuSeconds,

package/services/torrent/download/SwarmSelection.js

@@ -46,6 +46,8 @@ export class SwarmSelection {
   #stated = new Map();
   /** Claimants whose windows are currently protected in memory. */
   #protectedInMemory = new Set();
+  /** The pieces of the urgent first class, as last stated: what somebody waits for now. */
+  #required = [];
   #findStore;
 
   /**
@@ -110,7 +112,10 @@ export class SwarmSelection {
         else union.push({ from: range.from, to: range.to, priority });
       }
       for (const range of union) wanted.set(`${range.from}-${range.to}-${priority}`, range);
-      if (priority === 1) this.firstClassPieces = union.map(range => range.from === range.to ? `${range.from}` : `${range.from}-${range.to}`);
+      if (priority === 1) {
+        this.firstClassPieces = union.map(range => range.from === range.to ? `${range.from}` : `${range.from}-${range.to}`);
+        this.#required = strictFirstClass ? union.map(({ from, to }) => ({ from, to })) : [];
+      }
     }
     this.firstClass = first;
 
@@ -150,8 +155,21 @@ export class SwarmSelection {
     return { stated, withdrawn };
   }
 
+  /**
+   * The pieces of the urgent first class as last stated, or none while the
+   * first class is conditional: what somebody is waiting for now, and the
+   * only pieces whose last blocks are worth asking of a second peer
+   * (`TailRepeat`).
+   *
+   * @returns {Array<{ from: number, to: number }>}
+   */
+  requiredPieces() {
+    return this.#required;
+  }
+
   /** Take everything back. The torrent is going, or nobody wants anything. */
   releaseAll() {
+    this.#required = [];
     for (const range of this.#stated.values()) {
       this.#deselect(range);
     }

package/services/torrent/piece-timing.js

@@ -20,10 +20,12 @@
  * @property {string | null} slowestPeer - Who sent that block.
  * @property {number} lastInFlightMs - How long the block that completed the piece was in flight.
  * @property {string | null} lastPeer - Who sent it.
+ * @property {number} askedAgain - Asks of a block already asked of another peer.
+ * @property {number} arrivedTwice - Blocks that arrived after a copy of them had, and were dropped.
  */
 
 export class PieceTimings {
-  /** @type {Map<number, { firstAskAt: number, asks: number, peers: Set<string>, blocks: Map<number, number>, slowestMs: number, slowestPeer: string | null, lastInFlightMs: number, lastPeer: string | null }>} */
+  /** @type {Map<number, { firstAskAt: number, asks: number, peers: Set<string>, blocks: Map<number, number>, arrived: Set<number>, askedAgain: number, arrivedTwice: number, slowestMs: number, slowestPeer: string | null, lastInFlightMs: number, lastPeer: string | null }>} */
   #pieces = new Map();
 
   /**
@@ -37,12 +39,14 @@ export class PieceTimings {
   asked(piece, offset, peer, now) {
     let record = this.#pieces.get(piece);
     if (!record) {
-      record = { firstAskAt: now, asks: 0, peers: new Set(), blocks: new Map(), slowestMs: 0, slowestPeer: null, lastInFlightMs: 0, lastPeer: null };
+      record = { firstAskAt: now, asks: 0, peers: new Set(), blocks: new Map(), arrived: new Set(), askedAgain: 0, arrivedTwice: 0,
+        slowestMs: 0, slowestPeer: null, lastInFlightMs: 0, lastPeer: null };
       this.#pieces.set(piece, record);
     }
     record.asks += 1;
     record.peers.add(peer);
     if (!record.blocks.has(offset)) record.blocks.set(offset, now);
+    else record.askedAgain += 1;
   }
 
   /**
@@ -58,6 +62,13 @@ export class PieceTimings {
     const record = this.#pieces.get(piece);
     const askedAt = record?.blocks.get(offset);
     if (askedAt === undefined) return;
+    // A copy of a block that had already arrived is dropped by the piece; its
+    // bytes are what asking a second peer cost.
+    if (record.arrived.has(offset)) {
+      record.arrivedTwice += 1;
+      return;
+    }
+    record.arrived.add(offset);
     const inFlightMs = now - askedAt;
     if (inFlightMs >= record.slowestMs) {
       record.slowestMs = inFlightMs;
@@ -86,7 +97,9 @@ export class PieceTimings {
       slowestMs: record.slowestMs,
       slowestPeer: record.slowestPeer,
       lastInFlightMs: record.lastInFlightMs,
-      lastPeer: record.lastPeer
+      lastPeer: record.lastPeer,
+      askedAgain: record.askedAgain,
+      arrivedTwice: record.arrivedTwice
     };
   }
 }
@@ -101,5 +114,7 @@ export function describePieceTiming(timing) {
   if (!timing) return "";
   return `; first block asked ${(timing.askedAgoMs / 1000).toFixed(1)}s before, ${timing.asks} block ask(s) to ${timing.peers} peer(s), ` +
     `slowest block ${(timing.slowestMs / 1000).toFixed(1)}s in flight from ${timing.slowestPeer ?? "?"}, ` +
-    `the last one ${(timing.lastInFlightMs / 1000).toFixed(1)}s from ${timing.lastPeer ?? "?"}`;
+    `the last one ${(timing.lastInFlightMs / 1000).toFixed(1)}s from ${timing.lastPeer ?? "?"}` +
+    (timing.askedAgain > 0 || timing.arrivedTwice > 0
+      ? `, ${timing.askedAgain} block(s) asked again, ${timing.arrivedTwice} arrived twice` : "");
 }

package/services/torrent/torrent-pool.js

@@ -25,6 +25,22 @@ import { deadlineOfMapZone, levelOfMapZone, priorityOfMapZone } from "./map-zone
 import { deriveSourceKey } from "../../utils/torrent-source-key.js";
 import { noteTorrentDestroyed } from "./destroyed-torrents.js";
 import { PieceTimings, describePieceTiming } from "./piece-timing.js";
+import { TailRepeat } from "./worker/tail-repeat.js";
+
+/**
+ * The second-peer requests for the last blocks of a piece somebody waits for,
+ * one per torrent, made when the torrent is first watched and stopped when it
+ * is forgotten (`worker/tail-repeat.js`).
+ *
+ * @type {WeakMap<object, TailRepeat>}
+ */
+const tailRepeats = new WeakMap();
+
+/** Stop asking second peers for a torrent that is going. */
+function dropTailRepeat(torrent) {
+  tailRepeats.get(torrent)?.dispose();
+  tailRepeats.delete(torrent);
+}
 
 /** How a window stated from the priority map names itself. */
 const MAP_CLAIMANT = "priority-map";
@@ -1353,6 +1369,8 @@ export class TorrentPool {
     // swarm went on fetching the old first class for 1.16 s, until the next
     // piece happened to be verified (r34, torrent-tv/meta#178).
     reconcileAll();
+    // And a new map may make other pieces the ones somebody waits for.
+    tailRepeats.get(torrent)?.poke();
     // WHAT THE SWARM WAS ACTUALLY TOLD, said on change and never on a timer.
     // The map was applied in silence: that it had been BUILT was visible in the
     // encoding's own line, and that the download had received it was visible
@@ -1515,6 +1533,8 @@ export class TorrentPool {
     // its blocks were in flight, and from whom (`piece-timing.js`). One line
     // per piece: a 2.3 GB film is 563.
     const timings = new PieceTimings();
+    tailRepeats.set(torrent, new TailRepeat({ torrent, requiredPieces: () => demandFor(torrent).selection.requiredPieces(),
+      log: (line) => logger.info(`download ${label()} ${line}`) }));
     torrent.on("wire", (wire) => {
       // WebTorrent asks a wire for a block by calling `request` and states
       // nothing; a request the wire refuses (choked, closed) is not queued and
@@ -1963,6 +1983,7 @@ export class TorrentPool {
       return;
     }
     forgetTorrent(torrent);
+    dropTailRepeat(torrent);
     this.#forgetBookkeeping(torrent);
     const name = typeof torrent.name === "string" ? torrent.name : "(unknown)";
     logger.warn(
@@ -2008,6 +2029,7 @@ export class TorrentPool {
   #removeTorrent(torrent, reason = "unknown") {
     // Everything anybody stated for this torrent goes with it.
     forgetTorrent(torrent);
+    dropTailRepeat(torrent);
     if (!torrent) {
       return;
     }

package/services/torrent/worker/fastest-wires.js

@@ -37,6 +37,9 @@
  */
 const SHORT_TAIL_BLOCKS = 16;
 
+/** A block of a piece, as `torrent-piece` cuts it (`Piece.BLOCK_LENGTH`): a request's offset over this is its block. */
+const BLOCK_BYTES = 1 << 14;
+
 /**
  * The library's own request entry. Internal, so its absence must be noticed
  * rather than swallowed: without it this lever silently does nothing.
@@ -248,10 +251,10 @@ export function describePieceTail(torrent, pieceIndex) {
  * work, which no average speed can show.
  *
  * The cost is bounded by the same measurement: the tails were 2 to 14 blocks of
- * 512, so 32 to 224 KB against the 8 MiB piece they hold up. At most one
- * duplicate is asked per candidate wire per call, and the caller repeats every
- * half second, so a longer tail is covered across attempts rather than in one
- * burst.
+ * 512, so 32 to 224 KB against the 8 MiB piece they hold up. A block already in
+ * flight on `maxCopies` wires is not asked again, however often this is called:
+ * it is called on every block that arrives (`TailRepeat`), and without that
+ * check each call asked one more copy of the same block.
  *
  * Safe against the completion path: a block that arrives twice is dropped by
  * `Piece.set`, which writes only into an empty slot, and a piece already
@@ -260,17 +263,26 @@ export function describePieceTail(torrent, pieceIndex) {
  *
  * @param {object} torrent
  * @param {number} pieceIndex
- * @returns {{ duplicated: number, missing: number, wires: number }}
+ * @param {object} [options]
+ * @param {number} [options.maxCopies] - How many wires a missing block may be
+ *   in flight on at once: the first request and one copy beside it.
+ * @returns {{ duplicated: number, missing: number, wires: number, unplaced: number }}
  *   `duplicated` counts requests the library actually placed for a block that
- *   was already outstanding elsewhere.
+ *   was already outstanding elsewhere; `unplaced` the blocks in flight on one
+ *   wire alone that no other wire could be asked for now.
  */
-export function duplicateTailFor(torrent, pieceIndex) {
+export function duplicateTailFor(torrent, pieceIndex, { maxCopies = 2 } = {}) {
   const piece = torrent?.pieces?.[pieceIndex];
   const buffer = Array.isArray(piece?._buffer) ? piece._buffer : null;
-  if (!piece || !buffer || typeof piece.cancel !== "function") {
-    return { duplicated: 0, missing: 0, wires: 0 };
+  if (!piece || !buffer || typeof piece.cancel !== "function" || !canPlaceRequests(torrent)) {
+    return { duplicated: 0, missing: 0, wires: 0, unplaced: 0 };
   }
   const chunks = Number.isFinite(piece._chunks) ? piece._chunks : buffer.length;
+  // Most calls are for a piece still arriving in bulk; its own count says so
+  // without walking its blocks or every wire's queue.
+  if (Number.isFinite(piece._buffered) && chunks - piece._buffered > SHORT_TAIL_BLOCKS) {
+    return { duplicated: 0, missing: chunks - piece._buffered, wires: 0, unplaced: 0 };
+  }
   const missing = [];
   for (let index = 0; index < chunks; index += 1) {
     if (!buffer[index]) {
@@ -279,7 +291,7 @@ export function duplicateTailFor(torrent, pieceIndex) {
   }
   const candidates = wiresForPiece(torrent, pieceIndex);
   if (missing.length === 0 || candidates.length === 0) {
-    return { duplicated: 0, missing: missing.length, wires: candidates.length };
+    return { duplicated: 0, missing: missing.length, wires: candidates.length, unplaced: 0 };
   }
 
   // A tail this short is what a blocked read is actually waiting on, and a
@@ -288,31 +300,50 @@ export function duplicateTailFor(torrent, pieceIndex) {
   // bytes that are already coming — measured 2026-08-19, the tails a reader
   // waits on are 2 to 14 blocks of 512.
   if (missing.length > SHORT_TAIL_BLOCKS) {
-    return { duplicated: 0, missing: missing.length, wires: candidates.length };
+    return { duplicated: 0, missing: missing.length, wires: candidates.length, unplaced: 0 };
+  }
+
+  // Which wires each missing block is in flight on, read from the wires' own
+  // queues: the library keeps a block's reservation for one wire only, and a
+  // copy asked here is visible nowhere else.
+  const holders = new Map(missing.map(block => [block, new Set()]));
+  for (const wire of Array.isArray(torrent.wires) ? torrent.wires : []) {
+    for (const request of Array.isArray(wire?.requests) ? wire.requests : []) {
+      if (request?.piece !== pieceIndex) continue;
+      holders.get(Math.floor(request.offset / BLOCK_BYTES))?.add(wire);
+    }
   }
 
-  let duplicated = 0;
-  // One block per wire: that is what the pipelines can usefully take at once,
-  // and it needs no number of its own.
-  for (let index = 0; index < Math.min(missing.length, candidates.length); index += 1) {
-    // Freeing the reservation is what makes the block askable again; the
-    // request already in flight is deliberately left alone, because the point
-    // is to have two of them.
-    piece.cancel(missing[index]);
-    // `false` is hotswap: the library's own swap must not run on top of this,
-    // or it would free a THIRD wire's block as well.
-    if (torrent._request(candidates[index], pieceIndex, false) === true) {
-      duplicated += 1;
+  let duplicated = 0, unplaced = 0;
+  for (const block of missing) {
+    const held = holders.get(block);
+    // Not in flight anywhere: the library's own picker asks for it; a block
+    // nobody has been asked for is not a tail held by a slow peer.
+    if (held.size === 0 || held.size >= maxCopies) continue;
+    let placed = false;
+    for (const wire of candidates) {
+      if (held.has(wire)) continue;
+      // Freeing the reservation is what makes the block askable again; the
+      // request already in flight is deliberately left alone, because the
+      // point is to have two of them.
+      piece.cancel(block);
+      // `false` is hotswap: the library's own swap must not run on top of
+      // this, or it would free a THIRD wire's block as well.
+      if (torrent._request(wire, pieceIndex, false) === true) {
+        held.add(wire);
+        duplicated += 1;
+        placed = true;
+        break;
+      }
+      // Refused before anything was reserved (that wire's pipeline is full):
+      // the freed block is taken back, or the library would hand it to the
+      // next wire that asks, a copy nobody counted. The next wire's pipeline
+      // is its own, so it is still asked.
+      piece.reserve();
     }
-    // A refusal means THAT wire's pipeline is full, and says nothing about the
-    // next one's — pipelines are per wire. This used to stop the whole pass on
-    // the first refusal, on the stated reasoning that the remaining wires were
-    // "no emptier", which is an assumption about other peers' queues that
-    // nothing here measures. The block whose reservation was freed stays in the
-    // piece's cancellation stack and is handed to whoever asks next, which is
-    // harmless: it is already in flight elsewhere.
+    if (!placed) unplaced += 1;
   }
-  return { duplicated, missing: missing.length, wires: candidates.length };
+  return { duplicated, missing: missing.length, wires: candidates.length, unplaced };
 }
 
 /**

package/services/torrent/worker/tail-repeat.js

@@ -0,0 +1,154 @@
+/**
+ * @file Ask a second peer for the last blocks of a piece somebody is waiting
+ * for, when one slow peer holds them (torrent-tv/meta#178).
+ *
+ * Field r40 (Home Assistant, 2026-10-14, a cold 1080p MKV): the first run's
+ * input waited 10.0 s, last for piece 8, whose slowest block was 4.5 s in
+ * flight from one peer; pieces 14-16 waited 10.0-11.5 s on one peer each. A
+ * block is reserved for one wire, and the piece completes when its slowest
+ * holder delivers (`duplicateTailFor`). Nothing had asked a second peer since
+ * the blocked-read path that did so was removed (`0e38ec3`, torrent-tv/meta#95).
+ *
+ * Which pieces: those of the urgent first class the swarm was last told
+ * (`SwarmSelection.requiredPieces`) — what somebody waits for now. A map that
+ * withdraws them, or an input that is ready, takes them out, and nothing more
+ * is asked for them.
+ *
+ * When: a tail changes when a block arrives, a wire's queue moves on, or a
+ * peer becomes able or unable to give the piece; so it is looked at on those —
+ * a block arriving, a wire unchoking, a peer stating a piece, a wire joining
+ * or closing, a piece verified, a new map. Several in one turn of the event
+ * loop are one look. A tail no other wire could be asked for now is looked at
+ * once more after the time a wire's queue is sized to empty in — WebTorrent
+ * sizes it to one second of the wire's speed (`PIPELINE_MAX_DURATION`) — in
+ * case nothing else happens in between.
+ */
+
+import { duplicateTailFor } from "./fastest-wires.js";
+
+/** WebTorrent's `PIPELINE_MAX_DURATION`: a wire is given one second of its speed to fetch. */
+const WIRE_QUEUE_SECONDS = 1;
+
+/** What a wire says, besides a block arriving, that can change who could be asked for a piece. */
+const WIRE_EVENTS = ["unchoke", "have", "bitfield"];
+
+export class TailRepeat {
+  #torrent;
+  #requiredPieces;
+  #duplicate;
+  #schedule;
+  #wake;
+  #clear;
+  #scheduled = false;
+  #timer = null;
+  #disposed = false;
+  /** @type {Map<object, { onBlock: (index: number) => void, onPeer: () => void }>} */
+  #wires = new Map();
+  #onWire;
+  #onPoke;
+  #log;
+  /**
+   * Grow-only, for the log: block copies asked, looks taken, and blocks that
+   * arrived after their piece was complete — what the copies cost.
+   */
+  totals = { duplicated: 0, looks: 0, lateBlocks: 0 };
+
+  /**
+   * @param {object} params
+   * @param {object} params.torrent
+   * @param {() => Array<{ from: number, to: number }>} params.requiredPieces
+   * @param {typeof duplicateTailFor} [params.duplicate]
+   * @param {(work: () => void) => void} [params.schedule] - Runs work once this turn of the event loop is over.
+   * @param {(work: () => void, ms: number) => unknown} [params.wake]
+   * @param {(handle: unknown) => void} [params.clear]
+   * @param {(line: string) => void} [params.log]
+   */
+  constructor({ torrent, requiredPieces, duplicate = duplicateTailFor, schedule = setImmediate, wake = setTimeout, clear = clearTimeout, log = null }) {
+    this.#log = log;
+    this.#torrent = torrent;
+    this.#requiredPieces = requiredPieces;
+    this.#duplicate = duplicate;
+    this.#schedule = schedule;
+    this.#wake = wake;
+    this.#clear = clear;
+    this.#onWire = (wire) => this.#watch(wire);
+    this.#onPoke = () => this.poke();
+    torrent.on?.("wire", this.#onWire);
+    torrent.on?.("verified", this.#onPoke);
+    for (const wire of Array.isArray(torrent.wires) ? torrent.wires : []) this.#watch(wire);
+  }
+
+  /** Look at the tails once this turn of the event loop is over. */
+  poke() {
+    if (this.#scheduled || this.#disposed) return;
+    this.#scheduled = true;
+    this.#schedule(() => this.#look());
+  }
+
+  /** Stop watching: the torrent is going. */
+  dispose() {
+    this.#disposed = true;
+    this.#torrent.removeListener?.("wire", this.#onWire);
+    this.#torrent.removeListener?.("verified", this.#onPoke);
+    for (const wire of [...this.#wires.keys()]) this.#forget(wire);
+    if (this.#timer !== null) this.#clear(this.#timer);
+    this.#timer = null;
+  }
+
+  #watch(wire) {
+    if (!wire || this.#wires.has(wire) || typeof wire.on !== "function") return;
+    const listeners = {
+      onBlock: (index) => {
+        // A block of a piece already verified is a copy that came second; the
+        // block that completes a piece arrives before the piece is verified.
+        if (Number.isInteger(index) && this.#torrent.bitfield?.get?.(index)) this.totals.lateBlocks += 1;
+        this.poke();
+      },
+      onPeer: () => this.poke()
+    };
+    this.#wires.set(wire, listeners);
+    wire.on("piece", listeners.onBlock);
+    for (const event of WIRE_EVENTS) wire.on(event, listeners.onPeer);
+    wire.once?.("close", () => {
+      this.#forget(wire);
+      this.poke();
+    });
+    this.poke();
+  }
+
+  #forget(wire) {
+    const listeners = this.#wires.get(wire);
+    if (!listeners) return;
+    wire.removeListener?.("piece", listeners.onBlock);
+    for (const event of WIRE_EVENTS) wire.removeListener?.(event, listeners.onPeer);
+    this.#wires.delete(wire);
+  }
+
+  #look() {
+    this.#scheduled = false;
+    if (this.#disposed) return;
+    this.totals.looks += 1;
+    let unplaced = 0;
+    const asked = [];
+    for (const { from, to } of this.#requiredPieces()) {
+      for (let index = from; index <= to; index += 1) {
+        if (this.#torrent.bitfield?.get?.(index)) continue;
+        const result = this.#duplicate(this.#torrent, index);
+        this.totals.duplicated += result.duplicated;
+        unplaced += result.unplaced;
+        if (result.duplicated > 0) asked.push(`${index}:${result.duplicated}/${result.missing}`);
+      }
+    }
+    if (asked.length > 0) {
+      this.#log?.(`tail: asked a second peer for the last blocks of piece:blocks/missing ${asked.join(" ")}; ` +
+        `${this.totals.duplicated} block copies asked so far, ${this.totals.lateBlocks} block(s) arrived after their piece was complete`);
+    }
+    if (unplaced > 0 && this.#timer === null) {
+      this.#timer = this.#wake(() => {
+        this.#timer = null;
+        this.poke();
+      }, WIRE_QUEUE_SECONDS * 1000);
+      this.#timer?.unref?.();
+    }
+  }
+}