@torrent-tv/proxy 2.80.19 → 2.81.1

package/test/packet-witness.test.js

@@ -1,148 +1,148 @@
-/**
- * @file The packet witness's gating rules and command construction.
- *
- * Roadmap item 10: a send queue wedged longer than ~30 s must start a bounded
- * tcpdump on its own, because the 2026-08-24 episode proved no counter above
- * the wire can name the cause. Everything here is the part that decides WHEN
- * and WITH WHAT ARGUMENTS — the spawning itself is thin glue around these.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  buildTcpdumpArgs,
-  createPacketWitness,
-  isWitnessCapture,
-  isWitnessRingFile,
-  normalizeRemoteAddress,
-  shouldStartCapture,
-  WITNESS_RING_FILE_MB,
-  WITNESS_RING_FILES,
-  WITNESS_RTO_CEILING_SECONDS,
-  WITNESS_TAIL_SECONDS
-} from "../services/packet-witness.js";
-
-test("an IPv4 literal survives unchanged", () => {
-  assert.equal(normalizeRemoteAddress("192.168.178.57"), "192.168.178.57");
-});
-
-test("an IPv6 literal survives unchanged", () => {
-  assert.equal(
-    normalizeRemoteAddress("2001:1c00:a603:2100:a129:a1a1:7f07:3f0b"),
-    "2001:1c00:a603:2100:a129:a1a1:7f07:3f0b"
-  );
-});
-
-test("a zone suffix is stripped", () => {
-  assert.equal(normalizeRemoteAddress("fe80::2aca:8001:3ba6:f16f%18"), "fe80::2aca:8001:3ba6:f16f");
-});
-
-test("hostnames, garbage and shell text are rejected", () => {
-  assert.equal(normalizeRemoteAddress("homeassistant.local"), null);
-  assert.equal(normalizeRemoteAddress("8.8.8.8; rm -rf /"), null);
-  assert.equal(normalizeRemoteAddress("999.1.1.1"), null);
-  assert.equal(normalizeRemoteAddress(""), null);
-  assert.equal(normalizeRemoteAddress(undefined), null);
-  assert.equal(normalizeRemoteAddress(42), null);
-});
-
-test("the tcpdump command line is bounded and filtered to one peer", () => {
-  const args = buildTcpdumpArgs({
-    host: "2001:db8::1",
-    port: 9090,
-    filePrefix: "/data/packet-witness.e2b5ef39.1787600000.pcap"
-  });
-  assert.deepEqual(args, [
-    "-n",
-    "-S",
-    "-s",
-    "128",
-    "-i",
-    "any",
-    "-w",
-    "/data/packet-witness.e2b5ef39.1787600000.pcap",
-    "-C",
-    String(WITNESS_RING_FILE_MB),
-    "-W",
-    String(WITNESS_RING_FILES),
-    "udp",
-    "and",
-    "port",
-    "9090",
-    "and",
-    "host",
-    "2001:db8::1"
-  ]);
-});
-
-test("rotation is by size, so the ring files cannot collapse onto one name", () => {
-  // `-G` with a name carrying no strftime field overwrote a single file, which
-  // is why both field captures held 28 s instead of the intended 120.
-  const args = buildTcpdumpArgs({ port: 9090, filePrefix: "/data/ring.pcap" });
-  assert.equal(args.includes("-G"), false);
-  assert.equal(args[args.indexOf("-C") + 1], String(WITNESS_RING_FILE_MB));
-});
-
-test("with no peer named the ring records every peer on the port", () => {
-  const args = buildTcpdumpArgs({ port: 9090, filePrefix: "/data/ring.pcap" });
-  assert.equal(args.includes("host"), false);
-  assert.deepEqual(args.slice(-4), ["udp", "and", "port", "9090"]);
-});
-
-test("the tail outlasts three retransmission timeouts", () => {
-  assert.equal(WITNESS_TAIL_SECONDS, WITNESS_RTO_CEILING_SECONDS * 3);
-  // A zero-window probe is due once per timeout, so a window shorter than the
-  // ceiling could not tell silence from a probe that had not come round yet.
-  assert.ok(WITNESS_TAIL_SECONDS > WITNESS_RTO_CEILING_SECONDS);
-});
-
-test("ring files are told apart from the copies kept as evidence", () => {
-  assert.equal(isWitnessRingFile("packet-witness-ring.pcap"), true);
-  assert.equal(isWitnessRingFile("packet-witness-ring.pcap3"), true);
-  assert.equal(isWitnessRingFile("packet-witness.e2b5ef39.1787600000.before1.pcap"), false);
-  assert.equal(isWitnessCapture("packet-witness-ring.pcap3"), false);
-  assert.equal(isWitnessCapture("packet-witness.e2b5ef39.1787600000.before1.pcap"), true);
-  assert.equal(isWitnessCapture("packet-witness.e2b5ef39.1787600000.tail.pcap1"), true);
-});
-
-test("one capture runs at a time", () => {
-  assert.equal(shouldStartCapture({ running: true, lastStartedAt: Date.now() }), false);
-});
-
-test("the first capture of a process is always allowed", () => {
-  assert.equal(shouldStartCapture({ running: false, lastStartedAt: 0, now: 1000 }), true);
-});
-
-test("a capture within the cooldown is refused, one after it is allowed", () => {
-  const state = { running: false, lastStartedAt: 10_000 };
-  assert.equal(shouldStartCapture({ ...state, now: 10_000 + 599_999 }), false);
-  assert.equal(shouldStartCapture({ ...state, now: 10_000 + 600_000 }), true);
-});
-
-test("capture files are recognised by name, rotations included", () => {
-  assert.equal(isWitnessCapture("packet-witness.e2b5ef39.1787600000.pcap"), true);
-  assert.equal(isWitnessCapture("packet-witness.e2b5ef39.1787600000.pcap20260825T120000"), true);
-  assert.equal(isWitnessCapture("core.WorkerThread.81.1787600000"), false);
-  assert.equal(isWitnessCapture("proxy.log"), false);
-  assert.equal(isWitnessCapture("../packet-witness.x.pcap"), false);
-});
-
-test("a trigger without a usable remote endpoint is refused without touching anything", () => {
-  const lines = [];
-  const witness = createPacketWitness({
-    log: (message) => lines.push(message),
-    dir: "",
-    port: 9090
-  });
-  const started = witness.maybeCapture({
-    sessionId: "e2b5ef39-0000",
-    tag: "e2b5ef39",
-    label: "proxy",
-    remote: null,
-    queuedBytes: 160_000_000,
-    stuckForMs: 31_000
-  });
-  assert.equal(started, false);
-  assert.deepEqual(lines, []);
-});
+/**
+ * @file The packet witness's gating rules and command construction.
+ *
+ * Roadmap item 10: a send queue wedged longer than ~30 s must start a bounded
+ * tcpdump on its own, because the 2026-08-24 episode proved no counter above
+ * the wire can name the cause. Everything here is the part that decides WHEN
+ * and WITH WHAT ARGUMENTS — the spawning itself is thin glue around these.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  buildTcpdumpArgs,
+  createPacketWitness,
+  isWitnessCapture,
+  isWitnessRingFile,
+  normalizeRemoteAddress,
+  shouldStartCapture,
+  WITNESS_RING_FILE_MB,
+  WITNESS_RING_FILES,
+  WITNESS_RTO_CEILING_SECONDS,
+  WITNESS_TAIL_SECONDS
+} from "../services/packet-witness.js";
+
+test("an IPv4 literal survives unchanged", () => {
+  assert.equal(normalizeRemoteAddress("192.168.178.57"), "192.168.178.57");
+});
+
+test("an IPv6 literal survives unchanged", () => {
+  assert.equal(
+    normalizeRemoteAddress("2001:1c00:a603:2100:a129:a1a1:7f07:3f0b"),
+    "2001:1c00:a603:2100:a129:a1a1:7f07:3f0b"
+  );
+});
+
+test("a zone suffix is stripped", () => {
+  assert.equal(normalizeRemoteAddress("fe80::2aca:8001:3ba6:f16f%18"), "fe80::2aca:8001:3ba6:f16f");
+});
+
+test("hostnames, garbage and shell text are rejected", () => {
+  assert.equal(normalizeRemoteAddress("homeassistant.local"), null);
+  assert.equal(normalizeRemoteAddress("8.8.8.8; rm -rf /"), null);
+  assert.equal(normalizeRemoteAddress("999.1.1.1"), null);
+  assert.equal(normalizeRemoteAddress(""), null);
+  assert.equal(normalizeRemoteAddress(undefined), null);
+  assert.equal(normalizeRemoteAddress(42), null);
+});
+
+test("the tcpdump command line is bounded and filtered to one peer", () => {
+  const args = buildTcpdumpArgs({
+    host: "2001:db8::1",
+    port: 9090,
+    filePrefix: "/data/packet-witness.e2b5ef39.1787600000.pcap"
+  });
+  assert.deepEqual(args, [
+    "-n",
+    "-S",
+    "-s",
+    "128",
+    "-i",
+    "any",
+    "-w",
+    "/data/packet-witness.e2b5ef39.1787600000.pcap",
+    "-C",
+    String(WITNESS_RING_FILE_MB),
+    "-W",
+    String(WITNESS_RING_FILES),
+    "udp",
+    "and",
+    "port",
+    "9090",
+    "and",
+    "host",
+    "2001:db8::1"
+  ]);
+});
+
+test("rotation is by size, so the ring files cannot collapse onto one name", () => {
+  // `-G` with a name carrying no strftime field overwrote a single file, which
+  // is why both field captures held 28 s instead of the intended 120.
+  const args = buildTcpdumpArgs({ port: 9090, filePrefix: "/data/ring.pcap" });
+  assert.equal(args.includes("-G"), false);
+  assert.equal(args[args.indexOf("-C") + 1], String(WITNESS_RING_FILE_MB));
+});
+
+test("with no peer named the ring records every peer on the port", () => {
+  const args = buildTcpdumpArgs({ port: 9090, filePrefix: "/data/ring.pcap" });
+  assert.equal(args.includes("host"), false);
+  assert.deepEqual(args.slice(-4), ["udp", "and", "port", "9090"]);
+});
+
+test("the tail outlasts three retransmission timeouts", () => {
+  assert.equal(WITNESS_TAIL_SECONDS, WITNESS_RTO_CEILING_SECONDS * 3);
+  // A zero-window probe is due once per timeout, so a window shorter than the
+  // ceiling could not tell silence from a probe that had not come round yet.
+  assert.ok(WITNESS_TAIL_SECONDS > WITNESS_RTO_CEILING_SECONDS);
+});
+
+test("ring files are told apart from the copies kept as evidence", () => {
+  assert.equal(isWitnessRingFile("packet-witness-ring.pcap"), true);
+  assert.equal(isWitnessRingFile("packet-witness-ring.pcap3"), true);
+  assert.equal(isWitnessRingFile("packet-witness.e2b5ef39.1787600000.before1.pcap"), false);
+  assert.equal(isWitnessCapture("packet-witness-ring.pcap3"), false);
+  assert.equal(isWitnessCapture("packet-witness.e2b5ef39.1787600000.before1.pcap"), true);
+  assert.equal(isWitnessCapture("packet-witness.e2b5ef39.1787600000.tail.pcap1"), true);
+});
+
+test("one capture runs at a time", () => {
+  assert.equal(shouldStartCapture({ running: true, lastStartedAt: Date.now() }), false);
+});
+
+test("the first capture of a process is always allowed", () => {
+  assert.equal(shouldStartCapture({ running: false, lastStartedAt: 0, now: 1000 }), true);
+});
+
+test("a capture within the cooldown is refused, one after it is allowed", () => {
+  const state = { running: false, lastStartedAt: 10_000 };
+  assert.equal(shouldStartCapture({ ...state, now: 10_000 + 599_999 }), false);
+  assert.equal(shouldStartCapture({ ...state, now: 10_000 + 600_000 }), true);
+});
+
+test("capture files are recognised by name, rotations included", () => {
+  assert.equal(isWitnessCapture("packet-witness.e2b5ef39.1787600000.pcap"), true);
+  assert.equal(isWitnessCapture("packet-witness.e2b5ef39.1787600000.pcap20260825T120000"), true);
+  assert.equal(isWitnessCapture("core.WorkerThread.81.1787600000"), false);
+  assert.equal(isWitnessCapture("proxy.log"), false);
+  assert.equal(isWitnessCapture("../packet-witness.x.pcap"), false);
+});
+
+test("a trigger without a usable remote endpoint is refused without touching anything", () => {
+  const lines = [];
+  const witness = createPacketWitness({
+    log: (message) => lines.push(message),
+    dir: "",
+    port: 9090
+  });
+  const started = witness.maybeCapture({
+    sessionId: "e2b5ef39-0000",
+    tag: "e2b5ef39",
+    label: "proxy",
+    remote: null,
+    queuedBytes: 160_000_000,
+    stuckForMs: 31_000
+  });
+  assert.equal(started, false);
+  assert.deepEqual(lines, []);
+});

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

@@ -0,0 +1,267 @@
+/**
+ * @file The spilled pieces are bounded, and the bound returns disk.
+ *
+ * What these pin is the difference between this store and the tier it replaced.
+ * That one wrote into one sparse file and answered `forget` by dropping a
+ * number: nothing it did returned a block, and a store holding 400 MB had
+ * written 14.4 GB to the disk in fifty minutes (field 2026-08-31). So the
+ * assertions here are about the DISK, read back from the file system, not about
+ * the store's own bookkeeping — the bookkeeping was never what was wrong.
+ */
+
+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 { PieceDiskStore } from "../services/piece-store/piece-disk-store.js";
+
+const PIECE = 4096;
+
+/**
+ * @param {number | null} allowanceBytes
+ * @returns {Promise<{ store: PieceDiskStore, directory: string, clock: { at: number } }>}
+ */
+async function makeStore(allowanceBytes) {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), "piece-disk-test-"));
+  const clock = { at: 1000 };
+  const store = new PieceDiskStore({
+    directory,
+    name: "pieces",
+    chunkLength: PIECE,
+    allowanceBytes,
+    now: () => clock.at
+  });
+  return { store, directory, clock };
+}
+
+/**
+ * What the store's directory actually holds, in bytes and in files.
+ *
+ * @param {PieceDiskStore} store
+ * @returns {Promise<{ files: number, bytes: number }>}
+ */
+async function onDisk(store) {
+  let names = [];
+  try {
+    names = await fs.readdir(store.path);
+  } catch {
+    return { files: 0, bytes: 0 };
+  }
+  let bytes = 0;
+  for (const name of names) {
+    const stat = await fs.stat(path.join(store.path, name));
+    bytes += stat.size;
+  }
+  return { files: names.length, bytes };
+}
+
+const pieceOf = (index) => Buffer.alloc(PIECE, index % 251);
+
+test("told nothing, it holds everything — which is what it did before it could count", async () => {
+  const { store, directory } = await makeStore(null);
+  try {
+    for (let index = 0; index < 8; index += 1) {
+      await store.write(index, pieceOf(index));
+    }
+    assert.equal(store.size, 8, "a store with no allowance threw something away");
+    assert.equal(store.bytes, 8 * PIECE);
+    assert.deepEqual(await onDisk(store), { files: 8, bytes: 8 * PIECE });
+  } finally {
+    await store.destroy();
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("over its allowance it throws the least recently used away, and the disk shrinks with it", async () => {
+  const { store, directory, clock } = await makeStore(3 * PIECE);
+  try {
+    for (const index of [0, 1, 2]) {
+      clock.at += 100;
+      await store.write(index, pieceOf(index));
+    }
+    assert.deepEqual(await onDisk(store), { files: 3, bytes: 3 * PIECE }, "the store did not fill");
+
+    // Piece 0 is the oldest and nobody has read it since.
+    clock.at += 100;
+    await store.write(3, pieceOf(3));
+    await store.settled();
+
+    assert.equal(store.has(0), false, "the oldest piece was kept");
+    assert.equal(store.has(3), true, "the arriving piece was not stored");
+    assert.equal(store.bytes, 3 * PIECE, "the store counts more than its allowance");
+    // THE POINT: not the count in memory, the blocks on the disk.
+    assert.deepEqual(
+      await onDisk(store),
+      { files: 3, bytes: 3 * PIECE },
+      "the disk kept the bytes of the piece that was thrown away"
+    );
+    assert.equal(store.stats().evictions, 1);
+  } finally {
+    await store.destroy();
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("reading a piece keeps it: the oldest is not the least wanted", async () => {
+  const { store, directory, clock } = await makeStore(3 * PIECE);
+  try {
+    for (const index of [0, 1, 2]) {
+      clock.at += 100;
+      await store.write(index, pieceOf(index));
+    }
+    // Piece 0 is read, which makes piece 1 the oldest.
+    clock.at += 100;
+    await store.read(0, Buffer.alloc(PIECE));
+
+    clock.at += 100;
+    await store.write(3, pieceOf(3));
+    await store.settled();
+
+    assert.equal(store.has(0), true, "a piece that was just read was thrown away");
+    assert.equal(store.has(1), false, "the piece nobody had touched was kept");
+  } finally {
+    await store.destroy();
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("a piece being read is never the victim, however old it is", async () => {
+  const { store, directory, clock } = await makeStore(3 * PIECE);
+  try {
+    for (const index of [0, 1, 2]) {
+      clock.at += 100;
+      await store.write(index, pieceOf(index));
+    }
+    // Piece 0 is the oldest AND is being read. The read is not awaited, so the
+    // write below decides while it is still outstanding.
+    const reading = store.read(0, Buffer.alloc(PIECE));
+    clock.at += 100;
+    await store.write(3, pieceOf(3));
+    const bytes = await reading;
+    await store.settled();
+
+    assert.equal(bytes, PIECE, "the read did not complete");
+    assert.equal(store.has(0), true, "a piece being read was thrown away under the reader");
+    assert.equal(store.has(1), false, "the next oldest should have gone instead");
+  } finally {
+    await store.destroy();
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("a piece thrown away is answered as absent, so the swarm is asked for it again", async () => {
+  const { store, directory, clock } = await makeStore(PIECE);
+  try {
+    await store.write(0, pieceOf(0));
+    clock.at += 100;
+    await store.write(1, pieceOf(1));
+    await store.settled();
+
+    assert.equal(store.has(0), false, "the store still claims a piece it threw away");
+    await assert.rejects(
+      () => store.read(0, Buffer.alloc(PIECE)),
+      /Piece 0 is not on disk/,
+      "reading a thrown-away piece must say so rather than answer bytes"
+    );
+  } finally {
+    await store.destroy();
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("a piece wanted again after being thrown away is written, not refused", async () => {
+  const { store, directory, clock } = await makeStore(PIECE);
+  try {
+    await store.write(0, pieceOf(0));
+    clock.at += 100;
+    await store.write(1, pieceOf(1));
+    clock.at += 100;
+    // Piece 0 again, while its own removal may still be in flight.
+    await store.write(0, pieceOf(0));
+    await store.settled();
+
+    assert.equal(store.has(0), true, "the piece did not come back");
+    const target = Buffer.alloc(PIECE);
+    await store.read(0, target);
+    assert.ok(target.equals(pieceOf(0)), "the piece came back wrong");
+    assert.equal(store.bytes, PIECE, "the store is over its allowance");
+  } finally {
+    await store.destroy();
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("lowering the allowance frees nothing by itself, and binds the next write", async () => {
+  const { store, directory, clock } = await makeStore(null);
+  try {
+    for (const index of [0, 1, 2]) {
+      clock.at += 100;
+      await store.write(index, pieceOf(index));
+    }
+    store.reviseAllowance(PIECE);
+    assert.equal(store.size, 3, "lowering the allowance threw pieces away on its own");
+
+    clock.at += 100;
+    await store.write(3, pieceOf(3));
+    await store.settled();
+    assert.equal(store.size, 1, "the next write did not bring it within the allowance");
+    assert.deepEqual(await onDisk(store), { files: 1, bytes: PIECE });
+  } finally {
+    await store.destroy();
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("an allowance smaller than one piece keeps the arriving piece rather than losing it", async () => {
+  // A piece the swarm has already paid for is not thrown away because the
+  // arithmetic says there is no room for anything: the alternative is fetching
+  // it again, which costs ~1430 ms against a write measured in milliseconds.
+  const { store, directory } = await makeStore(1);
+  try {
+    await store.write(0, pieceOf(0));
+    await store.settled();
+    assert.equal(store.has(0), true, "the arriving piece was refused");
+    assert.equal(store.size, 1);
+  } finally {
+    await store.destroy();
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("destroying it takes the directory with it", async () => {
+  const { store, directory } = await makeStore(null);
+  await store.write(0, pieceOf(0));
+  const where = store.path;
+  await store.destroy();
+  await assert.rejects(() => fs.stat(where), /ENOENT/, "the store left its directory behind");
+  await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+});
+
+test("the spill ceiling is what the disk's owner said, divided between the stores", async () => {
+  const { reviseSpillBudgets, SharedPieceStore } = await import("../services/piece-store/shared-piece-store.js");
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), "spill-share-"));
+  const stores = [
+    new SharedPieceStore(PIECE, { length: PIECE * 8, memoryBytes: PIECE, path: directory, name: "one" }),
+    new SharedPieceStore(PIECE, { length: PIECE * 8, memoryBytes: PIECE, path: directory, name: "two" })
+  ];
+  try {
+    const revised = reviseSpillBudgets(100 * PIECE, stores);
+    assert.deepEqual(
+      revised.map((store) => store.allowanceBytes),
+      [50 * PIECE, 50 * PIECE],
+      "one thread's share is divided equally between its stores"
+    );
+
+    // Nobody has said yet: nothing is thrown away, which is what it always did.
+    assert.deepEqual(
+      reviseSpillBudgets(null, stores).map((store) => store.allowanceBytes),
+      [null, null]
+    );
+  } finally {
+    for (const store of stores) {
+      await new Promise((resolve) => store.destroy(resolve));
+    }
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});

package/test/piece-reader.test.js

@@ -99,7 +99,7 @@ test("a range inside one piece is read from that piece only", async () => {
     assert.deepEqual(bytes, expectedBytes(100, 100));
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -117,7 +117,7 @@ test("a range spanning pieces reassembles in order", async () => {
     assert.deepEqual(bytes, expectedBytes(start, end - start + 1));
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -136,7 +136,7 @@ test("a file that does not start at a piece boundary is still read correctly", a
     assert.deepEqual(bytes, expectedBytes(fileOffset, 1500));
   } finally {
     store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true });
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
@@ -157,6 +157,6 @@ test("every fragment releases its pin, so nothing stays held", async () => {
     assert.equal(store.stats().blockedByPins, before, "a pin was left 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 });
   }
 });