@torrent-tv/proxy 2.21.0 → 2.22.0

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 2.22.0
+
+- **Fix**: What a rung is OFFERED on is the startup measurement again, not the figure learned from a live session. The startup one is taken on a quiet machine against known clips and does not move; the learned one moves with whatever else the box was doing that second, and three field sessions in a row show the price of that: decoding learned at 0.87x, then at 1.34-1.57x, against calibration's 2.6x — each reading refusing another rung until the offer held a single height and the quality menu vanished with it.
+- **New**: A live reading keeps the one thing it is authority on — itself. A rung that has actually been seen running below realtime, with the machine to itself, is withdrawn on that evidence whatever any prediction says. A rung nobody has run is judged by the startup measurement like any other, because a measurement of one rung is not a prediction about the rest.
+
+## 2.21.1
+
+- **Fix**: A cost is learned only from an encoder that had the machine to itself. Beside another encoder a reading already contains that other work, and the budget then ADDS the same work again when it predicts — so the price of a file grew with every reading. Measured in the field 2026-08-15: copying, whose truth is 7.9x, was learned as 2.03x; decoding, whose calibration clips say 2.6x, as 0.87x. Every re-encoded rung was then refused (`not offering 720p=0.56x … 240p=0.66x`), the offer collapsed to the one copied height, and the viewer lost the quality menu entirely.
+
 ## 2.21.0
 
 - **Fix**: The two costs added in 2.18.0 and 2.19.0 were never measured in production — both features were inert. The torrent's cost read `torrentPool.client`, a field that belongs to the pool implementation that no longer runs on this thread (the WebTorrent client lives on the worker), so the byte totals were always zero and the guard that needs two megabytes of movement never passed. The copy's cost sat in a branch its only caller had already filtered out, so it never ran. The totals now come from the worker over its own protocol, and the caller admits a copying session.

package/package.json

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

package/services/hls-session-manager.js

@@ -4750,6 +4750,9 @@ export class HlsSessionManager {
       heights: ordered,
       ownHeight: own,
       playingHeight: playing,
+      // What each rung was actually seen doing in this session, which is the
+      // only thing a live reading may speak for.
+      measuredHeights: this.#measuredRungSpeeds(owner),
       // What the family is already spending while a rung is considered. The
       // picture being COPIED is the common case and used to be priced at
       // nothing; measured, it is about an eighth of the machine.
@@ -4759,7 +4762,18 @@ export class HlsSessionManager {
       fps: Number(owner.outputFps) || TRANSCODE_FPS,
       source: owner.sourceDecode ?? null,
       transcodeVideo: owner.transcodeVideo === true,
-      observedDecodeCostSec: observed?.costSec ?? null
+      // NOT the learned cost. What a rung is OFFERED on is the startup
+      // measurement, which is taken on a quiet machine against known clips and
+      // does not move; the figure learned from a live session moves with
+      // whatever else the box was doing at that second, and three field
+      // sessions in a row (2026-08-15) show what that costs: 0.87x, then
+      // 1.34-1.57x against calibration's 2.6x, each reading refusing another
+      // rung until the offer held one height and the menu disappeared with it.
+      //
+      // The learned figure keeps its job — but only over the rung it was
+      // measured ON, and only to take that one away (below). A measurement of
+      // one rung is not a prediction about the others.
+      observedDecodeCostSec: null
     });
     if (owner !== session) {
       // An orphan: its base is gone, so this is the family's last word and
@@ -4831,6 +4845,26 @@ export class HlsSessionManager {
    *
    * @param {HlsSession} session
    */
+  /**
+   * How many encoders are running and not suspended right now.
+   *
+   * A cost measured while two of them share the machine belongs to neither.
+   *
+   * @returns {number}
+   */
+  #runningEncoders() {
+    let running = 0;
+    for (const session of this.sessionsById.values()) {
+      if (session?.ffmpeg != null &&
+          !hasChildExited(session.ffmpeg) &&
+          session.encoderPaused !== true &&
+          session.state !== "disposed") {
+        running += 1;
+      }
+    }
+    return running;
+  }
+
   async #learnFromEncoder(session) {
     if (
       !session ||
@@ -4866,6 +4900,20 @@ export class HlsSessionManager {
     if (speed === null) {
       return;
     }
+    // Only while this encoder had the machine to itself. A reading taken beside
+    // another encoder already contains that other work — and the budget then
+    // ADDS the same work again when it predicts, so the cost is counted twice
+    // and grows with every reading. Measured 2026-08-15 in the field: copying,
+    // whose truth is 7.9x, was learned as 2.03x, and decoding, whose clips say
+    // 2.6x, as 0.87x. Every rung was then refused, the offer collapsed to the
+    // one copied height, and the viewer lost the quality menu altogether.
+    if (this.#runningEncoders() > 1) {
+      return;
+    }
+    // What this rung did with the machine to itself — the one figure a live
+    // reading is authority on, and what withdraws a rung that has been seen
+    // failing without letting it speak for rungs nobody has run.
+    session.lastAloneSpeed = speed;
     if (speed < BUDGET_SPEED_OK && await this.#classifyTranscodeBound(session) === "download") {
       return; // the torrent is what is short; this says nothing about the host
     }
@@ -5128,6 +5176,32 @@ export class HlsSessionManager {
     return cost;
   }
 
+  /**
+   * The speed each rung of this family was last seen running at, when it was
+   * running alone.
+   *
+   * A rung that has been watched failing is refused on that evidence; a rung
+   * nobody has run says nothing about itself and is judged by the startup
+   * measurement like any other.
+   *
+   * @param {HlsSession} base
+   * @returns {Map<number, number>}
+   */
+  #measuredRungSpeeds(base) {
+    /** @type {Map<number, number>} */
+    const speeds = new Map();
+    for (const session of this.#familyOf(base)) {
+      if (session.transcodeVideo !== true || !Number.isFinite(session.lastAloneSpeed)) {
+        continue;
+      }
+      const height = this.variantHeightOf(session);
+      if (height > 0) {
+        speeds.set(height, session.lastAloneSpeed);
+      }
+    }
+    return speeds;
+  }
+
   #sustainableHeights({
     heights,
     ownHeight,
@@ -5138,7 +5212,8 @@ export class HlsSessionManager {
     source,
     transcodeVideo,
     observedDecodeCostSec = null,
-    concurrentCostSec = 0
+    concurrentCostSec = 0,
+    measuredHeights = null
   }) {
     const benchmark = this.softwarePresetBenchmark;
     if (!Array.isArray(benchmark) || benchmark.length === 0 || sourceHeight <= 0 || sourceWidth <= 0) {
@@ -5170,6 +5245,14 @@ export class HlsSessionManager {
         kept.push(height);
         continue;
       }
+      // A rung this session has actually been seen running below realtime is
+      // withdrawn on that evidence, whatever the prediction says. This is the
+      // one thing a live reading is authority on: itself.
+      const measured = measuredHeights?.get(height) ?? null;
+      if (measured !== null && measured < 1) {
+        dropped.push(`${height}p=${measured.toFixed(2)}x measured`);
+        continue;
+      }
       const width = Math.round(((sourceWidth / sourceHeight) * height) / 2) * 2;
       const { speed, sustainable } = canSustainOutput({
         benchmark,