@torrent-tv/proxy 2.9.104 → 2.9.106

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 2.9.106
+
+- **Fix**: The two figures the browser needs to say how long until playback now reach it for the file that needs them most. Both are medians of sessions already finished on this host, and the plan read them at the moment it was BUILT and then cached the result — so the very first file opened after a restart got `null` for both and kept answering `null` for the life of the process, however many sessions ran afterwards. Measured 2026-08-05: a fresh proxy answered `null`, then created the session in 6 ms and produced the first segment in 21 479 ms. They are now read when the plan is ANSWERED, so a cached plan reports what the host currently knows. Covered by tests.
+- **New**: When the stats route has nothing to report it says which thing is missing — the torrent handle, the file index, or neither. A source answered `peers=0 file=n/a header=n/a` for minutes on 2026-08-05 while that very torrent was announcing to trackers with hundreds of seeders, and the line could not tell those cases apart. That line is what the viewer's loading screen shows, so it has to be answerable from the log.
+
+## 2.9.105
+
+- **Fix**: A reader's claim on pieces is put back when WebTorrent drops it, which is what stopped a download dead for eleven minutes. A reader declares the window it needs as a selection and withdraws it when it ends; that claim turns out not to be durable — the library deletes a selection the moment every piece in it is present (`remove fully downloaded selection`). While the reader keeps moving this is invisible, because the next window is claimed at once. It is fatal when the reader STOPS: the encoder gets held back by the look-ahead cap, ffmpeg stops reading, the reader parks on a window that is fully downloaded, the selection disappears, and no code of ours can notice because the reader is parked inside a write. Measured 2026-08-05: the encoder was suspended at 22:44:51, the download hit zero at 22:45:05 and stayed there for eleven minutes with 150 peer connections open and the new diagnostic reading `0 selection(s) covering 0 piece(s), 0 being asked, 0 blocks in flight`; when the encoder was let go there was nothing ahead of it. Live reader windows are now re-asserted from the pool's own timer, using the set the piece store already keeps, and only where something is actually missing — re-claiming a satisfied window would only be deleted again on the next pass.
+
 ## 2.9.104
 
 - **Fix**: An encoder run that stops because its input ran dry is no longer reported as a finished file. ffmpeg exits 0 both when it reaches the end of the source and when the source simply stops delivering, and over HTTP it cannot tell the two apart — so when a torrent's download died mid-session (field 2026-08-05), a run that had produced 188 segments of 624 logged `encode-run complete`, the player consumed what was already on disk and then froze for 60 s on the first segment nobody was making. The claim is now checked against the playlist that was published: a run that stopped short is a failure, which the session can restart, rather than a completed file.

package/package.json

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

package/routes/api/sources/stats/get.js

@@ -1,69 +1,82 @@
-import { logger } from "../../../../utils/logger.js";
-
-/**
- * Return download statistics for a registered torrent source.
- *
- * Provides peer count, transfer speeds, and per-file download progress so
- * that the browser client can display meaningful feedback while the proxy is
- * pre-fetching file metadata (MOOV atom / EBML headers) before codec probing.
- *
- * GET /api/sources/:sourceKey/stats?fileIndex=N
- *
- * @param {import("fastify").FastifyRequest} req
- * @param {import("fastify").FastifyReply} reply
- * @param {{
- *   sourceRegistry: ReturnType<import("../../../../store/source-registry.js").createSourceRegistry>,
- *   torrentPool: import("../../../../services/torrent-pool.js").TorrentPool
- * }} deps
- * @returns {Promise<void>}
- */
-export async function handleApiSourceStatsGet(req, reply, { sourceRegistry, torrentPool }) {
-  const sourceKey = typeof req.params.sourceKey === "string" ? req.params.sourceKey.trim() : "";
-  if (!sourceKey) {
-    return reply.code(400).send({ error: "sourceKey is required." });
-  }
-
-  const sourceRecord = sourceRegistry.get(sourceKey);
-  if (!sourceRecord) {
-    return reply.code(404).send({ error: "Source key was not found." });
-  }
-
-  let torrent;
-  try {
-    // getTorrent resolves immediately when the torrent is already loaded.
-    torrent = await torrentPool.getTorrent(sourceRecord.sourceType, sourceRecord.source);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return reply.code(500).send({ error: `Failed to load torrent: ${message}` });
-  }
-
-  const fileIndexRaw = typeof req.query.fileIndex === "string" ? req.query.fileIndex : "";
-  const fileIndex = fileIndexRaw !== "" && /^\d+$/.test(fileIndexRaw) ? Number(fileIndexRaw) : null;
-
-  // Optional: pin the resume window to a FIXED byte offset for the duration of
-  // one buffering episode (see getFileStats JSDoc) instead of the live, moving
-  // read position — otherwise "bytes needed" can jump up mid-poll as the window
-  // slides forward with playback/encoding progress.
-  const resumeAnchorRaw = typeof req.query.resumeAnchorByteStart === "string" ? req.query.resumeAnchorByteStart : "";
-  const resumeAnchorByteStart = resumeAnchorRaw !== "" && /^\d+$/.test(resumeAnchorRaw) ? Number(resumeAnchorRaw) : null;
-
-  // Awaited: with the torrent on its own thread this is a round trip, not a
-  // local lookup. Without the await the reply was the pending promise itself,
-  // which serialises to `{}` — the empty stats seen in the field 2026-08-02.
-  const stats = await torrentPool.getFileStats(torrent, fileIndex, { resumeAnchorByteStart });
-
-  // Diagnostic: surface the real swarm state per poll so a cold-start download
-  // stall (0 peers / header not advancing → playback-plan blocks on the codec
-  // probe → browser timeout) is visible in the proxy log.
-  const downKbps = (stats.downloadSpeed / 1024).toFixed(0);
-  const filePct = stats.fileProgress != null ? `${(stats.fileProgress * 100).toFixed(1)}%` : "n/a";
-  const header =
-    stats.headerBytes != null
-      ? `${stats.headerDownloadedBytes}/${stats.headerBytes}B`
-      : "n/a";
-  logger.info(
-    `[stats] ${sourceKey.slice(0, 8)} peers=${stats.numPeers} down=${downKbps}KB/s file=${filePct} header=${header}`
-  );
-
-  return reply.send(stats);
-}
+import { logger } from "../../../../utils/logger.js";
+
+/**
+ * Return download statistics for a registered torrent source.
+ *
+ * Provides peer count, transfer speeds, and per-file download progress so
+ * that the browser client can display meaningful feedback while the proxy is
+ * pre-fetching file metadata (MOOV atom / EBML headers) before codec probing.
+ *
+ * GET /api/sources/:sourceKey/stats?fileIndex=N
+ *
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{
+ *   sourceRegistry: ReturnType<import("../../../../store/source-registry.js").createSourceRegistry>,
+ *   torrentPool: import("../../../../services/torrent-pool.js").TorrentPool
+ * }} deps
+ * @returns {Promise<void>}
+ */
+export async function handleApiSourceStatsGet(req, reply, { sourceRegistry, torrentPool }) {
+  const sourceKey = typeof req.params.sourceKey === "string" ? req.params.sourceKey.trim() : "";
+  if (!sourceKey) {
+    return reply.code(400).send({ error: "sourceKey is required." });
+  }
+
+  const sourceRecord = sourceRegistry.get(sourceKey);
+  if (!sourceRecord) {
+    return reply.code(404).send({ error: "Source key was not found." });
+  }
+
+  let torrent;
+  try {
+    // getTorrent resolves immediately when the torrent is already loaded.
+    torrent = await torrentPool.getTorrent(sourceRecord.sourceType, sourceRecord.source);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return reply.code(500).send({ error: `Failed to load torrent: ${message}` });
+  }
+
+  const fileIndexRaw = typeof req.query.fileIndex === "string" ? req.query.fileIndex : "";
+  const fileIndex = fileIndexRaw !== "" && /^\d+$/.test(fileIndexRaw) ? Number(fileIndexRaw) : null;
+
+  // Optional: pin the resume window to a FIXED byte offset for the duration of
+  // one buffering episode (see getFileStats JSDoc) instead of the live, moving
+  // read position — otherwise "bytes needed" can jump up mid-poll as the window
+  // slides forward with playback/encoding progress.
+  const resumeAnchorRaw = typeof req.query.resumeAnchorByteStart === "string" ? req.query.resumeAnchorByteStart : "";
+  const resumeAnchorByteStart = resumeAnchorRaw !== "" && /^\d+$/.test(resumeAnchorRaw) ? Number(resumeAnchorRaw) : null;
+
+  // Awaited: with the torrent on its own thread this is a round trip, not a
+  // local lookup. Without the await the reply was the pending promise itself,
+  // which serialises to `{}` — the empty stats seen in the field 2026-08-02.
+  const stats = await torrentPool.getFileStats(torrent, fileIndex, { resumeAnchorByteStart });
+
+  // Diagnostic: surface the real swarm state per poll so a cold-start download
+  // stall (0 peers / header not advancing → playback-plan blocks on the codec
+  // probe → browser timeout) is visible in the proxy log.
+  const downKbps = (stats.downloadSpeed / 1024).toFixed(0);
+  const filePct = stats.fileProgress != null ? `${(stats.fileProgress * 100).toFixed(1)}%` : "n/a";
+  const header =
+    stats.headerBytes != null
+      ? `${stats.headerDownloadedBytes}/${stats.headerBytes}B`
+      : "n/a";
+  // When the answer is empty, say WHICH thing is missing. Field 2026-08-05: a
+  // source reported `peers=0 file=n/a header=n/a` for minutes while that very
+  // torrent was announcing to trackers with hundreds of seeders — and the line
+  // above cannot tell apart "the torrent handle is not the live one", "the file
+  // index did not resolve" and "no file index was asked for". That is what the
+  // viewer's loading screen was showing at the time, so it has to be
+  // answerable from the log rather than by reasoning about it afterwards.
+  const emptyAnswer = stats.fileProgress == null || (stats.numPeers === 0 && torrent.done !== true);
+  const detail = emptyAnswer
+    ? ` | infoHash=${String(torrent.infoHash).slice(0, 8)} files=${torrent.files?.length ?? "?"}` +
+      ` askedFor=${fileIndex ?? "none"} resolved=${torrent.files?.[fileIndex ?? -1] ? "yes" : "no"}` +
+      ` wires=${torrent.wires?.length ?? "?"} done=${torrent.done === true}`
+    : "";
+  logger.info(
+    `[stats] ${sourceKey.slice(0, 8)} peers=${stats.numPeers} down=${downKbps}KB/s file=${filePct} header=${header}${detail}`
+  );
+
+  return reply.send(stats);
+}

package/services/piece-store/piece-lru.js

@@ -200,6 +200,18 @@ export class PieceLru {
    * @param {string|number} readerId
    * @returns {void}
    */
+  /**
+   * Every live reader's declared window. Read by the pool to check that the
+   * torrent has actually been asked for those pieces — WebTorrent deletes a
+   * selection of its own accord once it is fully downloaded, so a claim made
+   * once does not stay made.
+   *
+   * @returns {Array<{ from: number, to: number }>}
+   */
+  protectedRanges() {
+    return [...this.#protected.values()].map((range) => ({ from: range.from, to: range.to }));
+  }
+
   unprotect(readerId) {
     this.#protected.delete(readerId);
   }