@torrent-tv/proxy 2.98.16 → 2.98.18

package/package.json

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

package/services/encode/EncodeRuns.js

@@ -1319,8 +1319,13 @@ export class EncodeRuns {
   /**
    * How long this run took to open its original input, for sizing the next
    * stretch: from its spawn to the name of its first closed piece, less what
-   * encoding that piece costs at the run's speed — its own where it measured
-   * one, else the output's. Nothing is noted where either is unknown.
+   * encoding that piece costs at a measured speed — the run's own where it
+   * closed two pieces, else the output's newest reading, which is taken
+   * between two closed pieces of a run too. Never a predicted speed: the
+   * output's starting figure, scaled by a machine share that missed short
+   * runs, read 0.08x on Home Assistant and recorded opens of 0.00 s (r41,
+   * torrent-tv/meta#178). Nothing is noted where no speed was measured or the
+   * rest is negative, and the open estimated before stands.
    *
    * @param {object} session
    * @param {import("./EncodeRun.js").EncodeRun} run
@@ -1330,14 +1335,21 @@ export class EncodeRuns {
   #noteOpen(session, run, ended) {
     const grid = session.timeline?.published ?? session.timeline?.boundaries;
     const pieceSeconds = Number(grid?.[run.from + 1]) - Number(grid?.[run.from]);
-    const speed = run.speedX > 0 ? run.speedX : this.#host.encodeOrchestrator.speedOn?.(session.outputKey) ?? 0;
+    const speed = run.speedX > 0 ? run.speedX : this.#speedReadings.windowOf(session).at(-1)?.speed ?? 0;
     // FFmpeg's reads may have waited for the stretch being copied; that wait
     // is the copy's, and the stretch is sized from the open (`run-open.js`).
     const open = runOpenOf({
       firstNamedMs: ended.firstNamedMs, firstNamedWallMs: ended.firstNamedWallMs, startedAt: run.startedAt,
       waitedBefore: run.originalInput?.waitedBefore, pieceSeconds, speed
     });
-    if (!open) return;
+    if (!open) {
+      if (Number.isFinite(ended.firstNamedMs) && pieceSeconds > 0) {
+        this.#host.logger.info(`encode input of run #${run.from}..#${run.to} on ${session.outputKey}: open not measured ` +
+          `(first piece named at ${ended.firstNamedMs}ms, ${pieceSeconds.toFixed(3)}s of film, ` +
+          `${speed > 0 ? `at a measured ${speed.toFixed(2)}x the piece takes longer than that` : "no speed measured between two closed pieces"})`);
+      }
+      return;
+    }
     const { openSeconds, waitedMs } = open;
     this.#host.encodeOrchestrator.noteOpen?.(session.outputKey ?? "", openSeconds);
     this.#host.logger.info(`encode input of run #${run.from}..#${run.to} on ${session.outputKey}: opened in ` +

package/services/encode/run-open.js

@@ -8,6 +8,14 @@
  * wall clock, so they are taken up to the wall-clock moment the first piece
  * was named — the run's start plus its time to that name, not that time alone,
  * which as a moment lay before every wait and counted none of them.
+ *
+ * THE SPEED IS A MEASURED ONE, between two closed pieces, and a negative rest
+ * is no open at all: on Home Assistant runs of one piece took 6.0-7.5 s to it
+ * for 4 s of film, were priced at a speed of 0.08x that no run had measured,
+ * and recorded opens of 0.00 s; the next inputs were sized from them to one
+ * piece, and the runs stayed one piece each (r41, torrent-tv/meta#178). A rest
+ * below zero says the speed does not describe that piece, and nothing is
+ * recorded: the open estimated before stands.
  */
 
 /**
@@ -18,12 +26,14 @@
  * @param {((until: number) => number) | null | undefined} params.waitedBefore - The input's wall-clock waits for its copy before `until`, ms.
  * @param {number} params.pieceSeconds - The first piece's film.
  * @param {number} params.speed - Film seconds per second; 0 when not known.
- * @returns {{ openSeconds: number, waitedMs: number } | null} Null where any term is unknown.
+ * @returns {{ openSeconds: number, waitedMs: number } | null} Null where any term is
+ *   unknown, or where the piece's encoding at that speed exceeds the time to it.
  */
 export function runOpenOf({ firstNamedMs, firstNamedWallMs, startedAt, waitedBefore, pieceSeconds, speed }) {
   if (!Number.isFinite(firstNamedMs) || !(pieceSeconds > 0) || !(speed > 0)) return null;
   const waitedMs = Number.isFinite(firstNamedWallMs) && startedAt > 0 && typeof waitedBefore === "function"
     ? waitedBefore(startedAt + firstNamedWallMs)
     : 0;
-  return { waitedMs, openSeconds: Math.max(0, (firstNamedMs - waitedMs) / 1000 - pieceSeconds / speed) };
+  const openSeconds = (firstNamedMs - waitedMs) / 1000 - pieceSeconds / speed;
+  return openSeconds >= 0 ? { waitedMs, openSeconds } : null;
 }

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