@torrent-tv/proxy 2.89.17 → 2.89.19

package/test/packet-witness.test.js

@@ -1,148 +0,0 @@
-/**
- * @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/transport/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-completeness.test.js

@@ -1,78 +0,0 @@
-/**
- * @file Whether a closed piece holds the whole of its stretch of film.
- *
- * Decided by the encoding from the cut table and the piece's own media; the
- * segment store only keeps what it is given.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { cutOf, judgePiece, originOf, productionOf } from "../services/encode/piece-completeness.js";
-import { SEGMENT_CUT_TIME_DELTA_SECONDS } from "../services/encode/output/index.js";
-import { readFileSync } from "node:fs";
-import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-
-const evidence = JSON.parse(readFileSync(new URL("./fixtures/refused-audio-20261002.json", import.meta.url)));
-const captured = (name) => fmp4Format.readMediaRanges(Buffer.from(evidence.files[name], "base64"));
-
-/** Media ending where stated, in the shape a format's reading has. */
-const endingAt = (seconds) => ({ end: seconds });
-const format = { producedThroughSeconds: (ranges) => ranges?.end ?? null };
-
-/** Cuts every ten seconds, ten pieces. */
-const timeline = { segmentCount: 10, publishedStartOf: (index) => index * 10 };
-
-test("a piece must reach its next cut less the delta the muxer is given", () => {
-  assert.equal(cutOf(timeline, 3), 40 - SEGMENT_CUT_TIME_DELTA_SECONDS);
-});
-
-test("the final piece has no next cut", () => {
-  assert.equal(cutOf(timeline, 9), undefined);
-  assert.deepEqual(judgePiece(format, endingAt(95), cutOf(timeline, 9)), { whole: true, throughSeconds: 95 });
-});
-
-test("an audio piece ending within the delta of its cut is whole", () => {
-  // Field 2026-10-01: AAC frames end 4.7389 s into a piece cut at 4.755 s.
-  const cut = 4.755 - SEGMENT_CUT_TIME_DELTA_SECONDS;
-  assert.equal(judgePiece(format, endingAt(4.738913832199547), cut).whole, true);
-});
-
-test("a piece closed short of its cut is not whole", () => {
-  // A run killed mid-piece: 84 ms of film where ten seconds were cut.
-  assert.deepEqual(judgePiece(format, endingAt(456.084), 466), { whole: false, throughSeconds: 456.084 });
-});
-
-test("a piece with no playable media is not whole, whatever its cut", () => {
-  assert.deepEqual(judgePiece(format, null, undefined), { whole: false, throughSeconds: null });
-});
-
-test("captured whole AAC pieces survive movie-time truncation and decimal cut subtraction", () => {
-  for (const [name, next] of [["making-0-00013.mp4", 81.415], ["making-0-00090.mp4", 618.076]]) {
-    const cut = cutOf({ segmentCount: 2, publishedStartOf: () => next }, 0);
-    const ranges = captured(name);
-    assert.equal(ranges.tracks[0].positionErrorTicks, 48n);
-    assert.equal(judgePiece(fmp4Format, ranges, cut).whole, true, name);
-    ranges.tracks[0].ranges.at(-1).end -= 1024n;
-    assert.equal(judgePiece(fmp4Format, ranges, cut).whole, false, "one lost AAC frame remains a refusal");
-  }
-});
-
-test("a restarted AAC cut follows its first packet rather than the requested seek", () => {
-  const ranges = captured("repair-13.mp4");
-  assert.equal(originOf(ranges, 81_364_000n, "soun"), 71_550_667n);
-  // The captured first packet is 71.5506667 s, 21.333 ms before -ss 71.572.
-  // segment.c adds it to the relative cut (81.415 - 71.572 = 9.843).
-  ranges.production = productionOf({ originMicros: 71_550_667n, endMicros: 81_364_000n }, [9.843], 0, "soun");
-  assert.equal(ranges.production.cutMicros, 81_343_667n);
-  assert.equal(judgePiece(fmp4Format, ranges, 81.365).whole, true);
-  ranges.production.endMicros -= 1024n * 1_000_000n / 48_000n;
-  assert.equal(judgePiece(fmp4Format, ranges, 81.365).whole, false);
-});
-
-test("a muxer's reference clock cannot conceal a shorter multiplexed track", () => {
-  const ranges = captured("making-0-00013.mp4");
-  ranges.production = productionOf({ originMicros: 0n, endMicros: 81_365_333n }, [81.415], 0, "soun");
-  const audio = ranges.tracks[0];
-  ranges.tracks.push({ ...audio, kind: "vide", ranges: audio.ranges.map(range => ({ ...range, end: range.end - 4800n })) });
-  assert.equal(judgePiece(fmp4Format, ranges, 81.365).whole, false);
-});

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

@@ -1,401 +0,0 @@
-/**
- * @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/storage/piece-store/piece-disk-store.js";
-
-const PIECE = 4096;
-
-test("bytes held before a memory wait cannot be forgotten or evicted", async () => {
-  const { store } = await makeStore(PIECE);
-  try {
-    await store.write(0, Buffer.alloc(PIECE, 7));
-    const release = store.hold(0);
-    store.forget(0);
-    store.forgetBehind([1]);
-    await store.write(1, Buffer.alloc(PIECE, 8));
-    const target = Buffer.alloc(PIECE);
-    assert.equal(await store.read(0, target), PIECE);
-    assert.equal(target[0], 7);
-    release();
-    release();
-    store.forget(0);
-    assert.equal(store.has(0), false);
-  } finally {
-    await store.destroy();
-  }
-});
-
-/**
- * @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/storage/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 });
-  }
-});
-
-test("what lies behind every reader goes without waiting for the disk to be short", async () => {
-  // THE SECOND RULE. The ceiling is a share of free space, and on a roomy host
-  // that is tens of gigabytes against a measured growth of 14 400 MB in one
-  // viewing — so the ceiling alone never binds and nothing is removed until the
-  // torrent itself goes. A piece behind every read head has been read.
-  const { store, directory } = await makeStore(1000 * PIECE);
-  try {
-    for (const index of [0, 1, 2, 3, 4, 5]) {
-      await store.write(index, pieceOf(index));
-    }
-
-    const removed = store.forgetBehind([3, 4]);
-    await store.settled();
-
-    assert.equal(removed, 3, "the three behind the earliest reader should have gone");
-    assert.deepEqual([0, 1, 2].map((index) => store.has(index)), [false, false, false]);
-    assert.deepEqual([3, 4, 5].map((index) => store.has(index)), [true, true, true]);
-    assert.equal(store.stats().behind, 3);
-  } finally {
-    await store.destroy();
-    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});
-
-test("with no reader at all, nothing is thrown away", async () => {
-  // A store between reads is not a store nobody wants. What empties it whole is
-  // the torrent going idle, which removes the store and its directory.
-  const { store, directory } = await makeStore(1000 * PIECE);
-  try {
-    for (const index of [0, 1, 2]) {
-      await store.write(index, pieceOf(index));
-    }
-    assert.equal(store.forgetBehind([]), 0);
-    assert.equal(store.size, 3);
-  } finally {
-    await store.destroy();
-    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});
-
-test("a piece being read is not taken even when it is behind everybody", async () => {
-  const { store, directory } = await makeStore(1000 * PIECE);
-  try {
-    await store.write(0, pieceOf(0));
-    await store.write(5, pieceOf(5));
-    const reading = store.read(0, Buffer.alloc(PIECE));
-    const removed = store.forgetBehind([5]);
-    await reading;
-    await store.settled();
-
-    assert.equal(removed, 0, "a piece under a reader was thrown away");
-    assert.equal(store.has(0), true);
-  } finally {
-    await store.destroy();
-    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});
-
-test("when there is no room, what is behind the readers goes before what is ahead", async () => {
-  const directory = await fs.mkdtemp(path.join(os.tmpdir(), "piece-disk-heads-"));
-  const clock = { at: 1000 };
-  // The reader stands on #5. #4 is behind it and was touched LAST, so under the
-  // old rule — least recently used — it would have been the safest piece there.
-  const store = new PieceDiskStore({
-    directory,
-    name: "pieces",
-    chunkLength: PIECE,
-    allowanceBytes: 3 * PIECE,
-    now: () => clock.at,
-    readHeads: () => [5]
-  });
-  try {
-    for (const index of [8, 7, 4]) {
-      clock.at += 100;
-      await store.write(index, pieceOf(index));
-    }
-    clock.at += 100;
-    await store.write(9, pieceOf(9));
-    await store.settled();
-
-    assert.equal(store.has(4), false, "the piece behind the reader was kept because it was touched last");
-    assert.deepEqual([7, 8, 9].map((index) => store.has(index)), [true, true, true]);
-  } finally {
-    await store.destroy();
-    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});
-
-test("a store takes up the pieces a previous life left in its directory", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "adopt-"));
-  try {
-    const first = new PieceDiskStore({ directory: root, name: "film.pieces", chunkLength: 1024 });
-    await first.write(7, Buffer.alloc(1024, 7));
-    await first.write(9, Buffer.alloc(1024, 9));
-    await first.close();
-
-    // A torrent torn down and added again gets a NEW store over the same
-    // directory. Before 2026-09-11 its index started empty, so every piece it
-    // in fact had read as missing and the film was downloaded a second time
-    // while the first copy sat beside it.
-    const second = new PieceDiskStore({ directory: root, name: "film.pieces", chunkLength: 1024 });
-    assert.equal(second.size, 2, "the pieces already on disk were not taken up");
-    assert.equal(second.bytes, 2048, "nor were their bytes counted");
-    assert.ok(second.has(7) && second.has(9));
-
-    const target = Buffer.alloc(1024);
-    await second.read(7, target);
-    assert.ok(target.equals(Buffer.alloc(1024, 7)), "and they read back as themselves");
-    await second.destroy();
-  } finally {
-    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});