@torrent-tv/proxy 2.80.6 → 2.80.8

package/services/orchestrators/EncodeOrchestrator.js

@@ -324,6 +324,21 @@ export class EncodeOrchestrator {
       )
     });
 
+    // A move is the plan taking a running encoder away from where it already
+    // stands, which is exactly the decision that was found wandering back and
+    // forth in the field on 2026-09-07 with no way to see why: the "because"
+    // line names the comparison in words, never the numbers it was decided
+    // from. Said here, once per reconcile, and only when a move actually
+    // happens — everything a rerun of the same decision needs: the windows
+    // this call saw (priority, the real time, which side of the viewers),
+    // the budget, and where every live run stood.
+    if (actions.some((action) => action.type === "move")) {
+      this.logger.info(
+        `encode-plan move on ${address}: windows=${JSON.stringify(windows)} ` +
+        `maxRuns=${this.#affordableOn(address, live)} ` +
+        `live=${JSON.stringify(live.map((run) => ({ from: run.from, to: run.to, head: run.head, speedX: run.speedX })))}`
+      );
+    }
     for (const action of actions) {
       if (action.type === "stop") {
         this.#stop(action.run, action.because);

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

@@ -575,22 +575,26 @@ export class SharedPieceStore {
     // the machine was full kept a small allowance for its whole life, however
     // much memory was freed afterwards (roadmap item 2, 2026-09-02).
     const wanted = Math.floor(Number(allowedBytes) / this.#chunkLength);
-    // Never below one reader's whole window while a reader exists, even when
-    // the machine's share says less. A store that cannot hold the window of the
-    // read it is serving cannot complete that read at all: every resident piece
-    // ends up pinned, the read returns zero bytes and ffmpeg takes that for the
-    // end of the file, which killed every encoder on that file in the field on
-    // 2026-08-15. Exceeding the share is the lesser failure, and the line below
-    // says when it happens.
+    // Never below what the live readers together hold, even when the machine's
+    // share says less. A store that cannot hold what its readers are pinning
+    // cannot complete any of their reads at all: every resident piece ends up
+    // pinned, a read returns zero bytes and ffmpeg takes that for the end of
+    // the file, which killed every encoder on that file in the field on
+    // 2026-08-15 (one reader) and again on 2026-09-07 (three readers of one
+    // file at once — picture, sound and the edge-warming read — where this
+    // floor was still computed from only the widest one of them, `wantedBytes`
+    // above already asks for the union and got it right; this is the same
+    // union, used as the floor instead of only as the ask). Exceeding the share
+    // is the lesser failure, and the line below says when it happens.
     const demand = this.#lru.demand();
     this.#growthCeiling = Math.max(
       MIN_RESIDENT_PIECES,
-      demand.readers > 0 ? demand.widestPieces : MIN_RESIDENT_PIECES,
+      demand.readers > 0 ? demand.unionPieces : MIN_RESIDENT_PIECES,
       Number.isFinite(wanted) ? wanted : MIN_RESIDENT_PIECES
     );
     const belowAWindow = demand.readers > 0
       && Number.isFinite(wanted)
-      && wanted < demand.widestPieces;
+      && wanted < demand.unionPieces;
     this.#beyondTheMachine = belowAWindow;
     // The LRU is told too. It was constructed with the store's original
     // capacity and never revised, so `isFull()` answered against a number that

package/test/piece-store-eviction.test.js

@@ -278,6 +278,32 @@ test("the store asks for what its readers declared, and for a whole window at le
   }
 });
 
+test("the floor the ceiling will not fall below is the same union, not the widest reader alone", async () => {
+  const { store, directory } = await makeStore(64);
+  try {
+    // The same two overlapping readers as the ask above: picture and sound,
+    // 10..44, thirty-five pieces together. The machine now offers far less
+    // than that (ten pieces) — before this fix the floor here came from
+    // `widestPieces` (twenty, the wider of the two readers alone), fifteen
+    // short of what both of them were actually pinning at once. A field
+    // session with three such readers on one file (video, audio and the
+    // edge-warming read) reached exactly that shortfall on 2026-09-07: every
+    // resident piece ended up pinned and WebTorrent destroyed the torrent
+    // over it.
+    store.protectRange("video", 10, 29);
+    store.protectRange("audio", 25, 44);
+    const revised = store.reviseGrowthCeiling(10 * PIECE);
+    assert.equal(
+      revised.ceilingBytes,
+      35 * PIECE,
+      "the floor is the union of both readers, not the wider one alone"
+    );
+  } finally {
+    store.destroy(() => undefined);
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
 test("a block is re-used instead of a new one being allocated for every piece", async () => {
   const capacity = 4;
   const { store, directory } = await makeStore(capacity);