@torrent-tv/proxy 2.107.51 → 2.107.53

package/services/viewer/ViewerPlaybackState.js

@@ -0,0 +1,215 @@
+/**
+ * Cross-request measurements owned by one live viewing. A viewer is the key,
+ * rather than its reusable wire id, so a later viewing with the same id starts
+ * with fresh measurements.
+ */
+export class ViewerPlaybackState {
+  #byViewer = new Map();
+  #waitOrder = new Map();
+
+  #stateFor(viewer, create = false) {
+    if (!viewer || typeof viewer !== "object") return null;
+    let state = this.#byViewer.get(viewer);
+    if (!state && create) {
+      state = { ratesByOutput: new Map(), waits: new Map() };
+      this.#byViewer.set(viewer, state);
+    }
+    return state ?? null;
+  }
+
+  rateState(viewer, output, playbackReadiness, lookaheadSeconds) {
+    const owner = this.#stateFor(viewer, true);
+    let state = owner.ratesByOutput.get(output);
+    if (!state) {
+      state = { link: new playbackReadiness.RateTrend(lookaheadSeconds), sources: new Map() };
+      owner.ratesByOutput.set(output, state);
+    }
+    return state;
+  }
+
+  owns(viewer, output, state) {
+    return this.#stateFor(viewer)?.ratesByOutput.get(output) === state;
+  }
+
+  forgetOutput(output) {
+    for (const [viewer, owner] of this.#byViewer) {
+      owner.ratesByOutput.delete(output);
+      this.#deleteIfEmpty(viewer, owner);
+    }
+  }
+
+  forgetViewerOutput(viewer, output) {
+    const owner = this.#stateFor(viewer);
+    if (!owner) return false;
+    const removed = owner.ratesByOutput.delete(output);
+    this.#deleteIfEmpty(viewer, owner);
+    return removed;
+  }
+
+  addLinkReading(state, at, mbps) {
+    state.link.add(at, mbps * 1_000_000);
+  }
+
+  sourceRateReadings(state, id, stats, now, playbackReadiness, lookaheadSeconds) {
+    let source = state.sources.get(id);
+    if (!source) {
+      const { RateTrend, SessionRate } = playbackReadiness;
+      source = { delivered: new RateTrend(lookaheadSeconds), free: new RateTrend(lookaheadSeconds),
+        deliveredAll: new SessionRate(), freeAll: new SessionRate(), limit: null };
+      state.sources.set(id, source);
+    }
+    if (Number.isFinite(stats?.downloadSpeed) && stats.downloadSpeed >= 0) {
+      source.delivered.add(now, stats.downloadSpeed);
+      source.deliveredAll.add(now, stats.downloadSpeed);
+    }
+    const limit = stats?.selectionLimit;
+    if (limit && source.limit && limit.freeMs > source.limit.freeMs) {
+      const free = Math.max(0, limit.freeBytes - source.limit.freeBytes) * 1000 / (limit.freeMs - source.limit.freeMs);
+      source.free.add(now, free);
+      source.freeAll.add(now, free);
+    }
+    if (limit) source.limit = limit;
+    return sourceService(source.free.snapshot(), source.delivered.snapshot(),
+      summary => playbackReadiness.forecastRate(summary, now, 0, "time"));
+  }
+
+  sourceTailRateReadings(state, id, now, playbackReadiness) {
+    const source = state.sources.get(id);
+    if (!source) return null;
+    return sourceService(source.freeAll.snapshot(), source.deliveredAll.snapshot(),
+      summary => playbackReadiness.forecastRate(summary, now, 0, "time"));
+  }
+
+  sourceRateSummaries(state, id) {
+    const source = state.sources.get(id);
+    return source ? { free: source.free.snapshot(), delivered: source.delivered.snapshot() } : null;
+  }
+
+  getWait(viewer, waitId) {
+    return this.#stateFor(viewer)?.waits.get(waitId) ?? null;
+  }
+
+  hasWait(viewer, waitId) {
+    return this.#stateFor(viewer)?.waits.has(waitId) ?? false;
+  }
+
+  recordWaitSnapshot({ viewer, consumerId, generation, sourceKey, fileIndex, waitId, features }) {
+    const owner = this.#stateFor(viewer, true);
+    const current = owner.waits.get(waitId);
+    const context = current?.waitId === waitId ? current : {
+      consumerId, generation, sourceKey, fileIndex, waitId, snapshots: [], observedWaits: new Set()
+    };
+    const measuredAt = performance.now();
+    const ageElapsedMs = Number.isFinite(context.featuresMeasuredAt)
+      ? Math.max(0, measuredAt - context.featuresMeasuredAt) : 0;
+    const mergedFeatures = mergeWaitFeatures(context.features, features, ageElapsedMs);
+    Object.assign(context, { consumerId, generation, sourceKey, fileIndex, waitId, features: mergedFeatures,
+      featuresMeasuredAt: measuredAt, updatedAt: Date.now() });
+    const previous = context.snapshots.at(-1);
+    if (!previous || JSON.stringify(previous) !== JSON.stringify(mergedFeatures)) {
+      const snapshot = { ...mergedFeatures };
+      if (context.snapshots.length < 2) context.snapshots.push(snapshot);
+      else context.snapshots[1] = snapshot;
+    }
+    owner.waits.set(waitId, context);
+    if (!this.#waitOrder.has(context)) this.#waitOrder.set(context, { viewer, waitId });
+    return context;
+  }
+
+  noteFirstFrame({ viewer, generation, waitId, wait, elapsedMs, stages, record }) {
+    const observation = this.getWait(viewer, waitId);
+    if (!observation || observation.generation !== generation || !Number.isSafeInteger(wait) || wait < 0 ||
+        observation.observedWaits.has(wait) || !Number.isFinite(elapsedMs) || elapsedMs < 0) return false;
+    const initialFeatures = observation.snapshots[0];
+    if (initialFeatures) record({ seconds: elapsedMs / 1000, features: initialFeatures,
+      featureSnapshots: observation.snapshots.slice(1), stages });
+    observation.observedWaits.add(wait);
+    observation.updatedAt = Date.now();
+    return true;
+  }
+
+  deleteWait(viewer, waitId) {
+    const owner = this.#stateFor(viewer);
+    if (!owner) return false;
+    const context = owner.waits.get(waitId);
+    const removed = owner.waits.delete(waitId);
+    if (context) this.#waitOrder.delete(context);
+    this.#deleteIfEmpty(viewer, owner);
+    return removed;
+  }
+
+  pruneWaits(now = Date.now(), maxObservations = 1000) {
+    const cutoff = now - 30 * 60_000;
+    for (const [viewer, owner] of this.#byViewer) {
+      for (const [waitId, value] of owner.waits) {
+        if (value.updatedAt < cutoff) {
+          owner.waits.delete(waitId);
+          this.#waitOrder.delete(value);
+        }
+      }
+      if (owner) this.#deleteIfEmpty(viewer, owner);
+    }
+    while (this.#waitOrder.size > maxObservations) {
+      const [context, { viewer, waitId }] = this.#waitOrder.entries().next().value;
+      const owner = this.#stateFor(viewer);
+      owner?.waits.delete(waitId);
+      this.#waitOrder.delete(context);
+      if (owner) this.#deleteIfEmpty(viewer, owner);
+    }
+  }
+
+  forgetViewer(viewer) {
+    const owner = this.#stateFor(viewer);
+    if (!owner) return false;
+    for (const context of owner.waits.values()) this.#waitOrder.delete(context);
+    return this.#byViewer.delete(viewer);
+  }
+
+  viewerCount() {
+    return this.#byViewer.size;
+  }
+
+  waitCount(viewer) {
+    return this.#stateFor(viewer)?.waits.size ?? 0;
+  }
+
+  #deleteIfEmpty(viewer, owner) {
+    if (owner.ratesByOutput.size === 0 && owner.waits.size === 0) this.#byViewer.delete(viewer);
+  }
+}
+
+export function sourceService(free, delivered, rateOf) {
+  if (!free) return delivered;
+  if (!delivered) return free;
+  return (rateOf(delivered) ?? 0) > (rateOf(free) ?? 0) ? delivered : free;
+}
+
+function mergeWaitFeatures(previous, incoming, ageElapsedMs) {
+  const merged = { ...(previous ?? {}) };
+  for (const [key, value] of Object.entries(incoming ?? {})) {
+    if (value === null || value === undefined) {
+      if (!Object.hasOwn(merged, key)) merged[key] = null;
+      continue;
+    }
+    if (key === "extension") {
+      if (typeof value === "string" && value.length > 0) merged[key] = value;
+      continue;
+    }
+    if (key === "fileAvailable") {
+      if (typeof value === "boolean") merged[key] = value;
+      continue;
+    }
+    if (key === "videoOperation" || key === "audioOperation") {
+      if (value === "copy" || value === "encode") merged[key] = value;
+      continue;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0 ||
+        ((key === "fileLength" || key === "linkMbps") && value === 0)) continue;
+    merged[key] = value;
+  }
+  const hasIncomingAge = Number.isFinite(incoming?.linkSampleAgeMs) && incoming.linkSampleAgeMs >= 0;
+  if (Number.isFinite(merged.linkSampleAgeMs) && !hasIncomingAge) {
+    merged.linkSampleAgeMs += Number.isFinite(ageElapsedMs) ? Math.max(0, ageElapsedMs) : 0;
+  }
+  return merged;
+}

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

@@ -1,398 +0,0 @@
-/**
- * @file Put the piece a reader is blocked on onto the fastest wires that hold
- * it.
- *
- * Measured 2026-08-17: the swarm delivered 5.1-5.9 MB/s against a film consumed
- * at about 1 MB/s — a fivefold surplus — and the reader still blocked 47 times
- * in two minutes, 1.0-4.5 s each. So the shortage is not bandwidth. The piece
- * that blocked had been requested from a median of five peers, and what set the
- * tail was WHICH wire held the last outstanding block: a block is reserved for
- * exactly one wire, and the read finishes when the slowest holder delivers.
- *
- * What the library already does, and what it does not: `torrent.critical()`
- * (which the reader already sets over its window) enables HOTSWAP — an idle
- * wire may take a block away from the SLOWEST holder. It does not duplicate:
- * `piece.reserve()` returns -1 once every block is spoken for, and the
- * end-game that would ask a second peer for the same block is commented out in
- * `webtorrent/lib/torrent.js`. Hotswap therefore fires only when the library's
- * own picker happens to visit an idle wire while our piece is critical.
- *
- * This asks for it on purpose, and chooses who: the wires that are unchoked,
- * hold the piece and are measurably fastest are handed the piece through the
- * same entry the library's picker uses, with hotswap enabled. Nothing is
- * duplicated and no protocol rule is bent — the block moves to a faster holder
- * instead of staying with whoever got it first.
- */
-
-/**
- * How short a piece's remaining tail must be for a second copy of it to be
- * worth asking for.
- *
- * Sixteen blocks is 256 KB against the 4-16 MB piece they hold up. The figure
- * comes from what was measured rather than chosen for roundness: the tails a
- * blocked reader waits on were 2 to 14 blocks of 512 on 2026-08-19, and 3 of
- * 512 in the field failure of 2026-09-03 that took 46.3 s. Above this the piece
- * is still arriving normally and duplicating would spend the shared link on
- * bytes already on their way.
- */
-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.
- *
- * @param {object} torrent
- * @returns {boolean}
- */
-export function canPlaceRequests(torrent) {
-  return typeof torrent?._request === "function";
-}
-
-/**
- * Wires that could deliver this piece right now, fastest first.
- *
- * Excluded, each for its own reason: a wire that is choking us cannot be asked
- * at all; one that does not hold the piece has nothing to give; a destroyed one
- * is a corpse. Speed is the library's own measurement over its own window, so
- * nothing here needs a history of its own.
- *
- * @param {object} torrent
- * @param {number} pieceIndex
- * @returns {object[]}
- */
-export function wiresForPiece(torrent, pieceIndex) {
-  const wires = Array.isArray(torrent?.wires) ? torrent.wires : [];
-  const usable = [];
-  for (const wire of wires) {
-    if (!wire || wire.destroyed || wire.peerChoking) {
-      continue;
-    }
-    if (wire.peerPieces?.get?.(pieceIndex) !== true) {
-      continue;
-    }
-    usable.push(wire);
-  }
-  return usable.sort((left, right) => speedOf(right) - speedOf(left));
-}
-
-/**
- * A wire's measured download speed in bytes per second, or 0 when it has not
- * been measured. Wrapped because `downloadSpeed` is a method on the wire and a
- * throw from a destroyed one must not take the caller with it.
- *
- * @param {object} wire
- * @returns {number}
- */
-function speedOf(wire) {
-  try {
-    const speed = wire?.downloadSpeed?.();
-    return Number.isFinite(speed) ? speed : 0;
-  } catch {
-    // A wire that cannot say how fast it is ranks last, which is the honest
-    // answer — and the caller's own log line reports how many were asked.
-    return 0;
-  }
-}
-
-/**
- * Ask the fastest holders of `pieceIndex` for it.
- *
- * @param {object} torrent
- * @param {number} pieceIndex
- * @param {number} [limit] - How many wires to push it onto.
- * @returns {{ asked: number, refusedWhileReserved: number, attempted: number, considered: number, fastestBytesPerSecond: number }}
- *   `asked` counts requests the library actually placed: it refuses when a
- *   wire's pipeline is full or when nothing can be reserved even with hotswap,
- *   and that refusal is information — a piece nobody can be asked for is
- *   waiting on the wire, not on the picker.
- */
-export function askFastestWiresFor(torrent, pieceIndex, limit = 3) {
-  if (!canPlaceRequests(torrent) || !Number.isInteger(pieceIndex) || pieceIndex < 0) {
-    return { asked: 0, refusedWhileReserved: 0, attempted: 0, considered: 0, fastestBytesPerSecond: 0 };
-  }
-  const candidates = wiresForPiece(torrent, pieceIndex);
-  let asked = 0;
-  let refusedWhileReserved = 0;
-  for (const wire of candidates.slice(0, Math.max(1, limit))) {
-    try {
-      // `true` is hotswap: if every block is reserved, take one from the
-      // slowest holder. That is the whole point — the reader is blocked
-      // precisely because a slow holder has one.
-      if (torrent._request(wire, pieceIndex, true) === true) {
-        asked += 1;
-      } else {
-        // Refused. Two reasons and they are different: this wire's pipeline is
-        // full, or every block of the piece is reserved and displacement did
-        // not happen. The second is the interesting one, because the thresholds
-        // that decide it are constants inside the library and not settings — a
-        // holder at 50 KB/s is just above the 48 KB/s line and is never
-        // displaced, however long the piece has been waited for. This counter
-        // is what would justify replacing `_hotswap` on the torrent, and
-        // without it that would be a change made on a hunch.
-        if (pieceIsFullyReserved(torrent, pieceIndex)) {
-          refusedWhileReserved += 1;
-        }
-      }
-    } catch (error) {
-      // Internal call: report it once per attempt rather than letting the lever
-      // fail in silence.
-      throw new Error(`could not place a request for piece ${pieceIndex}: ${error?.message ?? error}`);
-    }
-  }
-  return {
-    asked,
-    refusedWhileReserved,
-    considered: candidates.length,
-    // How many of the asks the library placed, against how many it was asked
-    // for. The caller sums these over the whole wait, and summing `asked`
-    // against a `considered` taken from the LAST attempt is how the field log
-    // came to read "steered onto 12 of 6 holders" — a ratio of two different
-    // things. Both halves are returned per attempt so the caller can add each
-    // to its own total.
-    attempted: Math.min(candidates.length, Math.max(1, limit)),
-    fastestBytesPerSecond: candidates.length > 0 ? speedOf(candidates[0]) : 0
-  };
-}
-
-/**
- * What is actually holding up a piece the reader is blocked on.
- *
- * The steering above can only move a block that the library will hand over, and
- * the field says it often hands over nothing: `steered onto 0 of 9 asks (8
- * peers held it)`, recorded 2026-08-18 while eight peers had the piece. When
- * every block of a piece is already reserved, `Piece.reserve()` answers -1 and
- * there is no request left to place — the read then ends when the SLOWEST
- * holder delivers its block, however fast the rest of the swarm is.
- *
- * Duplicating those last blocks onto faster wires is the standard remedy, and
- * it is not free: every duplicate is a block's worth of traffic paid twice. So
- * this describes the tail before anything is built with it — how many blocks
- * are still missing, and on which wires they sit, with each wire's speed. If
- * the missing blocks turn out to sit on one slow wire, duplication is aimed at
- * exactly the right thing; if they are spread across fast ones, the wait has
- * another cause and this work should not be done at all.
- *
- * Reads only: nothing here changes a reservation or places a request.
- *
- * @param {import("webtorrent").Torrent} torrent
- * @param {number} pieceIndex
- * @returns {{ chunks: number, missing: number,
- *   outstanding: Array<{ blocks: number, bytesPerSecond: number, choking: boolean }> } | null}
- *   Null only when the piece object is gone — it completed and was cleared.
- *   A piece nobody has reserved a block of yet is NOT null: `torrent-piece`
- *   creates its buffer lazily on the first reserve, so a piece the picker has
- *   not reached reads as every block missing and nothing outstanding, which is
- *   the most informative answer this can give — the wait is not on a slow
- *   holder, it is on nobody having been asked.
- */
-export function describePieceTail(torrent, pieceIndex) {
-  const piece = torrent?.pieces?.[pieceIndex];
-  if (!piece) {
-    return null;
-  }
-  const buffer = Array.isArray(piece._buffer) ? piece._buffer : null;
-  const chunks = Number.isFinite(piece._chunks)
-    ? piece._chunks
-    : (buffer ? buffer.length : 0);
-  // No buffer means no block of this piece has been reserved yet, so all of it
-  // is missing. Reading that as "no tail" hid the case worth seeing most.
-  let missing = chunks;
-  if (buffer) {
-    missing = 0;
-    for (let index = 0; index < chunks; index += 1) {
-      if (!buffer[index]) {
-        missing += 1;
-      }
-    }
-  }
-
-  const wires = Array.isArray(torrent?.wires) ? torrent.wires : [];
-  const outstanding = [];
-  for (const wire of wires) {
-    const requests = Array.isArray(wire?.requests) ? wire.requests : [];
-    const blocks = requests.filter((request) => request?.piece === pieceIndex).length;
-    if (blocks > 0) {
-      outstanding.push({
-        blocks,
-        bytesPerSecond: speedOf(wire),
-        choking: wire?.peerChoking === true
-      });
-    }
-  }
-  // Slowest first: that is the wire the read is waiting on, and the one a
-  // duplicate would be aimed past.
-  outstanding.sort((left, right) => left.bytesPerSecond - right.bytesPerSecond);
-  return { chunks, missing, outstanding };
-}
-
-/**
- * Ask a second wire for blocks the reader is still waiting on.
- *
- * WebTorrent reserves each block for exactly one wire, so once `Piece.reserve()`
- * answers -1 there is no request left to place and the read ends when the
- * holder of the last block delivers it — however fast the rest of the swarm is.
- * The library's own remedy is `_hotswap`, and it does precisely the right
- * thing: `piece.cancel(blockIndex)` frees the reservation while leaving the
- * first wire's request in flight, so a second wire can be asked for the same
- * block and whichever arrives first wins. What it will not do is apply that to
- * these tails. It is gated on speed — the held-up wire must be under 48 KB/s
- * (`3 * BLOCK_LENGTH`) and at least twice as slow as the asker — and measured
- * on a real swarm 2026-08-19, the tails a reader waits on sit at 109, 317 and
- * 870 KB/s. Peers the library rightly considers good, because for bulk
- * downloading they are; the gate is about throughput across a torrent and knows
- * nothing about a reader blocked on one piece now.
- *
- * Speed is not even what is wrong with them: two blocks — 32 KB — on a wire
- * measured at 109 KB/s is 0.3 s of transfer, and that read waited 4.6 s. The
- * blocks are not travelling slowly, they are queued behind that wire's other
- * 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. 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
- * flushed answers `false` from `Piece.init` so the second arrival returns
- * before `flush()` is reached.
- *
- * @param {object} torrent
- * @param {number} pieceIndex
- * @param {object} [options]
- * A BLOCK IS ASKED AGAIN ONLY ONCE IT IS LATE. A short tail is not by itself a
- * delay: copied as soon as the tail was short, 12-16 blocks of nearly every
- * piece were asked twice and 82 of 215 copies arrived after their piece was
- * complete (r41, Home Assistant, torrent-tv/meta#178). So a block is asked of a
- * second peer once its request to the first has been out `minAgeMs` — by
- * default the second WebTorrent sizes a wire's queue to fill
- * (`PIPELINE_MAX_DURATION`), a starting point to be checked in the field — and
- * the earliest moment a held block becomes late is returned, so whoever calls
- * this can look again then.
- *
- * @param {object} torrent
- * @param {number} pieceIndex
- * @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.
- * @param {number} [options.minAgeMs] - How long the first request must have been out.
- * @param {number} [options.now] - Wall clock, ms.
- * @returns {{ duplicated: number, missing: number, wires: number, unplaced: number, dueAt: number | null }}
- *   `duplicated` counts requests the library actually placed for a block that
- *   was already outstanding elsewhere; `unplaced` the late blocks in flight on
- *   one wire alone that no other wire could be asked for now; `dueAt` when the
- *   first block held by one wire and not yet late becomes late, or null.
- */
-export function duplicateTailFor(torrent, pieceIndex, { maxCopies = 2, minAgeMs = 1000, now = Date.now() } = {}) {
-  const piece = torrent?.pieces?.[pieceIndex];
-  const buffer = Array.isArray(piece?._buffer) ? piece._buffer : null;
-  if (!piece || !buffer || typeof piece.cancel !== "function" || !canPlaceRequests(torrent)) {
-    return { duplicated: 0, missing: 0, wires: 0, unplaced: 0, dueAt: null };
-  }
-  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, dueAt: null };
-  }
-
-  const missing = [];
-  for (let index = 0; index < chunks; index += 1) {
-    if (!buffer[index]) {
-      missing.push(index);
-    }
-  }
-  const candidates = wiresForPiece(torrent, pieceIndex);
-  if (missing.length === 0 || candidates.length === 0) {
-    return { duplicated: 0, missing: missing.length, wires: candidates.length, unplaced: 0, dueAt: null };
-  }
-
-  // A tail this short is what a blocked read is actually waiting on, and a
-  // second copy of it costs a few dozen kilobytes. A longer one is a piece
-  // still arriving normally, where duplicating would spend the shared link on
-  // 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, unplaced: 0, dueAt: null };
-  }
-
-  // Which wires each missing block is in flight on, and since when, 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. A request with no
-  // time of its own was asked before anybody watched, and is old.
-  const holders = new Map(missing.map(block => [block, { wires: new Set(), since: Number.POSITIVE_INFINITY }]));
-  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;
-      const holding = holders.get(Math.floor(request.offset / BLOCK_BYTES));
-      if (!holding) continue;
-      holding.wires.add(wire);
-      holding.since = Math.min(holding.since, Number.isFinite(request.askedAt) ? request.askedAt : Number.NEGATIVE_INFINITY);
-    }
-  }
-
-  let duplicated = 0, unplaced = 0, dueAt = null;
-  for (const block of missing) {
-    const { wires: held, since } = 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;
-    if (now - since < minAgeMs) {
-      dueAt = Math.min(dueAt ?? Number.POSITIVE_INFINITY, since + minAgeMs);
-      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();
-    }
-    if (!placed) unplaced += 1;
-  }
-  return { duplicated, missing: missing.length, wires: candidates.length, unplaced, dueAt };
-}
-
-/**
- * Whether every block of a piece is spoken for by some wire.
- *
- * The condition under which the library refuses a request and only displacement
- * could change the answer. Read from the piece's own reservation state, which
- * is what `_request` consults.
- *
- * @param {object} torrent
- * @param {number} pieceIndex
- * @returns {boolean}
- */
-function pieceIsFullyReserved(torrent, pieceIndex) {
-  const piece = torrent?.pieces?.[pieceIndex];
-  if (!piece || typeof piece.reserve !== "function") {
-    return false;
-  }
-  const reservation = piece.reserve();
-  if (reservation === -1) {
-    return true;
-  }
-  // Taken only to ask the question; give it straight back, or this reader has
-  // quietly claimed a block nobody will ever deliver.
-  piece.cancel?.(reservation);
-  return false;
-}