@torrent-tv/proxy 2.80.6 → 2.80.7

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.80.7
+
+- **Fix**: The piece store's memory floor, re-derived every time the machine's free memory changes, took the widest single reader's declared window (`demand.widestPieces`) as its lower bound instead of what every live reader together needs (`demand.unionPieces`) — right for one reader, wrong for several. Field 2026-09-07: three concurrent readers of one file — the picture, the sound, and the edge-warming read — each declared their own window; the floor guaranteed room for only the widest of the three, so once residents filled that smaller number, every resident piece belonged to some reader's still-live window and none could be evicted. `Every resident piece is pinned and nothing moved for 5000ms; no slot can be freed`, which is not our own failure — it reaches WebTorrent's own `store.put()` callback, and WebTorrent treats any error there as fatal and destroys the torrent outright: `torrent.files` went to `[]`, every later read answered `File N not found in torrent:<hash>`, and the session never recovered. `wantedBytes` in the same file already asked the machine for the union, correctly; the floor below which the store refuses to shrink now asks for the same thing.
+
 ## 2.80.6
 
 - **Fix**: `waitForBufferDrain` resolved after 5 s while `bufferedAmount` was still above `LOW_WATER` and the send loop kept queueing into a wedged association — `399 MB` in `libdatachannel` `rss 455→982 MB` `drainMs=5000` on every line for 6 h 50 min. Now waits until `LOW_WATER` with `50 ms` polling and never resolves while bytes are still held.

package/package.json

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

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);