@torrent-tv/proxy 2.98.17 → 2.98.19

package/package.json

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

package/server.js

@@ -65,6 +65,7 @@ import { DownloadMaps } from "./services/viewer/DownloadMaps.js";
 import { nativeSourceMap, nativeOriginalSourceMap } from "./services/viewer/NativeSourceMap.js";
 import { MediaReadRequests } from "./services/media/MediaReadRequests.js";
 import { SegmentInputs } from "./services/media/SegmentInputs.js";
+import { directSegmentInput } from "./services/media/direct-segment-input.js";
 import { ContainerTrack } from "./services/media/tracks/ContainerTrack.js";
 import { pauseCoefficient, viewerStartsOn } from "./services/viewer/PriorityMap.js";
 import { coalescing } from "./utils/coalesce.js";
@@ -551,6 +552,17 @@ export async function startProxyServer({
       `${Math.round(passCosts.ms)}ms from start to result in all, longest ${Math.round(passCosts.maxMs)}ms`);
     Object.assign(passCosts, { since: now, passes: 0, whole: 0, reworked: 0, resolved: 0, windows: 0, ms: 0, maxMs: 0 });
   };
+  // A container whose packet table a pass did not wait for builds the map
+  // again once, when the table is built or refused (`directSegmentInput`).
+  const refreshAfterTable = new WeakSet();
+  const refreshWhenBuilt = (container, built, { sourceKey, fileIndex }) => {
+    if (refreshAfterTable.has(container)) return;
+    refreshAfterTable.add(container);
+    void built.then(() => {
+      refreshAfterTable.delete(container);
+      return downloadMaps.refresh(sourceKey, fileIndex);
+    }).catch(error => logger.warn(`download map after a packet table: ${error?.message ?? error}`));
+  };
   const downloadMaps = new DownloadMaps({
     // The ranges a picture reads at open are named again by every segment;
     // only the zone the swarm would rank first is sent (torrent-tv/meta#166).
@@ -693,13 +705,15 @@ export async function startProxyServer({
           // packets, which the same index states (torrent-tv/meta#166).
           let value = null;
           try {
-            if (await direct.supportsOriginalSourceRanges(interval) === true) value = await direct.readSourceRanges(interval);
-            else {
-              const index = await direct.readPacketIndex(interval);
-              await index.prepareAudioDependencies?.(interval, direct.readRange);
-              value = new SegmentInputs({ index, tracks: wanted }).forInterval({ ...interval, mode: track => modes.get(track) });
-            }
+            value = await directSegmentInput(direct, { interval, tracks: wanted, mode: track => modes.get(track) },
+              built => refreshWhenBuilt(direct, built, map));
           } catch { value = null; }
+          // A table still being built holds this output's segments, and only
+          // this output's: the map is built again when it is.
+          if (value?.kind === "pending") {
+            waiting.add(zone.outputKey);
+            continue;
+          }
           // The pass shares the thread in equal turns (`takeTurns`): in one
           // stretch the first pass over a film's 4000 zones held the main thread
           // for all of its work, and handed back after every zone it took

package/services/media/container/AviContainer.js

@@ -199,6 +199,20 @@ export class AviContainer extends Container {
     return false;
   }
 
+  /**
+   * Whether reading the sound's packet table now would wait for it to be
+   * built: the index is read, the table is not, and no refusal of memory for
+   * it stands. A reader with other work may go on with it instead. Field r42
+   * (Home Assistant, 2026-10-14): the download map waited 3.2 s for the
+   * table, between the soundtrack's first segment and the picture's next
+   * ones, and the swarm was asked for the picture's next piece only after it
+   * (torrent-tv/meta#178).
+   */
+  packetTableWouldWait() {
+    if (!this.#index || this.#packets || this.#scan) return false;
+    return this.#soundPacketsRefused === null || this.packetMemory?.fits?.(this.#soundPacketsRefused) !== false;
+  }
+
   /** The index, read from the file; see `#readIndex`. */
   async #readIndexOnce() {
     const tracks = await this.readTracks();

package/services/media/direct-segment-input.js

@@ -0,0 +1,34 @@
+/**
+ * @file The bytes one segment reads, from an index its container already
+ * holds, for the download map's pass (torrent-tv/meta#178).
+ *
+ * The pass works out every segment of every output a viewer watches, one at a
+ * time. A segment read from the original file is answered by arithmetic over
+ * the index; a soundtrack segment of an AVI needs the sound's packet table,
+ * which is built once for the whole film. While that table was being built the
+ * pass waited for it, and the picture's segments after the soundtrack's first
+ * were not stated to the swarm: field r42 (Home Assistant, 2026-10-14), the
+ * picture's next piece was asked for 4.0 s after its input asked for it, 3.2 s
+ * of that behind the table.
+ */
+import { SegmentInputs } from "./SegmentInputs.js";
+
+/**
+ * @param {object} container - Has `supportsOriginalSourceRanges`, `readSourceRanges` and `readPacketIndex`.
+ * @param {{ interval: object, tracks: object[], mode: (track: object) => string }} segment
+ * @param {(built: Promise<void>) => void} whenBuilt - Given a promise that settles when a table
+ *   still being built is built or refused, when the answer is "pending".
+ * @returns {Promise<{ kind: string, ranges?: Array<[number, number]> }>} `pending` when the
+ *   answer waits for a table still being built.
+ */
+export async function directSegmentInput(container, { interval, tracks, mode }, whenBuilt) {
+  if (await container.supportsOriginalSourceRanges(interval) === true) return container.readSourceRanges(interval);
+  // The table is begun, or joined, and not waited for.
+  if (container.packetTableWouldWait?.() === true) {
+    whenBuilt(container.readPacketIndex(interval).then(() => undefined, () => undefined));
+    return { kind: "pending" };
+  }
+  const index = await container.readPacketIndex(interval);
+  await index.prepareAudioDependencies?.(interval, container.readRange);
+  return new SegmentInputs({ index, tracks }).forInterval({ ...interval, mode });
+}

package/services/torrent/torrent-pool.js

@@ -1545,7 +1545,13 @@ export class TorrentPool {
       wire.request = function (index, offset, length, callback) {
         const queued = this.requests.length;
         const answer = request.call(this, index, offset, length, callback);
-        if (this.requests.length > queued) timings.asked(index, offset, peer, Date.now());
+        if (this.requests.length > queued) {
+          const now = Date.now();
+          timings.asked(index, offset, peer, now);
+          // When this wire was asked for the block: how long it has held it is
+          // what decides whether a second peer is asked (`duplicateTailFor`).
+          this.requests.at(-1).askedAt = now;
+        }
         return answer;
       };
       wire.on("piece", (index, offset) => timings.arrived(index, offset, peer, Date.now()));

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

@@ -264,25 +264,42 @@ export function describePieceTail(torrent, pieceIndex) {
  * @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.
- * @returns {{ duplicated: number, missing: number, wires: number, unplaced: number }}
+ * @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 blocks in flight on one
- *   wire alone that no other wire could be asked for now.
+ *   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 } = {}) {
+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 };
+    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 };
+    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]) {
@@ -291,7 +308,7 @@ export function duplicateTailFor(torrent, pieceIndex, { maxCopies = 2 } = {}) {
   }
   const candidates = wiresForPiece(torrent, pieceIndex);
   if (missing.length === 0 || candidates.length === 0) {
-    return { duplicated: 0, missing: missing.length, wires: candidates.length, unplaced: 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
@@ -300,26 +317,34 @@ export function duplicateTailFor(torrent, pieceIndex, { maxCopies = 2 } = {}) {
   // 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 };
+    return { duplicated: 0, missing: missing.length, wires: candidates.length, unplaced: 0, dueAt: null };
   }
 
-  // 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()]));
+  // 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;
-      holders.get(Math.floor(request.offset / BLOCK_BYTES))?.add(wire);
+      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;
+  let duplicated = 0, unplaced = 0, dueAt = null;
   for (const block of missing) {
-    const held = holders.get(block);
+    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;
@@ -343,7 +368,7 @@ export function duplicateTailFor(torrent, pieceIndex, { maxCopies = 2 } = {}) {
     }
     if (!placed) unplaced += 1;
   }
-  return { duplicated, missing: missing.length, wires: candidates.length, unplaced };
+  return { duplicated, missing: missing.length, wires: candidates.length, unplaced, dueAt };
 }
 
 /**

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

@@ -18,10 +18,12 @@
  * 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.
+ * loop are one look. A block is asked again only once its request has been out
+ * a wire's queue time (`duplicateTailFor`), so a block not yet late is looked
+ * at again when it becomes late, and a late one no other wire could take is
+ * looked at again a queue time later — once, in case nothing else happens in
+ * between. WebTorrent sizes a wire's queue to one second of its speed
+ * (`PIPELINE_MAX_DURATION`).
  */
 
 import { duplicateTailFor } from "./fastest-wires.js";
@@ -41,12 +43,15 @@ export class TailRepeat {
   #clear;
   #scheduled = false;
   #timer = null;
+  /** When the armed look runs, wall clock ms. */
+  #timerAt = Number.POSITIVE_INFINITY;
   #disposed = false;
   /** @type {Map<object, { onBlock: (index: number) => void, onPeer: () => void }>} */
   #wires = new Map();
   #onWire;
   #onPoke;
   #log;
+  #now;
   /**
    * Grow-only, for the log: block copies asked, looks taken, and blocks that
    * arrived after their piece was complete — what the copies cost.
@@ -62,9 +67,11 @@ export class TailRepeat {
    * @param {(work: () => void, ms: number) => unknown} [params.wake]
    * @param {(handle: unknown) => void} [params.clear]
    * @param {(line: string) => void} [params.log]
+   * @param {() => number} [params.now]
    */
-  constructor({ torrent, requiredPieces, duplicate = duplicateTailFor, schedule = setImmediate, wake = setTimeout, clear = clearTimeout, log = null }) {
+  constructor({ torrent, requiredPieces, duplicate = duplicateTailFor, schedule = setImmediate, wake = setTimeout, clear = clearTimeout, log = null, now = Date.now }) {
     this.#log = log;
+    this.#now = now;
     this.#torrent = torrent;
     this.#requiredPieces = requiredPieces;
     this.#duplicate = duplicate;
@@ -95,6 +102,19 @@ export class TailRepeat {
     this.#timer = null;
   }
 
+  /** One look armed at a time, at the earliest moment asked for. */
+  #lookAgainAt(at, now) {
+    if (!Number.isFinite(at) || at >= this.#timerAt) return;
+    if (this.#timer !== null) this.#clear(this.#timer);
+    this.#timerAt = at;
+    this.#timer = this.#wake(() => {
+      this.#timer = null;
+      this.#timerAt = Number.POSITIVE_INFINITY;
+      this.poke();
+    }, Math.max(0, at - now));
+    this.#timer?.unref?.();
+  }
+
   #watch(wire) {
     if (!wire || this.#wires.has(wire) || typeof wire.on !== "function") return;
     const listeners = {
@@ -128,14 +148,16 @@ export class TailRepeat {
     this.#scheduled = false;
     if (this.#disposed) return;
     this.totals.looks += 1;
-    let unplaced = 0;
+    const now = this.#now();
+    let unplaced = 0, dueAt = Number.POSITIVE_INFINITY;
     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);
+        const result = this.#duplicate(this.#torrent, index, { minAgeMs: WIRE_QUEUE_SECONDS * 1000, now });
         this.totals.duplicated += result.duplicated;
         unplaced += result.unplaced;
+        if (Number.isFinite(result.dueAt)) dueAt = Math.min(dueAt, result.dueAt);
         if (result.duplicated > 0) asked.push(`${index}:${result.duplicated}/${result.missing}`);
       }
     }
@@ -143,12 +165,7 @@ export class TailRepeat {
       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?.();
-    }
+    if (unplaced > 0) dueAt = Math.min(dueAt, now + WIRE_QUEUE_SECONDS * 1000);
+    this.#lookAgainAt(dueAt, now);
   }
 }