@torrent-tv/proxy 2.80.19 → 2.81.0

package/test/seek-landing.test.js

@@ -1,109 +1,109 @@
-/**
- * @file Ask ffmpeg late enough that it lands where we meant.
- *
- * `fftools/ffmpeg_demux.c` moves an input seek back by `3*AV_TIME_BASE / 23` —
- * 130.435 ms — whenever the container does not declare `AVFMT_SEEK_TO_PTS` and
- * a stream carries B-frames. So asking for a keyframe lands on the one before
- * it, and since `-segment_times` is measured from where the run really began,
- * every cut of that run inherits the shift.
- *
- * Measured 2026-08-21 on Matroska with keyframes every 2 s: `-ss 10` produced a
- * first segment starting at 8.000, `-ss 10.130435` one starting at 10.000. On
- * MP4, where the heuristic does not fire, 10, 10.130435 and 10.2 all produced
- * 10.000 — right in one case, harmless in the other.
- */
-
-import assert from "node:assert/strict";
-import { SourceFile } from "../services/source/SourceFile.js";
-import test from "node:test";
-
-import { seekLandingOffsetFor } from "../services/hls-session-manager.js";
-
-const OFFSET = 3 / 23;
-
-test("a copied picture is asked for one heuristic later than the keyframe", () => {
-  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 2.002, 4.004, 6.006] }) };
-  assert.equal(seekLandingOffsetFor(session, 2.002), OFFSET);
-});
-
-test("a re-encode is asked for exactly what it should produce", () => {
-  // It decodes from the keyframe and discards frames up to the requested time,
-  // so pushing the request later would start its output late.
-  const session = { transcodeVideo: true, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 2.002, 4.004] }) };
-  assert.equal(seekLandingOffsetFor(session, 2.002), 0);
-});
-
-test("the offset never reaches the next keyframe", () => {
-  // Keyframes 0.1 s apart: half of that is the most that can be added without
-  // risking a landing on the NEXT one where the heuristic does not fire.
-  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 0.1, 0.2, 0.3] }) };
-  assert.equal(seekLandingOffsetFor(session, 0.1), 0.05);
-});
-
-test("the last keyframe has nothing after it to collide with", () => {
-  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 2.002, 4.004] }) };
-  assert.equal(seekLandingOffsetFor(session, 4.004), OFFSET);
-});
-
-test("no keyframe list is still answered", () => {
-  assert.equal(seekLandingOffsetFor({ transcodeVideo: false }, 5), OFFSET);
-  assert.equal(seekLandingOffsetFor(null, 5), OFFSET);
-});
-
-test("a grid whose times are approximate is asked for that much later again", () => {
-  // AVI names a keyframe by its frame NUMBER and the time is that number times
-  // the frame duration, so a name can sit just BELOW the keyframe it refers to
-  // — measured 2026-08-21, 10-44 ms out on two files, always under one frame.
-  // Asking at the name alone would seek to before the real keyframe and land on
-  // the one before that, which is the fault this offset exists for.
-  const session = {
-    transcodeVideo: false,
-    file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 4.004, 8.008, 12.012], keyframeTolerance: 0.04 })
-  };
-  assert.equal(seekLandingOffsetFor(session, 4.004), OFFSET + 0.04);
-});
-
-test("an exact grid claims no tolerance", () => {
-  // Matroska and MP4 state instants outright — measured the same day, nine
-  // files and 11 665 keyframes with not one disagreement.
-  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 4.004, 8.008], keyframeTolerance: 0 }) };
-  assert.equal(seekLandingOffsetFor(session, 4.004), OFFSET);
-});
-
-test("the bound still holds once a tolerance is added", () => {
-  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 0.1, 0.2], keyframeTolerance: 1 }) };
-  assert.equal(seekLandingOffsetFor(session, 0.1), 0.05);
-});
-
-test("an output carrying only sound is not pushed past what it asked for", () => {
-  // The field failure of 2026-09-06: the sound played 130 ms ahead of the
-  // picture from every restart onward, and the viewer saw lips out of step with
-  // the voice from two minutes in.
-  //
-  // The offset exists because ffmpeg's demuxer moves a seek target back for a
-  // container it reads in decode order, after which a COPY lands on the previous
-  // keyframe. A re-encode trims to the requested time itself and is excluded —
-  // and an output with no picture is exactly that, since its one track is
-  // `-c:a aac`. It was not excluded, because the test asked whether the PICTURE
-  // is re-encoded and an output with no picture answers no.
-  const soundtrack = {
-    audioOnly: true,
-    transcodeVideo: false,
-    file: new SourceFile({ sourceKey: "s", fileIndex: 0 })
-      .learn({ keyframeTimes: [0, 4.004, 8.008, 12.012], keyframeTolerance: 0 })
-  };
-  assert.equal(seekLandingOffsetFor(soundtrack, 4.004), 0);
-});
-
-test("the picture of the same film still gets the offset", () => {
-  // The pair to the check above: the two outputs are repositioned to one
-  // boundary and must be given DIFFERENT requests, because one is copied and one
-  // is re-encoded. Given the same request they land 130 ms apart.
-  const picture = {
-    audioOnly: false,
-    transcodeVideo: false,
-    file: new SourceFile({ sourceKey: "s", fileIndex: 0 })
-      .learn({ keyframeTimes: [0, 4.004, 8.008, 12.012], keyframeTolerance: 0 })
-  };
-  assert.equal(seekLandingOffsetFor(picture, 4.004), OFFSET);
-});
+/**
+ * @file Ask ffmpeg late enough that it lands where we meant.
+ *
+ * `fftools/ffmpeg_demux.c` moves an input seek back by `3*AV_TIME_BASE / 23` —
+ * 130.435 ms — whenever the container does not declare `AVFMT_SEEK_TO_PTS` and
+ * a stream carries B-frames. So asking for a keyframe lands on the one before
+ * it, and since `-segment_times` is measured from where the run really began,
+ * every cut of that run inherits the shift.
+ *
+ * Measured 2026-08-21 on Matroska with keyframes every 2 s: `-ss 10` produced a
+ * first segment starting at 8.000, `-ss 10.130435` one starting at 10.000. On
+ * MP4, where the heuristic does not fire, 10, 10.130435 and 10.2 all produced
+ * 10.000 — right in one case, harmless in the other.
+ */
+
+import assert from "node:assert/strict";
+import { SourceFile } from "../services/source/SourceFile.js";
+import test from "node:test";
+
+import { seekLandingOffsetFor } from "../services/hls-session-manager.js";
+
+const OFFSET = 3 / 23;
+
+test("a copied picture is asked for one heuristic later than the keyframe", () => {
+  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 2.002, 4.004, 6.006] }) };
+  assert.equal(seekLandingOffsetFor(session, 2.002), OFFSET);
+});
+
+test("a re-encode is asked for exactly what it should produce", () => {
+  // It decodes from the keyframe and discards frames up to the requested time,
+  // so pushing the request later would start its output late.
+  const session = { transcodeVideo: true, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 2.002, 4.004] }) };
+  assert.equal(seekLandingOffsetFor(session, 2.002), 0);
+});
+
+test("the offset never reaches the next keyframe", () => {
+  // Keyframes 0.1 s apart: half of that is the most that can be added without
+  // risking a landing on the NEXT one where the heuristic does not fire.
+  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 0.1, 0.2, 0.3] }) };
+  assert.equal(seekLandingOffsetFor(session, 0.1), 0.05);
+});
+
+test("the last keyframe has nothing after it to collide with", () => {
+  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 2.002, 4.004] }) };
+  assert.equal(seekLandingOffsetFor(session, 4.004), OFFSET);
+});
+
+test("no keyframe list is still answered", () => {
+  assert.equal(seekLandingOffsetFor({ transcodeVideo: false }, 5), OFFSET);
+  assert.equal(seekLandingOffsetFor(null, 5), OFFSET);
+});
+
+test("a grid whose times are approximate is asked for that much later again", () => {
+  // AVI names a keyframe by its frame NUMBER and the time is that number times
+  // the frame duration, so a name can sit just BELOW the keyframe it refers to
+  // — measured 2026-08-21, 10-44 ms out on two files, always under one frame.
+  // Asking at the name alone would seek to before the real keyframe and land on
+  // the one before that, which is the fault this offset exists for.
+  const session = {
+    transcodeVideo: false,
+    file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 4.004, 8.008, 12.012], keyframeTolerance: 0.04 })
+  };
+  assert.equal(seekLandingOffsetFor(session, 4.004), OFFSET + 0.04);
+});
+
+test("an exact grid claims no tolerance", () => {
+  // Matroska and MP4 state instants outright — measured the same day, nine
+  // files and 11 665 keyframes with not one disagreement.
+  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 4.004, 8.008], keyframeTolerance: 0 }) };
+  assert.equal(seekLandingOffsetFor(session, 4.004), OFFSET);
+});
+
+test("the bound still holds once a tolerance is added", () => {
+  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 0.1, 0.2], keyframeTolerance: 1 }) };
+  assert.equal(seekLandingOffsetFor(session, 0.1), 0.05);
+});
+
+test("an output carrying only sound is not pushed past what it asked for", () => {
+  // The field failure of 2026-09-06: the sound played 130 ms ahead of the
+  // picture from every restart onward, and the viewer saw lips out of step with
+  // the voice from two minutes in.
+  //
+  // The offset exists because ffmpeg's demuxer moves a seek target back for a
+  // container it reads in decode order, after which a COPY lands on the previous
+  // keyframe. A re-encode trims to the requested time itself and is excluded —
+  // and an output with no picture is exactly that, since its one track is
+  // `-c:a aac`. It was not excluded, because the test asked whether the PICTURE
+  // is re-encoded and an output with no picture answers no.
+  const soundtrack = {
+    audioOnly: true,
+    transcodeVideo: false,
+    file: new SourceFile({ sourceKey: "s", fileIndex: 0 })
+      .learn({ keyframeTimes: [0, 4.004, 8.008, 12.012], keyframeTolerance: 0 })
+  };
+  assert.equal(seekLandingOffsetFor(soundtrack, 4.004), 0);
+});
+
+test("the picture of the same film still gets the offset", () => {
+  // The pair to the check above: the two outputs are repositioned to one
+  // boundary and must be given DIFFERENT requests, because one is copied and one
+  // is re-encoded. Given the same request they land 130 ms apart.
+  const picture = {
+    audioOnly: false,
+    transcodeVideo: false,
+    file: new SourceFile({ sourceKey: "s", fileIndex: 0 })
+      .learn({ keyframeTimes: [0, 4.004, 8.008, 12.012], keyframeTolerance: 0 })
+  };
+  assert.equal(seekLandingOffsetFor(picture, 4.004), OFFSET);
+});

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

@@ -0,0 +1,232 @@
+/**
+ * @file What goes first when the disk is short: the viewers decide.
+ *
+ * The store used to throw away whole outputs by when their directory was last
+ * read, which says nothing about what anybody is about to watch. The order here
+ * is the priority map's own, read from the other end: nobody's output first,
+ * then what is behind the earliest viewer, then what is ahead of the furthest.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { SegmentStore } from "../services/encode/SegmentStore.js";
+
+const SEGMENT = 1024;
+
+const format = {
+  isSegmentFileName: (name) => /^segment-\d{5}\.mp4$/.test(name),
+  segmentIndexFromName: (name) => {
+    const match = /^segment-(\d{5})\.mp4$/.exec(name);
+    return match ? Number(match[1]) : -1;
+  }
+};
+
+/**
+ * @param {number} [now]
+ */
+async function makeStore(now = 1000) {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "segment-store-test-"));
+  const clock = { at: now };
+  const store = new SegmentStore({ root, now: () => clock.at });
+  return { store, root, clock };
+}
+
+/**
+ * @param {SegmentStore} store
+ * @param {string} key
+ * @param {number[]} indexes
+ */
+async function fill(store, key, indexes) {
+  store.useFormat(key, format);
+  const dir = store.directoryFor(key);
+  for (const index of indexes) {
+    await fs.writeFile(
+      path.join(dir, `segment-${String(index).padStart(5, "0")}.mp4`),
+      Buffer.alloc(SEGMENT, index % 251)
+    );
+  }
+}
+
+/**
+ * @param {SegmentStore} store
+ * @param {string} key
+ */
+async function heldNumbers(store, key) {
+  const names = await fs.readdir(store.pathFor(key)).catch(() => []);
+  return names
+    .filter((name) => format.isSegmentFileName(name))
+    .map((name) => format.segmentIndexFromName(name))
+    .sort((left, right) => left - right);
+}
+
+test("what nobody is watching goes before anything anybody is", async () => {
+  const { store, root } = await makeStore();
+  try {
+    await fill(store, "watched", [0, 1, 2, 3]);
+    await fill(store, "abandoned", [0, 1, 2, 3]);
+
+    // Room for five segments of the eight held.
+    store.enforce({
+      idleMs: Number.POSITIVE_INFINITY,
+      maxBytes: 5 * SEGMENT,
+      viewersAt: (key) => (key === "watched" ? [2] : [])
+    });
+
+    // Three of eight had to go, and all three came from the output nobody is on.
+    assert.deepEqual(
+      await heldNumbers(store, "watched"),
+      [0, 1, 2, 3],
+      "the watched output lost segments while an unwatched one still held some"
+    );
+    assert.equal((await heldNumbers(store, "abandoned")).length, 1, "the unwatched output kept too much");
+  } finally {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("behind the viewer goes before ahead of the viewer, furthest behind first", async () => {
+  const { store, root } = await makeStore();
+  try {
+    await fill(store, "one", [0, 1, 2, 3, 4, 5]);
+
+    // The viewer stands on #3. Room for four of the six.
+    store.enforce({
+      idleMs: Number.POSITIVE_INFINITY,
+      maxBytes: 4 * SEGMENT,
+      viewersAt: () => [3]
+    });
+
+    assert.deepEqual(
+      await heldNumbers(store, "one"),
+      [2, 3, 4, 5],
+      "the two furthest behind the viewer should have gone, and nothing ahead"
+    );
+  } finally {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("with nothing left behind, the furthest ahead goes next", async () => {
+  const { store, root } = await makeStore();
+  try {
+    await fill(store, "one", [4, 5, 6, 7, 8]);
+
+    // The viewer is on #4, so nothing is behind. Room for three of the five.
+    store.enforce({
+      idleMs: Number.POSITIVE_INFINITY,
+      maxBytes: 3 * SEGMENT,
+      viewersAt: () => [4]
+    });
+
+    assert.deepEqual(
+      await heldNumbers(store, "one"),
+      [4, 5, 6],
+      "the two furthest ahead should have gone, nearest kept"
+    );
+  } finally {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("the segment a viewer is standing on is never taken", async () => {
+  const { store, root } = await makeStore();
+  try {
+    await fill(store, "one", [0, 1, 2]);
+
+    // Two viewers, one on each end, and room for one segment only.
+    store.enforce({
+      idleMs: Number.POSITIVE_INFINITY,
+      maxBytes: SEGMENT,
+      viewersAt: () => [0, 2]
+    });
+
+    const left = await heldNumbers(store, "one");
+    assert.ok(left.includes(0), "the segment the first viewer is on was taken");
+    assert.ok(left.includes(2), "the segment the second viewer is on was taken");
+    assert.deepEqual(left, [0, 2], "the one between two viewers should have gone");
+  } finally {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("two viewers of one output: behind the EARLIEST, ahead of the FURTHEST", async () => {
+  const { store, root } = await makeStore();
+  try {
+    await fill(store, "one", [0, 1, 2, 3, 4, 5, 6]);
+
+    // Viewers on #2 and #5. Behind means below #2; ahead means above #5.
+    store.enforce({
+      idleMs: Number.POSITIVE_INFINITY,
+      maxBytes: 5 * SEGMENT,
+      viewersAt: () => [2, 5]
+    });
+
+    assert.deepEqual(
+      await heldNumbers(store, "one"),
+      [2, 3, 4, 5, 6],
+      "what lies behind the earliest viewer must go before anything ahead of the furthest"
+    );
+  } finally {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("an output nobody has read for long enough goes whole, however much room there is", async () => {
+  const { store, root, clock } = await makeStore();
+  try {
+    await fill(store, "stale", [0, 1, 2]);
+    clock.at += 60 * 60 * 1000;
+    await fill(store, "fresh", [0, 1, 2]);
+
+    const result = store.enforce({
+      idleMs: 30 * 60 * 1000,
+      // Room for everything: this is the rule that does not wait for pressure.
+      maxBytes: Number.MAX_SAFE_INTEGER,
+      viewersAt: () => []
+    });
+
+    assert.equal(result.droppedIdle, 1);
+    assert.deepEqual(await heldNumbers(store, "stale"), [], "the stale output was kept");
+    assert.deepEqual(await heldNumbers(store, "fresh"), [0, 1, 2], "the fresh output was taken");
+  } finally {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("told nothing about viewers, it falls back to the oldest directory", async () => {
+  const { store, root, clock } = await makeStore();
+  try {
+    await fill(store, "older", [0, 1, 2]);
+    clock.at += 1000;
+    await fill(store, "newer", [0, 1, 2]);
+
+    const result = store.enforce({ idleMs: Number.POSITIVE_INFINITY, maxBytes: 4 * SEGMENT });
+
+    assert.equal(result.droppedForRoom, 1);
+    assert.deepEqual(await heldNumbers(store, "older"), []);
+    assert.deepEqual(await heldNumbers(store, "newer"), [0, 1, 2]);
+  } finally {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("a clean exit leaves nothing of ours, so what is found next time is from a kill", async () => {
+  const { store, root } = await makeStore();
+  try {
+    await fill(store, "one", [0, 1, 2]);
+    await fill(store, "two", [0, 1]);
+    // A directory this process adopted at startup and no session owns: the very
+    // thing the old rule left behind, which is how an orphan became permanent.
+    await fs.mkdir(path.join(root, "abandoned"), { recursive: true });
+    await fs.writeFile(path.join(root, "abandoned", "segment-00000.mp4"), Buffer.alloc(SEGMENT));
+
+    assert.equal(store.dropAll("the proxy is shutting down"), 2);
+
+    await assert.rejects(() => fs.stat(root), /ENOENT/, "the store left its root behind");
+  } finally {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});

package/test/segments-are-shared.test.js

@@ -140,7 +140,7 @@ test("what nobody has read for long enough goes, and time is the only judge", (t
   clock += 60_000;
   assert.deepEqual(
     store.enforce({ idleMs: 3_600_000, maxBytes: 1e9 }),
-    { droppedIdle: 0, droppedForRoom: 0, bytes: 32 }
+    { droppedIdle: 0, droppedForRoom: 0, segmentsRemoved: 0, bytes: 32 }
   );
 
   clock += 7_200_000;

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

@@ -59,7 +59,7 @@ test("a stored piece comes back byte for byte", async () => {
     assert.deepEqual(read, piece(0));
   } finally {
     await new Promise((resolve) => store.destroy(resolve));
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -79,7 +79,7 @@ test("pieces past the memory budget spill to disk and read back intact", async (
     }
   } finally {
     await new Promise((resolve) => store.destroy(resolve));
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -99,7 +99,7 @@ test("the short last piece keeps its own length", async () => {
     assert.deepEqual(read, tail);
   } finally {
     await new Promise((resolve) => store.destroy(resolve));
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -118,7 +118,7 @@ test("a buffer handed out survives later writes to the same slot", async () => {
     assert.deepEqual(held, piece(0), "the buffer changed under its holder");
   } finally {
     await new Promise((resolve) => store.destroy(resolve));
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -139,7 +139,7 @@ test("a pinned piece is not evicted to make room", async () => {
     store.unpin(0);
   } finally {
     await new Promise((resolve) => store.destroy(resolve));
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -160,7 +160,7 @@ test("refuses to make room when every resident piece is being read", async () =>
     store.unpin(0);
     store.unpin(1);
     await new Promise((resolve) => store.destroy(resolve));
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -179,7 +179,7 @@ test("a piece revived from disk is readable by offset again", async () => {
     assert.deepEqual(view, piece(0));
   } finally {
     await new Promise((resolve) => store.destroy(resolve));
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -205,7 +205,7 @@ test("a range within a piece is served correctly from memory and from disk", asy
     );
   } finally {
     await new Promise((resolve) => store.destroy(resolve));
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -230,7 +230,7 @@ test("takes memory as it needs it, not the whole budget up front", async () => {
     assert.deepEqual(await get(store, 0), piece(0), "an early piece was disturbed");
   } finally {
     await new Promise((resolve) => store.destroy(resolve));
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -257,7 +257,7 @@ test("counts where reads were served from, so the budget can be judged", async (
     assert.equal(stats.capacity, 2);
   } finally {
     await new Promise((resolve) => store.destroy(resolve));
-    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("counts a refusal caused by pinned pieces", async () => {
     store.unpin(0);
     store.unpin(1);
     await new Promise((resolve) => store.destroy(resolve));
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -292,5 +292,5 @@ test("destroy removes the spill file", async () => {
   const after = await fs.readdir(directory);
   assert.equal(after.length, 0, "the spill file outlived the store");
 
-  await fs.rm(directory, { recursive: true, force: true });
+  await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
 });