@torrent-tv/proxy 2.90.0 → 2.92.0

package/services/storage/segment-store/SegmentStore.js

@@ -108,6 +108,23 @@ export class SegmentStore {
 
   /** Segment publication waiters by output key and segment number. @type {Map<string, Map<number, Set<Function>>>} */
   #waiters = new Map();
+  #changeListeners = new Map();
+
+  /** Register before inspecting files; changes include playlists, init and segments. */
+  subscribeChanges(key, listener) {
+    const listeners = this.#changeListeners.get(key) ?? new Set();
+    this.#changeListeners.set(key, listeners);
+    listeners.add(listener);
+    this.#watch(key);
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0 && this.#changeListeners.get(key) === listeners) this.#changeListeners.delete(key);
+    };
+  }
+
+  #changed(key) {
+    for (const listener of [...(this.#changeListeners.get(key) ?? [])]) listener();
+  }
 
   /** Output key → the watch on its directory. @type {Map<string, import("node:fs").FSWatcher>} */
   #watchers = new Map();
@@ -499,11 +516,11 @@ export class SegmentStore {
    * @param {string} key
    * @param {string} makingName - What the encoder called it while writing.
    * @param {{ servedNameOf?: (name: string) => string | null, segmentIndexFromName?: (name: string) => number }} format
-   * @param {{ mediaRanges?: object | null }} [read] - The piece's media
+   * @param {{ mediaRanges?: object | null, bytes?: Buffer | null }} [read] - The piece's media
    *   intervals as its format read them from the closed file, kept with it.
    * @returns {string | null} The served name, or null where nothing was renamed.
    */
-  publish(key, makingName, format, { mediaRanges = null } = {}) {
+  publish(key, makingName, format, { mediaRanges = null, bytes = null } = {}) {
     const served = format?.servedNameOf?.(makingName) ?? null;
     if (!served) {
       return null;
@@ -511,6 +528,10 @@ export class SegmentStore {
     const dir = path.join(this.#root, directoryNameFor(key));
     const index = format?.segmentIndexFromName?.(served) ?? -1;
     try {
+      if (bytes !== null) {
+        if (!Buffer.isBuffer(bytes) || bytes.length === 0) throw new TypeError("Published segment bytes must be complete and nonempty.");
+        writeFileSync(path.join(dir, makingName), bytes);
+      }
       renameSync(path.join(dir, makingName), path.join(dir, served));
     } catch (error) {
       // The file may already be gone — a process killed between closing the
@@ -685,10 +706,12 @@ export class SegmentStore {
         // the directory is asked about only where it can have gone.
         if (event === "rename" && !existsSync(dir)) {
           this.#held.delete(key);
+          this.#changed(key);
           end();
           return;
         }
         this.#noticed(key, typeof name === "string" ? name : null);
+        this.#changed(key);
       });
       // A directory that goes away takes its watch with it rather than leaving
       // an error nobody reads.
@@ -803,12 +826,14 @@ export class SegmentStore {
    * @param {number} index
    */
   announce(key, index) {
+    this.#changed(key);
     const byIndex = this.#waiters.get(key);
     const waiting = byIndex?.get(index);
     if (!waiting) return;
-    byIndex.delete(index);
-    if (byIndex.size === 0) this.#waiters.delete(key);
-    for (const resolve of waiting) resolve(true);
+    // An event only wakes readers. The store's current bytes decide readiness,
+    // including when a publication was followed by removal before this wake.
+    if (!this.pathOf(key, index)) return;
+    for (const resolve of [...waiting]) resolve(true);
   }
 
   /**
@@ -822,7 +847,7 @@ export class SegmentStore {
    * @returns {number}
    */
   waitingFor(key) {
-    let waiting = 0;
+    let waiting = this.#changeListeners.get(key)?.size ?? 0;
     for (const holders of this.#waiters.get(key)?.values() ?? []) {
       waiting += holders.size;
     }
@@ -842,16 +867,13 @@ export class SegmentStore {
    * @returns {Promise<boolean>}
    */
   waitFor(key, index, timeoutMs, cancelled = null) {
-    if (this.pathOf(key, index)) return Promise.resolve(true);
-    // An output adopted from a previous process has a directory nobody made in
-    // this one, so the wait itself is the first moment it is watched.
-    this.#watch(key);
     return new Promise((resolve) => {
       const byIndex = this.#waiters.get(key) ?? new Map();
       const waiting = byIndex.get(index) ?? new Set();
       this.#waiters.set(key, byIndex);
       byIndex.set(index, waiting);
       let settled = false;
+      let timer = null;
       const finish = (published) => {
         if (settled) return;
         settled = true;
@@ -865,15 +887,16 @@ export class SegmentStore {
         resolve(published);
       };
       waiting.add(finish);
+      // Subscribe before inspecting availability or starting the directory
+      // watch. A synchronous publication during either operation is visible.
+      this.#watch(key);
+      if (this.pathOf(key, index)) finish(true);
+      if (settled) return;
       // No deadline is a wait that ends only on the publication: a timer given
       // an infinite delay fires at once, which would turn the wait into a poll.
-      const timer = Number.isFinite(timeoutMs) ? setTimeout(() => finish(false), Math.max(0, timeoutMs)) : null;
+      timer = Number.isFinite(timeoutMs) ? setTimeout(() => finish(false), Math.max(0, timeoutMs)) : null;
       timer?.unref?.();
-      cancelled?.then(() => finish(false));
-      // Publication may have landed after the first path check and before this
-      // waiter was registered. Recheck once after registration so that window
-      // cannot turn a present segment into a full-deadline wait.
-      if (this.pathOf(key, index)) finish(true);
+      cancelled?.then(() => finish(false), () => finish(false));
     });
   }
 
@@ -892,7 +915,7 @@ export class SegmentStore {
    * name in a dead run's stretch is a piece it closed.
    *
    * @param {string} key
-   * @param {number} startedAt - The run's first segment number, which is its tag.
+   * @param {number | string} startedAt - The run's unique working-name tag.
    * @returns {number} How many unfinished pieces were removed.
    */
   clearUpAfter(key, startedAt) {
@@ -904,7 +927,8 @@ export class SegmentStore {
       key,
       this.directoryFor(key),
       format,
-      String(Number.isInteger(startedAt) && startedAt > 0 ? startedAt : 0)
+      typeof startedAt === "string" && /^[0-9a-z]+$/.test(startedAt)
+        ? startedAt : String(Number.isInteger(startedAt) && startedAt > 0 ? startedAt : 0)
     );
     if (removed > 0) {
       this.#logger?.info?.(
@@ -984,6 +1008,7 @@ export class SegmentStore {
    * @param {string} because
    */
   drop(key, because) {
+    this.#changed(key);
     const dir = path.join(this.#root, directoryNameFor(key));
     this.#unwatch(key);
     try {
@@ -996,6 +1021,12 @@ export class SegmentStore {
     this.#mediaRanges.delete(key);
     this.#touched.delete(key);
     this.#inits.delete(key);
+    // A removed output cannot publish to the existing waiters. Let callers
+    // re-evaluate its lifecycle instead of retaining an unbounded wait.
+    const byIndex = this.#waiters.get(key);
+    for (const waiting of byIndex?.values() ?? []) {
+      for (const finish of [...waiting]) finish(false);
+    }
     this.#logger.info(`segment-store dropped ${directoryNameFor(key)} (${because})`);
   }
 

package/services/storage/wire.js

@@ -61,6 +61,8 @@ export function wireMachineBudget({
   segmentStore,
   spill,
   memory,
+  encodeInputs,
+  indexMemory,
   wholeFiles,
   diagnostics,
   diagnosticsRoot = "",
@@ -87,6 +89,10 @@ export function wireMachineBudget({
   };
 
   budget.defineResource({ name: "memory", readFree: () => availableMemoryBytes() });
+  if (encodeInputs) budget.register({ name: "admitted encode inputs", resource: "memory",
+    held: () => encodeInputs.held(), wanted: () => encodeInputs.wanted(), required: () => encodeInputs.held(), allow: bytes => encodeInputs.allow(bytes) });
+  if (indexMemory) budget.register({ name: "media metadata", resource: "memory",
+    held: () => indexMemory.held(), wanted: () => indexMemory.wanted(), required: () => indexMemory.required(), allow: bytes => indexMemory.allow(bytes) });
 
   const segmentsOn = deviceOf(segmentStore.root);
   defineDisk(segmentsOn, segmentStore.root);
@@ -162,6 +168,7 @@ export function wireMachineBudget({
   }
 
   return {
+    capacityOf: name => budget.capacityOf(name),
     revise: async () => {
       // Re-read the evidence before dividing: it is the one claimant whose
       // bytes are written by something that never reports them.

package/services/torrent/Contents.js

@@ -27,19 +27,12 @@
  *    into the torrent's own list — and whoever takes them holds nothing of this
  *    object.
  *
- * **What was measured and deliberately NOT built**, so that it is not proposed
- * again as an oversight: telling a real episode from an extra. Over the 134
- * torrents of the survey collection, the words that would say so (`sample`,
- * `trailer`, `extra`, `bonus`, `preview`, `making`) matched four files, and all
- * four were ordinary titles — "Making cash with her pussy" is an episode, not a
- * making-of. Size says no more: the ratio of a video to the median of its own
- * torrent runs continuously from 0.00 to 1.00 with no gap anywhere, because a
- * collection of short clips is made of short clips. So there is nothing here to
- * derive a rule from, and a rule invented anyway would decide the order in
- * which a stranger's bandwidth is spent. Every picture is an item.
- *
- * Nothing here reads bytes, waits on the swarm or knows about ffmpeg. Like the
- * functions it is built on, it is a function of the list of names.
+ * Exact `sample`/`samples` words in a file or folder exclude an example clip.
+ * A video named exactly after an identified release group is its promo. Other
+ * words such as `making`, file sizes and guessed group names exclude nothing.
+ * Extension classifications are provisional until a completed media read
+ * reports whether the file carries video. This object owns every revision.
+ * Nothing here reads bytes, waits on the swarm or knows about ffmpeg.
  */
 
 import { readEpisodeMarker } from "./episode-naming.js";
@@ -132,6 +125,10 @@ function showKey(text) {
 }
 
 export class TorrentContents {
+  #files;
+  #name;
+  #releaseGroup;
+  #videoFacts = new Map();
   /** @type {TorrentItem[]} */
   #items = [];
 
@@ -154,24 +151,56 @@ export class TorrentContents {
    * @param {string} [params.name] - The torrent's name, which WebTorrent
    *   prefixes to every path in a multi-file torrent.
    */
-  constructor({ files, name = "" }) {
-    const list = Array.isArray(files) ? files : [];
+  constructor({ files, name = "", releaseGroup = "" }) {
+    this.#files = Array.isArray(files) ? files : [];
+    this.#name = name;
+    this.#releaseGroup = releaseGroup;
+    this.#rebuild();
+  }
+
+  /** A completed track read replaces the provisional extension classification. */
+  noteVideo(fileIndex, hasVideo) {
+    if (!Number.isSafeInteger(fileIndex) || !this.#files[fileIndex] || typeof hasVideo !== "boolean") return false;
+    if (this.#videoFacts.get(fileIndex) === hasVideo) return false;
+    this.#videoFacts.set(fileIndex, hasVideo);
+    this.#rebuild();
+    return true;
+  }
+
+  /** Only an explicitly identified release group may exclude its own promo. */
+  noteReleaseGroup(group) {
+    if (typeof group !== "string" || this.#releaseGroup === group) return false;
+    this.#releaseGroup = group;
+    this.#rebuild();
+    return true;
+  }
+
+  #rebuild() {
+    const list = this.#files;
+    const name = this.#name;
+    this.#items = [];
+    this.#itemByFile.clear();
     const described = list.map((file, fileIndex) => {
       const { folders, name: fileName } = splitTorrentPath(file?.path ?? file?.name ?? "", name);
+      const stem = fileName.slice(0, fileName.length - extensionOf(fileName).length);
+      const sample = [...folders, stem].some((part) => /(?:^|[^\p{L}\p{N}])samples?(?:$|[^\p{L}\p{N}])/iu.test(part));
+      const promo = Boolean(this.#releaseGroup) && stem.toLowerCase() === this.#releaseGroup.toLowerCase();
       return {
         fileIndex,
         name: fileName,
         folders,
         relativePath: [...folders, fileName].join("/"),
         length: Number.isFinite(file?.length) ? file.length : 0,
-        isVideo: VIDEO_FILE_EXTENSIONS.has(extensionOf(fileName))
+        isVideo: this.#videoFacts.get(fileIndex) ?? VIDEO_FILE_EXTENSIONS.has(extensionOf(fileName)),
+        provisional: !this.#videoFacts.has(fileIndex),
+        excludedReason: sample ? "sample" : promo ? "release-group-promo" : null
       };
     });
     this.#described = described;
-    this.#videoCount = described.filter((file) => file.isVideo).length;
+    this.#videoCount = described.filter((file) => file.isVideo && !file.excludedReason).length;
 
     const claimed = new Set();
-    for (const file of described.filter((one) => one.isVideo).sort(inReadingOrder)) {
+    for (const file of described.filter((one) => one.isVideo && !one.excludedReason).sort(inReadingOrder)) {
       const { audio, subtitles, images } = matchSidecarFiles({
         files: list,
         videoIndex: file.fileIndex,
@@ -318,7 +347,9 @@ export class TorrentContents {
         name: file.name,
         relativePath: file.relativePath,
         length: file.length,
-        kind: this.kindOf(file.fileIndex)
+        kind: this.kindOf(file.fileIndex),
+        provisional: file.provisional,
+        excludedReason: file.isVideo ? file.excludedReason : null
       }));
   }
 
@@ -375,7 +406,8 @@ export function contentsOf(torrent) {
   }
   const contents = new TorrentContents({
     files,
-    name: typeof torrent?.name === "string" ? torrent.name : ""
+    name: typeof torrent?.name === "string" ? torrent.name : "",
+    releaseGroup: typeof torrent?.releaseGroup === "string" ? torrent.releaseGroup : ""
   });
   byTorrent.set(torrent, { contents, fileCount: files.length });
   return contents;

package/services/torrent/demand/DemandRegister.js

@@ -23,6 +23,9 @@ import { unionOf, Window } from "./Window.js";
 export class DemandRegister {
   /** Claimant → the one window it currently states. */
   #windows = new Map();
+  #revision = 0;
+
+  get revision() { return this.#revision; }
 
   /**
    * State a need, replacing whatever that claimant said before.
@@ -39,9 +42,12 @@ export class DemandRegister {
    * @param {number} params.urgency
    * @returns {Window}
    */
-  state({ claimant, fileIndex, byteStart, byteEnd, urgency }) {
-    const window = new Window({ claimant, fileIndex, byteStart, byteEnd, urgency });
-    this.#windows.set(claimant, window);
+  state(params) {
+    const window = new Window(params);
+    const previous = this.#windows.get(window.claimant);
+    if (previous?.equals(window) && previous.requestId === window.requestId) return previous;
+    this.#windows.set(window.claimant, window);
+    this.#revision++;
     return window;
   }
 
@@ -57,7 +63,9 @@ export class DemandRegister {
    * @returns {boolean} Whether there was anything to withdraw.
    */
   withdraw(claimant) {
-    return this.#windows.delete(claimant);
+    const removed = this.#windows.delete(claimant);
+    if (removed) this.#revision++;
+    return removed;
   }
 
   /** How many claimants are stating something. */
@@ -195,6 +203,7 @@ export class DemandRegister {
 
   /** Forget everything. The torrent is going. */
   clear() {
+    if (this.#windows.size) this.#revision++;
     this.#windows.clear();
   }
 }

package/services/torrent/demand/Window.js

@@ -26,7 +26,7 @@ export class Window {
    * @param {number} params.byteEnd - Last byte, inclusive.
    * @param {number} params.urgency - A value of {@link import("./Urgency.js").Urgency}.
    */
-  constructor({ claimant, fileIndex, byteStart, byteEnd, urgency }) {
+  constructor({ claimant, fileIndex, byteStart, byteEnd, urgency, priority = 1, deadlineAt = Number.POSITIVE_INFINITY, requestId = claimant, order = 0 }) {
     if (typeof claimant !== "string" || claimant.length === 0) {
       throw new Error("A window needs a claimant to release it by.");
     }
@@ -47,6 +47,14 @@ export class Window {
     this.byteStart = byteStart;
     this.byteEnd = byteEnd;
     this.urgency = urgency;
+    if (!Number.isFinite(priority) || priority < 1 || priority > 100 ||
+      !(Number.isFinite(deadlineAt) || deadlineAt === Number.POSITIVE_INFINITY) || !Number.isSafeInteger(order) || order < 0) {
+      throw new TypeError("Invalid download priority or deadline.");
+    }
+    this.priority = priority;
+    this.deadlineAt = deadlineAt;
+    this.requestId = requestId;
+    this.order = order;
     Object.freeze(this);
   }
 
@@ -80,7 +88,10 @@ export class Window {
       && this.fileIndex === other.fileIndex
       && this.byteStart === other.byteStart
       && this.byteEnd === other.byteEnd
-      && this.urgency === other.urgency;
+      && this.urgency === other.urgency
+      && this.priority === other.priority
+      && this.deadlineAt === other.deadlineAt
+      && this.order === other.order;
   }
 
   /** @returns {string} */

package/services/torrent/demand-progress.js

@@ -0,0 +1,25 @@
+/** Count exact wanted bytes and their available residence without a read window. */
+export function demandProgress({ windows, file, pieceLength, locationOf }) {
+  if (!Number.isSafeInteger(pieceLength) || pieceLength <= 0 || typeof locationOf !== "function") return null;
+  const ordered = windows.map(window => [Math.max(0, window.byteStart), Math.min(file.length - 1, window.byteEnd)])
+    .filter(([from, to]) => to >= from).sort((left, right) => left[0] - right[0]);
+  const ranges = [];
+  for (const range of ordered) {
+    const previous = ranges.at(-1);
+    if (previous && range[0] <= previous[1] + 1) previous[1] = Math.max(previous[1], range[1]);
+    else ranges.push(range);
+  }
+  if (!ranges.length) return null;
+  let totalBytes = 0, downloadedBytes = 0;
+  for (const [from, to] of ranges) {
+    totalBytes += to - from + 1;
+    const first = Math.floor((file.offset + from) / pieceLength), last = Math.floor((file.offset + to) / pieceLength);
+    for (let index = first; index <= last; index++) {
+      if (locationOf(index) === "missing") continue;
+      const start = Math.max(from, index * pieceLength - file.offset);
+      const end = Math.min(to, (index + 1) * pieceLength - file.offset - 1);
+      downloadedBytes += end - start + 1;
+    }
+  }
+  return { totalBytes, downloadedBytes };
+}

package/services/torrent/download/DeadlineScheduler.js

@@ -0,0 +1,167 @@
+import { piecesOf } from "../demand/pieces.js";
+import { pieceStoreOf } from "../piece-store-of.js";
+
+/** The block length and one-second request allowance used by WebTorrent. */
+const BLOCK_BYTES = 16 * 1024;
+const compiledDemand = new WeakMap();
+const requestArrivals = new WeakMap();
+
+/** Keep the same reassignment evidence in an isolated forecast request. */
+export function copyRequestArrival(source, target) {
+  if (requestArrivals.has(source)) requestArrivals.set(target, requestArrivals.get(source));
+  return target;
+}
+
+function requestArrival(wire, request, now) {
+  if (!requestArrivals.has(request)) {
+    const speed = Number(wire.downloadSpeed?.());
+    let bytes = 0;
+    for (const queued of wire.requests ?? []) {
+      bytes += queued.length;
+      if (queued === request) break;
+    }
+    requestArrivals.set(request, speed > 0 ? now + bytes / speed * 1000 : Infinity);
+  }
+  return requestArrivals.get(request);
+}
+
+export function peerRequestCapacity(torrent, wire) {
+  const speed = Math.max(0, Number(wire.downloadSpeed?.()) || 0);
+  if (wire.type === "webSeed") {
+    return Math.min(1 + Math.ceil(speed / torrent.pieceLength), torrent.maxWebConns);
+  }
+  let capacity = 2 + Math.ceil(speed / BLOCK_BYTES);
+  const maximum = wire.peerExtendedHandshake?.reqq;
+  if (Number.isFinite(maximum) && maximum > 0) capacity = Math.min(capacity, Math.floor(maximum));
+  return capacity;
+}
+
+export function requestCompletionAt(wire, bytes, now) {
+  const speed = Number(wire.downloadSpeed?.());
+  if (!(speed > 0)) return Number.POSITIVE_INFINITY;
+  const queued = (wire.requests ?? []).reduce((total, request) => total + request.length, 0);
+  return now + (queued + bytes) / speed * 1000;
+}
+
+export function peerCanServe(wire, piece) {
+  return !wire.destroyed && (!wire.peerChoking || (wire.hasFast && wire.peerAllowedFastSet?.includes(piece))) &&
+    wire.peerPieces?.get(piece);
+}
+
+/** Identical map ordering for present requests and conditional future requests. */
+export function compareDownloadCandidates(a, b) {
+  return a.deadlineAt - b.deadlineAt || b.priority - a.priority || a.order - b.order || a.piece - b.piece;
+}
+
+/** One ordering across torrents; peers retain protocol-owned block verification. */
+export class DeadlineScheduler {
+  #entries;
+  #running = false;
+  #store;
+
+  constructor({ entries, findStore = pieceStoreOf }) {
+    this.#entries = entries;
+    this.#store = findStore;
+  }
+
+  reconcile(now = Date.now()) {
+    if (this.#running) return { requested: 0, reassigned: 0 };
+    this.#running = true;
+    try {
+      return dispatchDownloadCandidates(downloadCandidates(this.#entries(), this.#store), now);
+    } finally {
+      this.#running = false;
+    }
+  }
+}
+
+
+/** The published map defines the same candidates for every scheduling pass. */
+export function downloadCandidates(entries, findStore = pieceStoreOf) {
+  const candidates = [];
+  for (const { torrent, register } of entries) {
+    if (torrent.destroyed || torrent.ready === false || typeof torrent._request !== "function") continue;
+    const store = findStore(torrent);
+    let compiled = compiledDemand.get(register);
+    if (!Number.isSafeInteger(register.revision) || compiled?.revision !== register.revision ||
+        compiled.torrent !== torrent || compiled.files !== torrent.files || compiled.pieceLength !== torrent.pieceLength) {
+      const byPiece = new Map();
+      for (const window of register.windows()) {
+        const file = torrent.files?.[window.fileIndex];
+        if (!file) continue;
+        const range = piecesOf({ fileOffset: file.offset, byteStart: window.byteStart, byteEnd: Math.min(window.byteEnd, file.length - 1), pieceLength: torrent.pieceLength });
+        if (!range) continue;
+        for (let piece = range.from; piece <= range.to; piece++) {
+          const prior = byPiece.get(piece);
+          if (!prior || window.deadlineAt < prior.deadlineAt ||
+            (window.deadlineAt === prior.deadlineAt && (window.priority > prior.priority ||
+              (window.priority === prior.priority && window.order < prior.order)))) {
+            byPiece.set(piece, { torrent, piece, deadlineAt: window.deadlineAt, priority: window.priority, order: window.order, requestId: window.requestId });
+          }
+        }
+      }
+      compiled = { torrent, revision: register.revision, files: torrent.files,
+        pieceLength: torrent.pieceLength, pieces: [...byPiece.values()] };
+      compiledDemand.set(register, compiled);
+    }
+    for (const candidate of compiled.pieces) {
+      const present = store?.locationOf ? store.locationOf(candidate.piece) !== "missing" : torrent.bitfield?.get(candidate.piece);
+      if (!present) candidates.push(candidate);
+    }
+  }
+  candidates.sort(compareDownloadCandidates);
+  return candidates;
+}
+
+/** Run against protocol peers or an isolated future-state copy. */
+export function dispatchDownloadCandidates(candidates, now) {
+  let requested = 0, reassigned = 0;
+  const hasCapacity = torrent => (torrent.wires ?? []).some(wire =>
+    !wire.destroyed && (wire.requests?.length ?? 0) < peerRequestCapacity(torrent, wire));
+  const writable = new Set(candidates.map(candidate => candidate.torrent).filter(hasCapacity));
+  for (const candidate of candidates) {
+    if (!writable.size) break;
+    const { torrent, piece, deadlineAt, requestId } = candidate;
+    if (!writable.has(torrent)) continue;
+    const wires = (torrent.wires ?? []).filter(wire => peerCanServe(wire, piece) &&
+      (wire.requests?.length ?? 0) < peerRequestCapacity(torrent, wire));
+    while (wires.length) {
+      wires.sort((a, b) => requestCompletionAt(a, BLOCK_BYTES, now) - requestCompletionAt(b, BLOCK_BYTES, now) ||
+        (a.requests?.length ?? 0) - (b.requests?.length ?? 0));
+      const wire = wires[0];
+      const before = wire.requests?.length ?? 0;
+      let accepted = torrent._request(wire, piece, false);
+      if (!accepted && Number.isFinite(deadlineAt)) {
+        const fasterAt = requestCompletionAt(wire, BLOCK_BYTES, now);
+        for (const slower of torrent.wires ?? []) {
+          if (slower === wire || typeof slower.cancel !== "function") continue;
+          const lateAt = requestCompletionAt(slower, 0, now);
+          if (!Number.isFinite(lateAt) || !(lateAt > deadlineAt && fasterAt < lateAt)) continue;
+          const request = slower.requests?.find(one => one.piece === piece);
+          if (!request) continue;
+          // A later queue estimate must not move the same block between peers
+          // indefinitely. Reassignment must improve its previous arrival;
+          // protocol completion or timeout ends this request's evidence.
+          if (!(fasterAt < requestArrival(slower, request, now))) continue;
+          slower.cancel(piece, request.offset, request.length);
+          reassigned++;
+          torrent.emit?.("download-request-cancelled", { ...request, reason: "deadline-reassigned", requestId });
+          accepted = torrent._request(wire, piece, false);
+          if (accepted) {
+            const replacement = wire.requests?.find(one => one.piece === piece && one.offset === request.offset);
+            if (replacement) requestArrivals.set(replacement, fasterAt);
+          }
+          if (accepted) break;
+        }
+      }
+      if (accepted) {
+        requested++;
+        torrent.emit?.("download-requested", { piece, deadlineAt, requestId, peer: wire.remoteAddress, queued: wire.requests?.length ?? 0 });
+      }
+      if (!accepted || (wire.requests?.length ?? 0) <= before ||
+        (wire.requests?.length ?? 0) >= peerRequestCapacity(torrent, wire)) wires.shift();
+    }
+    if (!hasCapacity(torrent)) writable.delete(torrent);
+  }
+  return { requested, reassigned };
+}