@torrent-tv/proxy 2.87.12 → 2.87.13

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.87.13
+
+- **Fix**: Include distinct active piece reads in memory demand and preserve their slots immediately, so reads without priority-map ranges cannot deadlock the torrent piece store.
+
 ## 2.87.12
 
 - **Fix**: Check each automatic output against whole-machine encoding occupancy before opening it, so a rejected size can resolve to a lower admissible rung instead of failing the request.

package/package.json

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

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

@@ -593,13 +593,13 @@ export class SharedPieceStore {
   }
 
   /**
-   * Whether the machine's share of memory is smaller than one reader's window.
+   * Whether the machine's share is smaller than current read demand.
    *
    * The store holds the window anyway — refusing would leave the read it is
    * serving unable to finish, which is worse — but it is the honest measure of
    * "this machine cannot take any more", and it is measured rather than
-   * guessed: it is the last revision's own comparison of what the machine
-   * allowed against what the widest reader declared.
+   * guessed: it is the last revision's comparison of the machine's share
+   * against declared windows and distinct pieces pinned by live reads.
    */
   get isBeyondTheMachine() {
     return this.#beyondTheMachine;
@@ -650,15 +650,17 @@ export class SharedPieceStore {
    * resident piece ends up pinned, the read returns zero bytes and ffmpeg takes
    * that for the end of the file (field 2026-08-15, roadmap item 9).
    *
-   * With no reader declaring anything there is no demand to speak of, so the
-   * store asks for what the machine allows and the first revision after a read
-   * begins brings it down to what that read needs.
+   * A declared window is not the only evidence of demand: a live reader pins
+   * each piece it is waiting on or handing to its consumer. Include those
+   * distinct pins as well, because some byte reads do not have a priority-map
+   * range to declare.
    */
   get wantedBytes() {
     const demand = this.#lru.demand();
+    const pinned = this.#lru.pinnedCount;
     if (demand.readers > 0) {
       this.#widestSeenPieces = Math.max(this.#widestSeenPieces, demand.widestPieces);
-      const pieces = Math.max(MIN_RESIDENT_PIECES, demand.unionPieces, demand.widestPieces);
+      const pieces = Math.max(MIN_RESIDENT_PIECES, demand.unionPieces, demand.widestPieces, pinned);
       // Plus room to absorb what arrives while a write is finishing. Asking for
       // exactly what the readers want leaves no free place ever, so every
       // arrival evicts one of them — measured 2026-09-02: `6 reader(s) want 23
@@ -666,9 +668,9 @@ export class SharedPieceStore {
       // that followed.
       return (pieces + this.slackPieces()) * this.#chunkLength;
     }
-    // WITH NO READER, THE FLOOR IS ONE READER'S WINDOW — the widest this store
-    // has actually been asked for, which is measured rather than chosen, and
-    // `MIN_RESIDENT_PIECES` only until it has been asked for anything.
+    // WITH NO DECLARED RANGE, the floor is the widest prior window or the
+    // distinct pieces pinned by current reads, both measured rather than
+    // chosen. `MIN_RESIDENT_PIECES` applies until either has been observed.
     //
     // It used to fall to the minimum the moment the last reader went, and the
     // allowance is re-derived once a minute (`STORE_REPORT_INTERVAL_MS`) while
@@ -677,12 +679,11 @@ export class SharedPieceStore {
     // to another file of the same torrent and the store was at
     // `0/3 (0MB of 12MB allowed)` with the machine offering 4.3 GB.
     //
-    // Holding one window's worth between readers is not waste: it is what the
-    // next read will ask for within seconds, and the pieces in it are the ones
-    // that reader left off at. A store that has never been read keeps nothing
-    // either — its pieces are arriving for a reader on the way, and they have
-    // the disk.
-    return (Math.max(MIN_RESIDENT_PIECES, this.#widestSeenPieces) + this.slackPieces()) * this.#chunkLength;
+    // Retaining the last declared window between reads avoids dropping back to
+    // the minimum; current pins cover reads that have no declared window. A
+    // store that has never been read keeps only the measured minimum.
+    const pieces = Math.max(MIN_RESIDENT_PIECES, this.#widestSeenPieces, pinned);
+    return (pieces + this.slackPieces()) * this.#chunkLength;
   }
 
   reviseGrowthCeiling(allowedBytes) {
@@ -692,27 +693,33 @@ 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 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
+    // Never below what the live readers together need, even when the machine's
+    // share says less. That is the union of declared windows, or the distinct
+    // pieces pinned by direct reads that have no declared window. A store that
+    // cannot hold what its readers are pinning cannot complete those reads:
+    // 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.
+    // union, used as the floor instead of only as the ask). A live read can
+    // also pin pieces without a priority-map range, so those measured pins are
+    // part of the same minimum. Exceeding the share is the lesser failure, and
+    // the line below says when it happens.
     const demand = this.#lru.demand();
-    this.#growthCeiling = Math.max(
+    const activeDemandPieces = Math.max(
       MIN_RESIDENT_PIECES,
-      demand.readers > 0 ? demand.unionPieces : MIN_RESIDENT_PIECES,
+      demand.readers > 0 ? demand.unionPieces : 0,
+      this.#lru.pinnedCount
+    );
+    this.#growthCeiling = Math.max(
+      activeDemandPieces,
       Number.isFinite(wanted) ? wanted : MIN_RESIDENT_PIECES
     );
-    const belowAWindow = demand.readers > 0
-      && Number.isFinite(wanted)
-      && wanted < demand.unionPieces;
-    this.#beyondTheMachine = belowAWindow;
+    const belowActiveDemand = Number.isFinite(wanted) && wanted < activeDemandPieces;
+    this.#beyondTheMachine = belowActiveDemand;
     // The LRU is told too. It was constructed with the store's original
     // capacity and never revised, so `isFull()` answered against a number that
     // had not been the limit for some time — dormant only because nothing calls
@@ -754,7 +761,7 @@ export class SharedPieceStore {
       committedBytes: this.#blocksAllocated * this.#chunkLength,
       evicted,
       releasedBlocks,
-      belowAWindow
+      belowActiveDemand
     };
   }
 
@@ -803,6 +810,19 @@ export class SharedPieceStore {
 
   pin(index) {
     this.#lru.pin(index);
+    // A piece reader pins before it waits for the bytes to arrive or return
+    // from disk. That is the only live record of some reads; the priority map
+    // can have no declared range for them (for example, a verified piece that
+    // was spilled). Include the measured set of distinct active pins in the
+    // immediate floor so a claim does not wait for the next budget pass to get
+    // a slot. `wantedBytes` carries the same demand to the machine-wide owner.
+    const pinned = this.#lru.pinnedCount;
+    if (pinned > this.#growthCeiling) {
+      this.#growthCeiling = pinned;
+      this.#lru.setCapacity(pinned);
+      this.#beyondTheMachine = true;
+      this.#wake();
+    }
   }
 
   unpin(index) {

package/services/torrent/worker/worker.js

@@ -638,11 +638,11 @@ setInterval(() => {
         (revised.releasedBlocks > 0 ? `, gave back ${revised.releasedBlocks} block(s) of memory` : "") +
         ` — now ${Math.round(revised.committedBytes / 1048576)}MB committed`
       );
-    } else if (revised.belowAWindow) {
+    } else if (revised.belowActiveDemand) {
       log(
-        `piece-store "${revised.name.slice(0, 40)}": the machine's share is smaller than one ` +
-        `reader's window, so the allowance is held at ${Math.round(revised.ceilingBytes / 1048576)}MB ` +
-        "anyway — a store that cannot hold the window of the read it is serving cannot finish that read"
+        `piece-store "${revised.name.slice(0, 40)}": the machine's share is smaller than active read demand, ` +
+        `so the allowance is held at ${Math.round(revised.ceilingBytes / 1048576)}MB ` +
+        "— a store cannot finish a read if it cannot hold the pieces that read is using"
       );
     } else if (revised.committedBytes > revised.ceilingBytes) {
       log(

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

@@ -428,6 +428,41 @@ test("a store whose readers have gone asks for nothing, one that never had them
   }
 });
 
+test("live piece pins set memory demand when no priority-map range is declared", async () => {
+  const { store, directory } = await makeStore(2);
+  try {
+    await put(store, 0, pieceOf(0));
+    await put(store, 1, pieceOf(1));
+
+    store.pin(0);
+    store.pin(1);
+    store.pin(2);
+
+    assert.equal(store.stats().demand.readers, 0, "this read has no priority-map range");
+    assert.equal(store.stats().pinned, 3, "the three distinct live pieces are measured");
+    assert.equal(store.capacity, 3, "the active read demand expands capacity immediately");
+    assert.equal(store.wantedBytes, 3 * PIECE, "the budget owner sees the same measured demand");
+
+    const revised = store.reviseGrowthCeiling(2 * PIECE);
+    assert.equal(revised.ceilingBytes, 3 * PIECE, "a budget pass preserves pieces in active reads");
+    assert.equal(revised.belowActiveDemand, true, "the store reports that the machine share was short");
+
+    await put(store, 2, pieceOf(2));
+    assert.ok(store.locate(0), "the first active piece remains resident");
+    assert.ok(store.locate(1), "the second active piece remains resident");
+    assert.ok(store.locate(2), "the pending active piece obtains a memory slot");
+
+    store.unpin(0);
+    store.unpin(1);
+    store.unpin(2);
+    const released = store.reviseGrowthCeiling(2 * PIECE);
+    assert.equal(released.ceilingBytes, 2 * PIECE, "the measured floor falls after the reads release their pieces");
+  } finally {
+    await store.destroy();
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
 test("the allowance is never cut below one reader's whole window", async () => {
   const { store, directory } = await makeStore(16);
   try {
@@ -438,13 +473,13 @@ test("the allowance is never cut below one reader's whole window", async () => {
     // which killed every encoder on that file in the field on 2026-08-15.
     const revised = store.reviseGrowthCeiling(2 * PIECE);
     assert.equal(revised.ceilingBytes, 10 * PIECE, "one whole window is the floor");
-    assert.equal(revised.belowAWindow, true, "and the store says the share was smaller than that");
+    assert.equal(revised.belowActiveDemand, true, "and the store says the share was smaller than that");
 
     // With no reader there is no window to protect and the share is obeyed.
     store.releaseProtection("video");
     const obeyed = store.reviseGrowthCeiling(2 * PIECE);
     assert.equal(obeyed.ceilingBytes, 2 * PIECE);
-    assert.equal(obeyed.belowAWindow, false);
+    assert.equal(obeyed.belowActiveDemand, false);
   } finally {
     store.destroy(() => undefined);
     await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });