@torrent-tv/proxy 2.98.12 → 2.98.14

package/package.json

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

package/services/encode/EncodeRuns.js

@@ -13,6 +13,7 @@ import { contentionPenalty } from "./contention.js";
 import { LOOKAHEAD_PAUSE_SECONDS } from "./CushionReport.js";
 import { SpeedReadings } from "./SpeedReadings.js";
 import { nextInputAtFirstPiece } from "./next-input.js";
+import { runOpenOf } from "./run-open.js";
 import { ENCODE_RUN_STATE, liveRunsOf, runStateOf, wireState } from "./encode-run-state.js";
 import { ENCODE_EXIT } from "./encode-exit.js";
 import { EncodeRun, endOfRun } from "./EncodeRun.js";
@@ -1330,11 +1331,14 @@ export class EncodeRuns {
     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;
-    if (!Number.isFinite(ended.firstNamedMs) || !(pieceSeconds > 0) || !(speed > 0)) return;
     // 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 (torrent-tv/meta#178).
-    const waitedMs = Number.isFinite(ended.firstNamedWallMs) ? run.originalInput?.waitedBefore?.(ended.firstNamedWallMs) ?? 0 : 0;
-    const openSeconds = Math.max(0, (ended.firstNamedMs - waitedMs) / 1000 - pieceSeconds / speed);
+    // 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;
+    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 ` +
       `${openSeconds.toFixed(2)}s (first piece named at ${ended.firstNamedMs}ms, ${pieceSeconds.toFixed(3)}s of film at ${speed.toFixed(2)}x` +

package/services/encode/run-open.js

@@ -0,0 +1,29 @@
+/**
+ * @file How long a run took to open its original input (torrent-tv/meta#178).
+ *
+ * Measured from the run's spawn to the name of its first closed piece, less
+ * what encoding that piece costs at the run's speed, and less the time
+ * FFmpeg's reads waited for the stretch being copied: that wait is the copy's,
+ * and the stretch is sized from the open. The input states those waits on the
+ * 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.
+ */
+
+/**
+ * @param {object} params
+ * @param {number | null} params.firstNamedMs - Spawn to the first piece's name, pauses left out.
+ * @param {number | null} params.firstNamedWallMs - The same on the wall clock, pauses included.
+ * @param {number} params.startedAt - The run's spawn on the wall clock, ms.
+ * @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.
+ */
+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) };
+}

package/services/torrent/piece-timing.js

@@ -0,0 +1,105 @@
+/**
+ * @file When each piece was asked of the swarm, and how long its blocks were
+ * in flight (torrent-tv/meta#178).
+ *
+ * The order in which pieces were verified cannot say why one came last: it
+ * may have been asked for late, or asked for early with its last blocks held
+ * by slow peers, and the two need different fixes. Field 2026-10-14: the
+ * first input of a 1080p MKV waited 18.7 s for pieces 1 and 2, verified after
+ * pieces 3-33. WebTorrent states no outgoing request, so the torrent pool
+ * tells this record each block it asks and each block that arrives; the
+ * record answers once, when the piece is verified, and then forgets it.
+ */
+
+/**
+ * @typedef {object} PieceTiming
+ * @property {number} askedAgoMs - From the first block asked to the verification.
+ * @property {number} asks - Blocks asked, duplicates included.
+ * @property {number} peers - Distinct peers asked.
+ * @property {number} slowestMs - The longest a block was in flight, from its first ask to its arrival.
+ * @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.
+ */
+
+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 }>} */
+  #pieces = new Map();
+
+  /**
+   * A block of `piece` at `offset` was asked of `peer`.
+   *
+   * @param {number} piece
+   * @param {number} offset
+   * @param {string} peer
+   * @param {number} now
+   */
+  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 };
+      this.#pieces.set(piece, record);
+    }
+    record.asks += 1;
+    record.peers.add(peer);
+    if (!record.blocks.has(offset)) record.blocks.set(offset, now);
+  }
+
+  /**
+   * A block of `piece` at `offset` arrived from `peer`. A block never asked
+   * through this record — it is not one of ours — says nothing.
+   *
+   * @param {number} piece
+   * @param {number} offset
+   * @param {string} peer
+   * @param {number} now
+   */
+  arrived(piece, offset, peer, now) {
+    const record = this.#pieces.get(piece);
+    const askedAt = record?.blocks.get(offset);
+    if (askedAt === undefined) return;
+    const inFlightMs = now - askedAt;
+    if (inFlightMs >= record.slowestMs) {
+      record.slowestMs = inFlightMs;
+      record.slowestPeer = peer;
+    }
+    record.lastInFlightMs = inFlightMs;
+    record.lastPeer = peer;
+  }
+
+  /**
+   * The timing of `piece`, verified at `now`, or null when no block of it was
+   * asked through this record; forgotten either way.
+   *
+   * @param {number} piece
+   * @param {number} now
+   * @returns {PieceTiming | null}
+   */
+  verified(piece, now) {
+    const record = this.#pieces.get(piece);
+    this.#pieces.delete(piece);
+    if (!record) return null;
+    return {
+      askedAgoMs: now - record.firstAskAt,
+      asks: record.asks,
+      peers: record.peers.size,
+      slowestMs: record.slowestMs,
+      slowestPeer: record.slowestPeer,
+      lastInFlightMs: record.lastInFlightMs,
+      lastPeer: record.lastPeer
+    };
+  }
+}
+
+/**
+ * The timing said after a verified piece.
+ *
+ * @param {PieceTiming | null} timing
+ * @returns {string}
+ */
+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 ?? "?"}`;
+}

package/services/torrent/torrent-pool.js

@@ -24,6 +24,7 @@ import { withdrawClaim } from "./download/withdraw-claim.js";
 import { deadlineOfMapZone, levelOfMapZone, priorityOfMapZone } from "./map-zones.js";
 import { deriveSourceKey } from "../../utils/torrent-source-key.js";
 import { noteTorrentDestroyed } from "./destroyed-torrents.js";
+import { PieceTimings, describePieceTiming } from "./piece-timing.js";
 
 /** How a window stated from the priority map names itself. */
 const MAP_CLAIMANT = "priority-map";
@@ -1502,21 +1503,35 @@ export class TorrentPool {
     const addedAt = Date.now();
     this.#swarmTimingByTorrent.set(torrent, { addedAt, firstPeerAt: null });
 
-    torrent.on("download-requested", ({ piece, deadlineAt, requestId, peer, queued }) => {
-      logger.info(`download request=${requestId} piece=${piece} deadline=${deadlineAt} peer=${peer} outstanding=${queued}`);
-    });
     torrent.on("download-request-cancelled", ({ piece, offset, length, reason, requestId }) => {
       logger.info(`download request=${requestId ?? `${torrent.infoHash ?? "unknown"}:${piece}:${offset}`} cancel bytes=${length} reason=${reason}`);
     });
     torrent.on("download-request-cancel-failed", ({ piece, offset, length, error }) => {
       logger.warn(`download request=${torrent.infoHash ?? "unknown"}:${piece}:${offset} cancel bytes=${length} failed: ${error}`);
     });
-    // WHEN each piece arrived. The requests above say what was asked for; this
-    // says what came and in which order, which is what decides how far an
-    // encoder reading the file can go before it meets a piece still missing
-    // (torrent-tv/meta#151). One short line per piece: a 2.3 GB film is 563.
+    // WHEN each piece arrived, which decides how far an encoder reading the
+    // file can go before it meets a piece still missing (torrent-tv/meta#151),
+    // and WHY it came when it did: when its first block was asked and how long
+    // 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();
+    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
+      // not counted.
+      if (typeof wire?.request !== "function") return;
+      const peer = String(wire.remoteAddress ?? "?");
+      const request = wire.request;
+      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());
+        return answer;
+      };
+      wire.on("piece", (index, offset) => timings.arrived(index, offset, peer, Date.now()));
+    });
     torrent.on("verified", (piece) => {
-      logger.info(`download ${label()} verified piece=${piece}`);
+      logger.info(`download ${label()} verified piece=${piece}${describePieceTiming(timings.verified(piece, Date.now()))}`);
     });
 
     // The first connected peer, said once, because the wait for it can BE the