@torrent-tv/proxy 2.80.12 → 2.80.14

package/services/priority/WaitLedger.js

@@ -0,0 +1,142 @@
+/**
+ * @file How well the priority map is being served, measured where somebody waits.
+ *
+ * The map says what matters most. Nothing said whether what mattered most was
+ * actually delivered first — so "is the prioritisation any good" had no answer
+ * of any kind, for either of the two things that read the map.
+ *
+ * The measure is the same for both, and it is a wait recorded against the rank
+ * the map gave the thing waited for AT THE MOMENT it was asked for. Read that
+ * way it says which part is wrong rather than whether the whole scheme is:
+ *
+ * - long waits at the TOP rank mean the urgent zone is not being served first,
+ *   which is a fault in whoever acts on the map;
+ * - long waits further down with none at the top mean the zones are the wrong
+ *   width — the urgent one too narrow, so the viewer reaches material that was
+ *   only ever ranked "soon";
+ * - a rank with no waits at all is not a good sign or a bad one, it is silence,
+ *   and it is reported as such rather than as a zero.
+ *
+ * There is nothing in here about encoders, torrents, sessions or viewers: it is
+ * given a rank and a number of milliseconds.
+ */
+
+/** How many waits to keep per rank. A median wants a sample, not a history. */
+const HISTORY = 200;
+
+/**
+ * Ranks are collapsed into bands before they are counted.
+ *
+ * The map's ranks are as many as the film needs — 100 down to 1 on a long file
+ * — and a table with a hundred rows says nothing a reader can hold. What is
+ * being asked is coarse: was the thing waited for what the viewer needs NOW,
+ * what they reach shortly, or the rest of the film. So the top rank is its own
+ * band, the next few are the second, and everything below is the third.
+ *
+ * @param {number} rank
+ * @param {number} topRank - The highest rank the map currently states.
+ * @returns {"now" | "soon" | "later"}
+ */
+export function bandOf(rank, topRank) {
+  if (!Number.isFinite(rank) || rank <= 0) {
+    return "later";
+  }
+  const top = Number.isFinite(topRank) && topRank > 0 ? topRank : rank;
+  if (rank >= top) {
+    return "now";
+  }
+  // Within a tenth of the top: what a viewer reaches while watching what they
+  // hold. A tenth is the map's own shape — its zones widen geometrically — and
+  // not a threshold chosen for this table.
+  return rank >= top - Math.max(1, Math.round(top / 10)) ? "soon" : "later";
+}
+
+export class WaitLedger {
+  /** @type {Map<string, Map<string, number[]>>} */
+  #waits = new Map();
+
+  /** @type {Map<string, Map<string, number>>} */
+  #counts = new Map();
+
+  /**
+   * Somebody waited this long for something the map ranked this highly.
+   *
+   * @param {string} key - What the waits belong to: an output, or a file.
+   * @param {number} waitedMs
+   * @param {number} rank - The map's rank for the thing waited for.
+   * @param {number} topRank - The highest rank the map states, so the rank can
+   *   be read as a position rather than as an absolute number.
+   */
+  note(key, waitedMs, rank, topRank) {
+    if (!key || !Number.isFinite(waitedMs) || waitedMs < 0) {
+      return;
+    }
+    const band = bandOf(rank, topRank);
+    let byBand = this.#waits.get(key);
+    if (!byBand) {
+      byBand = new Map();
+      this.#waits.set(key, byBand);
+    }
+    const held = byBand.get(band) ?? [];
+    held.push(waitedMs);
+    while (held.length > HISTORY) {
+      held.shift();
+    }
+    byBand.set(band, held);
+
+    let counts = this.#counts.get(key);
+    if (!counts) {
+      counts = new Map();
+      this.#counts.set(key, counts);
+    }
+    counts.set(band, (counts.get(band) ?? 0) + 1);
+  }
+
+  /**
+   * What the waits say, in one line, or null while nothing has waited.
+   *
+   * The count is the whole run and the median and worst are the recent sample,
+   * because those answer different questions: how often, and how badly.
+   *
+   * @param {string} key
+   * @returns {string | null}
+   */
+  describe(key) {
+    const byBand = this.#waits.get(key);
+    if (!byBand || byBand.size === 0) {
+      return null;
+    }
+    const counts = this.#counts.get(key) ?? new Map();
+    const parts = [];
+    for (const band of ["now", "soon", "later"]) {
+      const held = byBand.get(band);
+      if (!held || held.length === 0) {
+        // Said out loud, because an absent band and a band that never waited
+        // are the same silence and neither is a zero.
+        parts.push(`${band} none`);
+        continue;
+      }
+      const sorted = [...held].sort((a, b) => a - b);
+      const median = sorted[Math.floor(sorted.length / 2)];
+      parts.push(
+        `${band} ${counts.get(band) ?? held.length} wait(s) median ${Math.round(median)}ms ` +
+        `worst ${Math.round(sorted[sorted.length - 1])}ms`
+      );
+    }
+    return parts.join(", ");
+  }
+
+  /**
+   * @param {string} key
+   */
+  forget(key) {
+    this.#waits.delete(key);
+    this.#counts.delete(key);
+  }
+}
+
+/**
+ * One ledger for the process, because the question is asked in two layers and
+ * the answer is comparable only if the scale is the same.
+ */
+export const waits = new WaitLedger();

package/services/supply-margin.js

@@ -110,8 +110,47 @@ export function requiredSpeedFrom(waits) {
   if (!(medianIntervalSec > 0)) {
     return null;
   }
+  // THE SHARE OF ITS TIME THE READING LOST, over the stretch actually observed.
+  //
+  // The model is unchanged and it was always right: if a fraction `f` of the
+  // time is spent not delivering, then producing one second of film takes
+  // `1/(1 - f)` seconds, so a step must run that much faster than realtime.
+  // What was wrong was the two quantities fed into it — the WORST single
+  // interruption divided by the MEDIAN gap between interruptions, a maximum
+  // over a median, from two populations that need not be the same events at
+  // all. It asks what would happen if the worst interruption recurred at the
+  // typical rate, which is a compound case that never occurs, and it divides by
+  // a gap that goes to zero whenever interruptions arrive in a burst.
+  //
+  // Field 2026-09-08: 0.79 s (one jump, on a file already downloaded whole)
+  // over 0.01 s (the gaps inside a burst of microsecond waits) gave 158.60x,
+  // and the quality budget refused every step against it forty times in one
+  // session. The same measurements as a share of time lost give 1.00x, because
+  // that is what a reading of a complete file loses.
+  //
+  // The denominator here cannot vanish: it is the span the interruptions are
+  // spread over, which contains them.
+  // OVER WHOLE CYCLES, from the first interruption's start to the last one's
+  // start. That window holds exactly one running stretch per interruption in
+  // it, so the share does not depend on where the window happens to be cut —
+  // measured to the last interruption's END it counts one interruption more
+  // than it counts running stretches, and the same supply then reads 1.54x or
+  // 1.45x according to nothing but the moment the log line was printed.
+  const last = interruptions.length - 1;
+  const spanSec = (interruptions[last].start - interruptions[0].start) / 1000;
+  const lostSec = interruptions
+    .slice(0, last)
+    .reduce((total, one) => total + (one.end - one.start), 0) / 1000;
+  // A span that is all interruption says the supply delivered nothing at all
+  // while it was watched. There is no speed that survives that, and saying a
+  // huge number is less honest than saying it is not a speed question — so the
+  // largest figure any step is ever compared against is stated and named.
+  const lostShare = spanSec > 0 ? Math.min(0.99, lostSec / spanSec) : 0;
   return {
-    requiredSpeed: 1 + worstWaitSec / medianIntervalSec,
+    requiredSpeed: 1 / (1 - lostShare),
+    lostShare,
+    spanSec,
+    lostSec,
     worstWaitSec,
     medianIntervalSec,
     // Interruptions, not waits: what the figure is derived from. The two differ

package/services/torrent-pool.js

@@ -15,7 +15,7 @@ import { rmSync, statfsSync } from "node:fs";
 import WebTorrent from "webtorrent";
 import { logger } from "../utils/logger.js";
 import { SharedPieceStore, findSharedStore } from "./piece-store/shared-piece-store.js";
-import { Urgency } from "./demand/index.js";
+import { Urgency, urgencyName } from "./demand/index.js";
 import { demandFor, forgetTorrent, reconcileAll } from "./download/registry.js";
 import { isAtAWatchingViewer, isBehindEverybody, isNobodyComingNow } from "./priority/PriorityMap.js";
 import { deriveSourceKey } from "./torrent-source-key.js";
@@ -682,6 +682,12 @@ export function dhtNodeCount(client) {
   }
 }
 
+// The last shape said out loud per torrent, so an unchanged one is not
+// repeated. Held here rather than on the pool because `applyPriorityMap`
+// reads nothing but its arguments — which is what lets it be exercised
+// without building a pool, a torrent client or a thread.
+const lastMapSaid = new WeakMap();
+
 export class TorrentPool {
   /**
    * In-flight `client.add()` promises keyed by the same key as `torrents`.
@@ -1099,6 +1105,37 @@ export class TorrentPool {
         register.withdraw(window.claimant);
       }
     }
+    // WHAT THE SWARM WAS ACTUALLY TOLD, said on change and never on a timer.
+    // The map was applied in silence: that it had been BUILT was visible in the
+    // encoding's own line, and that the download had received it was visible
+    // nowhere at all — so "is the map reaching the swarm" could only be taken
+    // on trust. Field 2026-09-08: not one line about it in a whole session.
+    //
+    // Per LEVEL rather than per zone, because the register has five levels and
+    // the map has as many bands as the film needs; the fit between them is the
+    // one thing here that could be wrong, and this is what shows it. Megabytes,
+    // because that is what a swarm delivers.
+    const byLevel = new Map();
+    for (const zone of ordered) {
+      const level = levelOf(zone);
+      const seconds = Math.max(0, zone.to - zone.from);
+      const held = byLevel.get(level) ?? { zones: 0, megabytes: 0 };
+      held.zones += 1;
+      held.megabytes += (seconds / duration) * length / 1048576;
+      byLevel.set(level, held);
+    }
+    const shape = [...byLevel.entries()]
+      .sort((left, right) => right[0] - left[0])
+      .map(([level, held]) => `${urgencyName(level)} ${held.zones} zone(s) ${held.megabytes.toFixed(0)}MB`)
+      .join(", ");
+    const said = `${fileIndex}:${shape}`;
+    if (lastMapSaid.get(torrent) !== said) {
+      lastMapSaid.set(torrent, said);
+      logger.info(
+        `torrent-pool: the swarm is told, for "${file.name}": ${shape || "nothing"} ` +
+        `(${ordered.length} band(s) of the map, over ${Math.round(duration)}s of film)`
+      );
+    }
   }
 
   #reportStalledDownloads() {

package/services/torrent-worker/client.js

@@ -228,12 +228,7 @@ export class TorrentWorkerClient {
       // Fail everything outstanding rather than leaving callers hanging: a dead
       // worker will never answer, and a stalled request is worse than an error
       // the loading flow can retry.
-      const reason = new Error("Torrent worker stopped unexpectedly.");
-      this.#caller.rejectAll(reason);
-      for (const [, read] of this.#reads) {
-        read.fail(reason);
-      }
-      this.#reads.clear();
+      this.#failEverythingOutstanding(new Error("Torrent worker stopped unexpectedly."));
     });
 
     // A worker that ENDS was, until now, not noticed at all: only `message` and
@@ -252,15 +247,35 @@ export class TorrentWorkerClient {
         `torrent-worker: thread ended on its own with code ${code} — nobody asked it to. ` +
         "Everything waiting on it is failed; the proxy has no torrent client until it is rebuilt."
       );
-      const reason = new Error("Torrent worker ended unexpectedly.");
-      this.#caller.rejectAll(reason);
-      for (const [, read] of this.#reads) {
-        read.fail(reason);
-      }
-      this.#reads.clear();
+      this.#failEverythingOutstanding(new Error("Torrent worker ended unexpectedly."));
     });
   }
 
+  /**
+   * A dead thread will never answer, so everything waiting on it is failed.
+   *
+   * INCLUDING THE FRAGMENT READS, which is what ffmpeg's input is. Both death
+   * handlers walked `#reads` alone and left `#fragmentReaders` untouched, so an
+   * encoder's input neither ended nor errored — it went quiet. Field 2026-08-31,
+   * three times: the thread died, both ffmpeg runs stayed ALIVE and stopped
+   * producing (167 `holding segment-00085.mp4 … encoder alive` lines), the
+   * browser drained its cushion and then retried a segment that would never
+   * exist, for ever, with nothing shown to the viewer.
+   *
+   * @param {Error} reason
+   */
+  #failEverythingOutstanding(reason) {
+    this.#caller.rejectAll(reason);
+    for (const [, read] of this.#reads) {
+      read.fail(reason);
+    }
+    this.#reads.clear();
+    for (const [, reader] of this.#fragmentReaders) {
+      reader.fail(reason);
+    }
+    this.#fragmentReaders.clear();
+  }
+
   /**
    * Add (or join) a torrent and register it under `sourceKey`.
    *

package/services/torrent-worker/piece-reader.js

@@ -243,7 +243,7 @@ const supplyReportedAt = new Map();
  * Record one interruption and, at most twice a minute, say what it implies.
  *
  * The two figures are the whole of roadmap item 3: the speed a step must
- * sustain to survive this supply (`1 + worst wait / median interval`), and the
+ * sustain to survive this supply (`1 / (1 - the share of time lost)`), and the
  * smallest buffer that hides an interruption from the viewer. Both are printed
  * before either is USED, so the field says whether the arithmetic describes
  * reality before anything is decided by it.
@@ -265,7 +265,7 @@ const supplyReportedAt = new Map();
  * @param {string} infoHash
  * @param {string} fileName
  * @param {number} segmentSeconds - The session's own segment duration.
- * @returns {{ requiredSpeed: number, worstWaitSec: number, medianIntervalSec: number, samples: number, minimumBufferSec: number } | null}
+ * @returns {{ requiredSpeed: number, worstWaitSec: number, medianIntervalSec: number, lostShare: number, spanSec: number, lostSec: number, samples: number, minimumBufferSec: number } | null}
  */
 export function supplyFiguresFor(infoHash, fileName, segmentSeconds) {
   const history = supplyWaits.get(`${infoHash ?? "?"}/${fileName ?? "?"}`);
@@ -502,8 +502,13 @@ function noteSupplyWait(key, label, waitedMs) {
     // several waits. Saying how many of each is what makes the figure readable;
     // reporting the waits alone made `2 measured` look like two interruptions
     // 3 ms apart, and the demanded speed came out at 4422x.
-    `to survive this swarm (worst stall ${demand.worstWaitSec.toFixed(2)}s, one every ` +
-    `${demand.medianIntervalSec.toFixed(2)}s of running, ${demand.samples} stall(s) ` +
+    // THE NUMBERS THE FIGURE IS MADE OF, so a wrong one can be seen to be wrong.
+    // The share of time lost is what the speed now comes from; the worst stall
+    // and the typical gap are printed beside it because they are what the
+    // cushion is sized by and what the old formula divided one by the other.
+    `to survive this swarm (lost ${demand.lostSec.toFixed(2)}s of ${demand.spanSec.toFixed(2)}s ` +
+    `= ${(demand.lostShare * 100).toFixed(1)}%, worst stall ${demand.worstWaitSec.toFixed(2)}s, ` +
+    `one every ${demand.medianIntervalSec.toFixed(2)}s of running, ${demand.samples} stall(s) ` +
     `from ${demand.waits} wait(s)) — ` +
     `and the smallest buffer that hides it is ${buffer ? buffer.seconds.toFixed(1) : "?"}s` +
     // What steering the blocked piece onto another peer bought, as the

package/services/torrent-worker/worker.js

@@ -747,6 +747,11 @@ setInterval(() => {
         `piece-store "${stats.name.slice(0, 40)}" demand: ${demand.readers} reader(s) want ` +
         `${demand.unionPieces} piece(s) of ${demand.capacity} the store may hold ` +
         `(widest window ${demand.widestPieces})` +
+        // NAMED, because the count read as five encoders on a session that had
+        // two: a "reader" is whoever declared a range, and four of the five
+        // were zones of the priority map. Choosing between narrowing the
+        // windows and raising the allowance was guesswork without this.
+        ` [${demand.names.join(" ")}]` +
         (stats.evictedProtected > 0
           ? `; ${stats.evictedProtected} of ${stats.spills} eviction(s) took a piece a reader had declared`
           : "; no eviction has taken a declared piece") +