@torrent-tv/proxy 2.80.12 → 2.80.14

package/routes/transcode/session-file/get.js

@@ -1,4 +1,5 @@
 import { logger } from "../../../utils/logger.js";
+import { bandOf, waits } from "../../../services/priority/WaitLedger.js";
 
 /**
  * How long a request for a not-yet-produced file is held before answering with
@@ -99,7 +100,20 @@ export async function serveSessionFile(req, reply, { hlsSessionManager, sessionI
     const outcome = clientAborted
       ? "client-aborted"
       : result.kind === "ok" ? "served" : result.kind;
-    logger.info(`[hold] ${fileName} ${outcome} after ${heldMs}ms`);
+    // AGAINST THE RANK THE MAP GAVE IT. A wait is the only thing that says
+    // whether the prioritisation is being used well, and this is the one place
+    // in the proxy where a viewer is measurably waiting for a named segment.
+    // Recorded even when the segment was served at once: a run of short waits
+    // at the top rank is what "the urgent zone is being served first" looks
+    // like, and without them the table would hold only the failures.
+    const ranked = result.ranked ?? null;
+    if (ranked) {
+      waits.note(ranked.address, heldMs, ranked.rank, ranked.topRank);
+    }
+    logger.info(
+      `[hold] ${fileName} ${outcome} after ${heldMs}ms` +
+      (ranked ? ` (the map wants it ${bandOf(ranked.rank, ranked.topRank)}, rank ${ranked.rank} of ${ranked.topRank})` : "")
+    );
   }
 
   if (result.kind === "not-found") {
@@ -180,6 +194,8 @@ export async function waitForSessionFile(hlsSessionManager, sessionId, fileName,
   // this wait, and the segment the viewer wanted took 15 ms once it was asked
   // for.
   let seekEpoch = hlsSessionManager.seekEpoch(sessionId);
+  /** @type {{ address: string, rank: number, topRank: number } | null} */
+  let lastRanked = null;
   while (Date.now() - startedAt < timeoutMs) {
     const result = await hlsSessionManager.getFileStream(sessionId, fileName, {
       requestSeq,
@@ -202,9 +218,13 @@ export async function waitForSessionFile(hlsSessionManager, sessionId, fileName,
       );
       seekEpoch = hlsSessionManager.seekEpoch(sessionId);
     }
+    // The rank the map last gave this segment, so a request that runs out of
+    // patience is still counted against what it was promised. Kept across the
+    // polls because the timeout path has no result of its own.
+    lastRanked = result.ranked ?? lastRanked;
     await delay(300);
   }
-  return { kind: "warming-up" };
+  return { kind: "warming-up", ranked: lastRanked };
 }
 
 /**

package/services/download/SwarmSelection.js

@@ -206,9 +206,25 @@ export class SwarmSelection {
    * rebuild the second. Now there is one statement and two views of it, both
    * computed here.
    *
-   * Only the urgent levels. Memory holds what will be READ soon; the tail and
-   * the gap behind the playhead are fetched speculatively and must not push a
-   * piece the decoder is about to want out of memory.
+   * WHAT WILL BE READ SOON, WHICH IS NOT WHAT WILL BE DOWNLOADED SOON. Memory
+   * holds the first; the swarm is told the second; and the priority map states
+   * the second, over the whole rest of the film.
+   *
+   * `AHEAD` used to reach memory, and it is exactly the speculative lead: the
+   * map states one claimant per zone, so on a film with seven zones one `NEAR`
+   * and four `AHEAD` arrived here as five separate holders, each covering tens
+   * of megabytes. Field 2026-09-08: the store reported `5 reader(s) want 24
+   * piece(s) of 25 the store may hold (widest window 17)` — the union of what
+   * was declared equalled the whole capacity, so every admission had to evict a
+   * piece somebody had declared, and 100 of 1395 evictions did. Beside that,
+   * 6565 spills and 7575 revivals in 44 minutes with a median 0.0 s on disk, and
+   * 2138 h264 parse errors on a picture that was being COPIED.
+   *
+   * Raising the allowance does not touch it: a lead stated over the rest of the
+   * film grows to fill whatever memory it is given, and the ratio is unchanged.
+   * What belongs in memory is what a READ is stopped on and the little in front
+   * of it — the levels a read itself states — and those are `BLOCKED` and
+   * `NEAR`.
    *
    * @returns {void}
    */
@@ -218,7 +234,7 @@ export class SwarmSelection {
       return;
     }
     const holding = new Set();
-    for (const urgency of [Urgency.BLOCKED, Urgency.NEAR, Urgency.AHEAD]) {
+    for (const urgency of [Urgency.BLOCKED, Urgency.NEAR]) {
       for (const window of this.#register.at(urgency)) {
         const range = this.#piecesFor(window);
         if (!range) {

package/services/encode/SegmentDemand.js

@@ -58,4 +58,38 @@ export class SegmentDemand {
   mapOn(address) {
     return this.#maps.get(address) ?? [];
   }
+
+  /**
+   * What the map says about one segment, and about the map it sits in.
+   *
+   * Asked by whoever MEASURES how well the map is being served: a wait means
+   * one thing at the top rank and another at the bottom, and telling them apart
+   * needs both the segment's own rank and the highest rank stated — a rank is a
+   * position in this map, not an absolute number.
+   *
+   * AND AN EMPTY MAP IS NOT AN ANSWER, which is why the top rank comes back even
+   * when the segment's own is zero. A top rank of zero says the map has not been
+   * built yet — a session created a moment ago, before the first pass — and that
+   * is a different thing from "nobody is coming". Conflated, every request
+   * behind the run reads as absent for as long as a fresh session has no map.
+   *
+   * @param {string} address
+   * @param {number} index
+   * @returns {{ rank: number, topRank: number }} Rank zero for a number in
+   *   nobody's zone, which is a statement: nothing is coming for it.
+   */
+  rankOf(address, index) {
+    const zones = this.mapOn(address);
+    let rank = 0;
+    let topRank = 0;
+    for (const zone of zones) {
+      if (zone.priority > topRank) {
+        topRank = zone.priority;
+      }
+      if (index >= zone.from && index <= zone.to && zone.priority > rank) {
+        rank = zone.priority;
+      }
+    }
+    return { rank, topRank };
+  }
 }