@torrent-tv/proxy 2.80.19 → 2.81.1

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

@@ -27,7 +27,7 @@ async function makeStore(capacityPieces) {
   const store = new SharedPieceStore(PIECE, {
     length: PIECE * 64,
     memoryBytes: PIECE * capacityPieces,
-    spillDirectory: directory,
+    path: directory,
     name: "eviction-test"
   });
   return { store, directory };
@@ -89,7 +89,7 @@ test("concurrent puts past capacity never hand two pieces the same slot", async
     );
   } finally {
     await store.destroy();
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -108,7 +108,7 @@ test("a piece caught mid-spill is waited for, not reported missing", async () =>
     assert.ok(bytes.equals(pieceOf(0)), "piece 0 came back wrong while being spilled");
   } finally {
     await store.destroy();
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -129,7 +129,7 @@ test("pinned pieces are never evicted, and the pin count is reported", async ()
     assert.equal(store.stats().pinned, 0, "unpin is not reflected in the stats");
   } finally {
     await store.destroy();
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -188,7 +188,7 @@ test("the store says why it spills: what is asked of it, what it had to take, ho
     assert.equal(store.stats().demand.readers, 0, "a reader that ends stops being counted");
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -226,7 +226,7 @@ test("a piece nobody has declared does not push out one that is being read", asy
     }
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -245,7 +245,7 @@ test("before any reader has declared anything, an arriving piece still goes to m
     assert.ok(stats.spills > 0, "the store filled and evicted, as it did before");
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -274,7 +274,7 @@ test("the store asks for what its readers declared, and for a whole window at le
     assert.equal(store.wantedBytes, 50 * PIECE);
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -300,7 +300,7 @@ test("the floor the ceiling will not fall below is the same union, not the wides
     );
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -333,7 +333,7 @@ test("a block is re-used instead of a new one being allocated for every piece",
     }
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -360,7 +360,7 @@ test("a spare block is given up once it has sat longer than the store's own work
     assert.equal(store.stats().blocksReleased, released);
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -388,7 +388,7 @@ test("evicting a piece the disk already holds costs no second write", async () =
     assert.ok((await get(store, 0)).equals(pieceOf(0)));
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -411,7 +411,7 @@ test("a store whose readers have gone asks for nothing, one that never had them
     assert.ok(store.wantedBytes < opening, "a store with no readers left asks for nothing");
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -434,7 +434,7 @@ test("the allowance is never cut below one reader's whole window", async () => {
     assert.equal(obeyed.belowAWindow, false);
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -478,7 +478,7 @@ test("the pool stays the size it is allowed to be, however many pieces pass thro
     }
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -512,7 +512,7 @@ test("a piece wanted later than the one it would displace goes to disk instead",
     }
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -542,6 +542,6 @@ test("a piece the map wants more displaces one it wants less, however far away i
     assert.ok((await get(store, 95)).equals(pieceOf(95)));
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });

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

@@ -39,6 +39,25 @@ function makeDisk({ failWrite = false, failRead = false, holdWrites = false } =
     get size() {
       return stored.size;
     },
+    get bytes() {
+      let total = 0;
+      for (const value of stored.values()) {
+        total += value.length;
+      }
+      return total;
+    },
+    get path() {
+      return ".";
+    },
+    get allowanceBytes() {
+      return null;
+    },
+    reviseAllowance() {
+      return null;
+    },
+    stats() {
+      return { pieces: stored.size, bytes: this.bytes, allowanceBytes: null, evictions: 0 };
+    },
     has(index) {
       return stored.has(index);
     },
@@ -247,7 +266,7 @@ test("a piece written back to memory is not resurrected on disk by its own spill
 
     // The swarm hands piece 0 back while that write is still going. The store
     // must drop the disk copy AFTER the write has recorded it, not before —
-    // `DiskTier.write` adds the index on completion, so an early forget is
+    // `PieceDiskStore.write` adds the index on completion, so an early forget is
     // undone and the next read of piece 0 comes back from before the rewrite.
     let settled = false;
     const rewritten = put(store, 0);

package/test/piece-store-slow-disk.test.js

@@ -55,6 +55,21 @@ function heldDisk() {
     get size() {
       return stored.size;
     },
+    get bytes() {
+      return 0;
+    },
+    get path() {
+      return ".";
+    },
+    get allowanceBytes() {
+      return null;
+    },
+    reviseAllowance() {
+      return null;
+    },
+    stats() {
+      return { pieces: stored.size, bytes: 0, allowanceBytes: null, evictions: 0 };
+    },
     has: (index) => stored.has(index),
     forget: (index) => stored.delete(index),
     write(index) {
@@ -139,6 +154,6 @@ test("memory in use never runs past the allowance while the disk is behind", asy
     assert.ok(store.stats().blocksInUse <= capacity + 1, "the pool did not settle");
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });

package/test/read-window.test.js

@@ -154,7 +154,7 @@ test("a read that is not stopped claims nothing", async () => {
     await iterator.return();
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -165,7 +165,7 @@ test("a finished read leaves nothing selected", async () => {
     assert.deepEqual(torrent.held, [], "the read kept its claim after finishing");
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -188,7 +188,7 @@ test("an abandoned read leaves nothing selected", async () => {
     assert.deepEqual(torrent.held, [], "an abandoned read kept its claim forever");
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -238,7 +238,7 @@ test("two stopped readers add up, and one leaving takes only its own", async ()
     assert.deepEqual(torrent.held, [], "the last reader left something behind");
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -275,7 +275,7 @@ test("criticality marks the window being waited for, not the whole range", async
     await iterator.return();
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -306,7 +306,7 @@ test("a reader that is abandoned mid-fragment does not keep the piece pinned", a
     );
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 

package/test/run-intervals.test.js

@@ -1,100 +1,100 @@
-/**
- * @file How far a run may work, and who decides it.
- *
- * These cases used to be asked of `planRunInterval`, a second authority inside
- * the session manager that answered by its own rules: it walked the whole track
- * for the first free number, MOVED the start there, and counted every live run
- * as claiming up to `head + look-ahead`. It contradicted the plan directly, and
- * the two together produced the field oscillation of 2026-09-05 — the plan
- * commanded a start at #46, this moved it to #78, the plan killed the run for
- * standing outside the window it had asked for, and the same start was
- * commanded again, 350-700ms per cycle, no segment ever produced, the viewer's
- * picture stopped for 125 seconds.
- *
- * It is gone. WHERE a run starts is the plan's decision and nothing moves it;
- * HOW FAR it may work is a fact of the one coverage map, and that is what these
- * cases now ask. The map is the same object the plan reads, so there is no
- * second set of rules for the two to disagree about.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { CoverageMap } from "../services/encode/CoverageMap.js";
-
-/** A stand-in for a run: the map identifies one by being it. */
-function run(name) {
-  return { name };
-}
-
-test("with nothing made, a run gets everything from where it was asked", () => {
-  const coverage = new CoverageMap({ segmentCount: 100 });
-
-  assert.equal(coverage.freeRunFrom(0), 100, "the whole track is free");
-  assert.equal(coverage.firstGapFrom(0), 0);
-});
-
-test("a run stops before material that is already made", () => {
-  const coverage = new CoverageMap({ segmentCount: 100 });
-  coverage.setReady([10, 11, 12, 13, 14, 15, 16, 17, 18, 19]);
-
-  assert.equal(coverage.freeRunFrom(0), 10, "0..9, and it stops where 10 begins");
-});
-
-test("a run stops before a stretch another live run was given", () => {
-  const coverage = new CoverageMap({ segmentCount: 100 });
-  const other = run("other");
-  coverage.claim(other, 40, 60);
-
-  assert.equal(coverage.freeRunFrom(0), 40, "0..39, and the other run's claim begins at 40");
-  assert.equal(coverage.firstGapFrom(45), 61, "the first thing nobody holds after it");
-});
-
-test("a run's own claim does not hold it back", () => {
-  const coverage = new CoverageMap({ segmentCount: 100 });
-  const mine = run("mine");
-  coverage.claim(mine, 40, 60);
-
-  assert.equal(
-    coverage.freeRunFrom(40, mine),
-    60,
-    "asked by the run that holds it, the stretch is its own to work through"
-  );
-});
-
-test("a run that has ended holds nothing back", () => {
-  const coverage = new CoverageMap({ segmentCount: 100 });
-  const dead = run("dead");
-  coverage.claim(dead, 40, 60);
-  coverage.release(dead);
-
-  assert.equal(coverage.freeRunFrom(0), 100, "what it did not finish is free again");
-});
-
-test("what a dead run DID finish stays made", () => {
-  const coverage = new CoverageMap({ segmentCount: 100 });
-  const dead = run("dead");
-  coverage.claim(dead, 40, 60);
-  coverage.setReady([40, 41, 42]);
-  coverage.release(dead);
-
-  assert.equal(coverage.firstGapFrom(40), 43, "a closed file is closed whoever made it");
-});
-
-test("nothing left to make is answered with nothing", () => {
-  const coverage = new CoverageMap({ segmentCount: 5 });
-  coverage.setReady([0, 1, 2, 3, 4]);
-
-  assert.equal(coverage.firstGapFrom(0), null, "and a run started here would only repeat somebody's work");
-});
-
-test("a run without an end does not take the film away from a viewer further in", () => {
-  // The case that used to need a second authority's `head + look-ahead` guess.
-  // A run's claim is now the stretch the plan GAVE it, so a viewer opening the
-  // same film in the middle finds their own position free.
-  const coverage = new CoverageMap({ segmentCount: 1000 });
-  const first = run("first");
-  coverage.claim(first, 0, 499);
-
-  assert.equal(coverage.firstGapFrom(500), 500, "the second viewer's own position is free");
-  assert.equal(coverage.freeRunFrom(500), 500, "and everything from there to the end");
-});
+/**
+ * @file How far a run may work, and who decides it.
+ *
+ * These cases used to be asked of `planRunInterval`, a second authority inside
+ * the session manager that answered by its own rules: it walked the whole track
+ * for the first free number, MOVED the start there, and counted every live run
+ * as claiming up to `head + look-ahead`. It contradicted the plan directly, and
+ * the two together produced the field oscillation of 2026-09-05 — the plan
+ * commanded a start at #46, this moved it to #78, the plan killed the run for
+ * standing outside the window it had asked for, and the same start was
+ * commanded again, 350-700ms per cycle, no segment ever produced, the viewer's
+ * picture stopped for 125 seconds.
+ *
+ * It is gone. WHERE a run starts is the plan's decision and nothing moves it;
+ * HOW FAR it may work is a fact of the one coverage map, and that is what these
+ * cases now ask. The map is the same object the plan reads, so there is no
+ * second set of rules for the two to disagree about.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { CoverageMap } from "../services/encode/CoverageMap.js";
+
+/** A stand-in for a run: the map identifies one by being it. */
+function run(name) {
+  return { name };
+}
+
+test("with nothing made, a run gets everything from where it was asked", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+
+  assert.equal(coverage.freeRunFrom(0), 100, "the whole track is free");
+  assert.equal(coverage.firstGapFrom(0), 0);
+});
+
+test("a run stops before material that is already made", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  coverage.setReady([10, 11, 12, 13, 14, 15, 16, 17, 18, 19]);
+
+  assert.equal(coverage.freeRunFrom(0), 10, "0..9, and it stops where 10 begins");
+});
+
+test("a run stops before a stretch another live run was given", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  const other = run("other");
+  coverage.claim(other, 40, 60);
+
+  assert.equal(coverage.freeRunFrom(0), 40, "0..39, and the other run's claim begins at 40");
+  assert.equal(coverage.firstGapFrom(45), 61, "the first thing nobody holds after it");
+});
+
+test("a run's own claim does not hold it back", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  const mine = run("mine");
+  coverage.claim(mine, 40, 60);
+
+  assert.equal(
+    coverage.freeRunFrom(40, mine),
+    60,
+    "asked by the run that holds it, the stretch is its own to work through"
+  );
+});
+
+test("a run that has ended holds nothing back", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  const dead = run("dead");
+  coverage.claim(dead, 40, 60);
+  coverage.release(dead);
+
+  assert.equal(coverage.freeRunFrom(0), 100, "what it did not finish is free again");
+});
+
+test("what a dead run DID finish stays made", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  const dead = run("dead");
+  coverage.claim(dead, 40, 60);
+  coverage.setReady([40, 41, 42]);
+  coverage.release(dead);
+
+  assert.equal(coverage.firstGapFrom(40), 43, "a closed file is closed whoever made it");
+});
+
+test("nothing left to make is answered with nothing", () => {
+  const coverage = new CoverageMap({ segmentCount: 5 });
+  coverage.setReady([0, 1, 2, 3, 4]);
+
+  assert.equal(coverage.firstGapFrom(0), null, "and a run started here would only repeat somebody's work");
+});
+
+test("a run without an end does not take the film away from a viewer further in", () => {
+  // The case that used to need a second authority's `head + look-ahead` guess.
+  // A run's claim is now the stretch the plan GAVE it, so a viewer opening the
+  // same film in the middle finds their own position free.
+  const coverage = new CoverageMap({ segmentCount: 1000 });
+  const first = run("first");
+  coverage.claim(first, 0, 499);
+
+  assert.equal(coverage.firstGapFrom(500), 500, "the second viewer's own position is free");
+  assert.equal(coverage.freeRunFrom(500), 500, "and everything from there to the end");
+});