@torrent-tv/proxy 2.87.10 → 2.87.12

package/test/encoder-kinds.test.js

@@ -1,122 +1,122 @@
-/**
- * @file What every encoder kind must state about itself, and the properties of
- * its arguments that a field failure paid for.
- *
- * Deliberately NOT a transcription of the argument lists: a test written by
- * copying the code cannot fail when the code is wrong. What is stated here is
- * what must hold for ANY kind, including one added later, plus the two
- * kind-specific facts that were learned by running the thing on real hardware.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { Encoder } from "../services/encode/Encoder.js";
-import { NvencEncoder } from "../services/encode/NvencEncoder.js";
-import { QsvEncoder } from "../services/encode/QsvEncoder.js";
-import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
-import { V4l2m2mEncoder } from "../services/encode/V4l2m2mEncoder.js";
-import { VaapiEncoder } from "../services/encode/VaapiEncoder.js";
-
-const KINDS = [
-  new SoftwareEncoder(),
-  new VaapiEncoder("/dev/dri/renderD128"),
-  new QsvEncoder("/dev/dri/renderD128"),
-  new NvencEncoder(),
-  new V4l2m2mEncoder()
-];
-
-const BASE = { targetWidth: 1280, targetHeight: 720, segmentDurationSec: 4, fps: 24 };
-
-test("a kind's arguments name the encoder the kind claims to be", () => {
-  // The one thing that must never drift: a class called `h264_nvenc` that puts
-  // `libx264` on the command line would be filed under an address promising
-  // the other one's header.
-  for (const encoder of KINDS) {
-    const args = encoder.buildVideoArgs(BASE);
-    const at = args.indexOf("-c:v");
-    assert.notEqual(at, -1, `${encoder.name} names no video encoder`);
-    assert.equal(args[at + 1], encoder.name, `${encoder.name} builds ${args[at + 1]}`);
-  }
-});
-
-test("an explicit cut list is passed through exactly, by every kind", () => {
-  // This is what makes a re-encoded step splice into a copied picture: it has
-  // to be cut at the source's own keyframe times and nowhere else. A kind that
-  // rounded them, or dropped them for its own even grid, would produce segments
-  // that cannot stand where the copy's would.
-  const times = [0, 4.271, 8.9, 13.04];
-  for (const encoder of KINDS) {
-    const args = encoder.buildVideoArgs({ ...BASE, forcedKeyframeTimes: times });
-    const at = args.indexOf("-force_key_frames");
-    assert.notEqual(at, -1, `${encoder.name} forces no keyframes`);
-    assert.equal(args[at + 1], times.join(","), `${encoder.name} altered the cut list`);
-  }
-});
-
-test("with no cut list, keyframes are still placed on the segment grid", () => {
-  for (const encoder of KINDS) {
-    const args = encoder.buildVideoArgs({ ...BASE, forcedKeyframeTimes: null });
-    const joined = args.join(" ");
-    // Either forced by time, or by a frame-count GOP — both put a keyframe on
-    // every boundary, which is what makes a segment independently decodable.
-    const byTime = joined.includes("-force_key_frames expr:gte(t,n_forced*4)");
-    const byFrameCount = joined.includes(`-g ${4 * 24}`);
-    assert.ok(byTime || byFrameCount, `${encoder.name} places keyframes by neither rule`);
-  }
-});
-
-test("a target box of nothing still produces a usable size", () => {
-  // The session manager passes 0 for "keep the source size"; a kind that let
-  // that through would build `scale=0:0`.
-  for (const encoder of KINDS) {
-    const args = encoder.buildVideoArgs({ ...BASE, targetWidth: 0, targetHeight: 0 });
-    assert.ok(!args.join(" ").includes("=0:"), `${encoder.name} scaled to zero`);
-  }
-});
-
-test("every kind says what its speed setting is, or that it has none", () => {
-  for (const encoder of KINDS) {
-    const ladder = encoder.speedLadder;
-    assert.equal(typeof ladder.note, "string");
-    assert.ok(ladder.note.length > 0, `${encoder.name} explains nothing about its ladder`);
-    assert.ok(Array.isArray(ladder.values));
-    if (ladder.values.length > 0) {
-      assert.ok(ladder.flag.length > 0, `${encoder.name} lists settings but names no option`);
-    }
-  }
-});
-
-test("only libx264 claims a measured ladder", () => {
-  // The four hardware kinds have never been benchmarked across their settings,
-  // and a ladder claiming to be measured is what would let something start
-  // choosing from it.
-  for (const encoder of KINDS) {
-    assert.equal(
-      encoder.speedLadder.measured,
-      encoder.kind === "software",
-      `${encoder.name} misreports whether its ladder was measured`
-    );
-  }
-});
-
-test("a kind that is not software is hardware, and says so", () => {
-  for (const encoder of KINDS) {
-    assert.equal(encoder.isHardware, encoder.kind !== "software");
-  }
-});
-
-test("the encoder on an ARM board always asks for more capture buffers", () => {
-  // The default of four deadlocks on the CM4 — "All capture buffers returned to
-  // userspace" — so this is not a tuning choice but the condition under which
-  // that encoder runs at all.
-  const args = new V4l2m2mEncoder().buildVideoArgs(BASE);
-  const at = args.indexOf("-num_capture_buffers");
-  assert.notEqual(at, -1, "v4l2m2m was given the default buffer count");
-  assert.ok(Number(args[at + 1]) > 4);
-});
-
-test("a kind that does not say how to build its arguments refuses rather than producing none", () => {
-  class Unstated extends Encoder {}
-  const encoder = new Unstated({ name: "h264_unstated", kind: "nvenc" });
-  assert.throws(() => encoder.buildVideoArgs(BASE), /does not say how/);
-});
+/**
+ * @file What every encoder kind must state about itself, and the properties of
+ * its arguments that a field failure paid for.
+ *
+ * Deliberately NOT a transcription of the argument lists: a test written by
+ * copying the code cannot fail when the code is wrong. What is stated here is
+ * what must hold for ANY kind, including one added later, plus the two
+ * kind-specific facts that were learned by running the thing on real hardware.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Encoder } from "../services/encode/Encoder.js";
+import { NvencEncoder } from "../services/encode/NvencEncoder.js";
+import { QsvEncoder } from "../services/encode/QsvEncoder.js";
+import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
+import { V4l2m2mEncoder } from "../services/encode/V4l2m2mEncoder.js";
+import { VaapiEncoder } from "../services/encode/VaapiEncoder.js";
+
+const KINDS = [
+  new SoftwareEncoder(),
+  new VaapiEncoder("/dev/dri/renderD128"),
+  new QsvEncoder("/dev/dri/renderD128"),
+  new NvencEncoder(),
+  new V4l2m2mEncoder()
+];
+
+const BASE = { targetWidth: 1280, targetHeight: 720, segmentDurationSec: 4, fps: 24 };
+
+test("a kind's arguments name the encoder the kind claims to be", () => {
+  // The one thing that must never drift: a class called `h264_nvenc` that puts
+  // `libx264` on the command line would be filed under an address promising
+  // the other one's header.
+  for (const encoder of KINDS) {
+    const args = encoder.buildVideoArgs(BASE);
+    const at = args.indexOf("-c:v");
+    assert.notEqual(at, -1, `${encoder.name} names no video encoder`);
+    assert.equal(args[at + 1], encoder.name, `${encoder.name} builds ${args[at + 1]}`);
+  }
+});
+
+test("an explicit cut list is passed through exactly, by every kind", () => {
+  // This is what makes a re-encoded step splice into a copied picture: it has
+  // to be cut at the source's own keyframe times and nowhere else. A kind that
+  // rounded them, or dropped them for its own even grid, would produce segments
+  // that cannot stand where the copy's would.
+  const times = [0, 4.271, 8.9, 13.04];
+  for (const encoder of KINDS) {
+    const args = encoder.buildVideoArgs({ ...BASE, forcedKeyframeTimes: times });
+    const at = args.indexOf("-force_key_frames");
+    assert.notEqual(at, -1, `${encoder.name} forces no keyframes`);
+    assert.equal(args[at + 1], times.join(","), `${encoder.name} altered the cut list`);
+  }
+});
+
+test("with no cut list, keyframes are still placed on the segment grid", () => {
+  for (const encoder of KINDS) {
+    const args = encoder.buildVideoArgs({ ...BASE, forcedKeyframeTimes: null });
+    const joined = args.join(" ");
+    // Either forced by time, or by a frame-count GOP — both put a keyframe on
+    // every boundary, which is what makes a segment independently decodable.
+    const byTime = joined.includes("-force_key_frames expr:gte(t,n_forced*4)");
+    const byFrameCount = joined.includes(`-g ${4 * 24}`);
+    assert.ok(byTime || byFrameCount, `${encoder.name} places keyframes by neither rule`);
+  }
+});
+
+test("a target box of nothing still produces a usable size", () => {
+  // The session manager passes 0 for "keep the source size"; a kind that let
+  // that through would build `scale=0:0`.
+  for (const encoder of KINDS) {
+    const args = encoder.buildVideoArgs({ ...BASE, targetWidth: 0, targetHeight: 0 });
+    assert.ok(!args.join(" ").includes("=0:"), `${encoder.name} scaled to zero`);
+  }
+});
+
+test("every kind says what its speed setting is, or that it has none", () => {
+  for (const encoder of KINDS) {
+    const ladder = encoder.speedLadder;
+    assert.equal(typeof ladder.note, "string");
+    assert.ok(ladder.note.length > 0, `${encoder.name} explains nothing about its ladder`);
+    assert.ok(Array.isArray(ladder.values));
+    if (ladder.values.length > 0) {
+      assert.ok(ladder.flag.length > 0, `${encoder.name} lists settings but names no option`);
+    }
+  }
+});
+
+test("only libx264 claims a measured ladder", () => {
+  // The four hardware kinds have never been benchmarked across their settings,
+  // and a ladder claiming to be measured is what would let something start
+  // choosing from it.
+  for (const encoder of KINDS) {
+    assert.equal(
+      encoder.speedLadder.measured,
+      encoder.kind === "software",
+      `${encoder.name} misreports whether its ladder was measured`
+    );
+  }
+});
+
+test("a kind that is not software is hardware, and says so", () => {
+  for (const encoder of KINDS) {
+    assert.equal(encoder.isHardware, encoder.kind !== "software");
+  }
+});
+
+test("the encoder on an ARM board always asks for more capture buffers", () => {
+  // The default of four deadlocks on the CM4 — "All capture buffers returned to
+  // userspace" — so this is not a tuning choice but the condition under which
+  // that encoder runs at all.
+  const args = new V4l2m2mEncoder().buildVideoArgs(BASE);
+  const at = args.indexOf("-num_capture_buffers");
+  assert.notEqual(at, -1, "v4l2m2m was given the default buffer count");
+  assert.ok(Number(args[at + 1]) > 4);
+});
+
+test("a kind that does not say how to build its arguments refuses rather than producing none", () => {
+  class Unstated extends Encoder {}
+  const encoder = new Unstated({ name: "h264_unstated", kind: "nvenc" });
+  assert.throws(() => encoder.buildVideoArgs(BASE), /does not say how/);
+});

package/test/encoder-readings.test.js

@@ -1,46 +1,46 @@
-/**
- * @file What two readings of a running encoder say about its speed.
- *
- * The case this exists for is a COPY. ffmpeg's own cumulative `speed=` counts
- * the seconds the look-ahead cap keeps the encoder stopped, and a copy is
- * stopped for most of its life — reaching the cap in about fifteen seconds and
- * then waiting a minute. Read cumulatively, a copy running at 8x reports 1.6x,
- * which filed as the price of copying would refuse rungs on a measurement of a
- * pause.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { speedFromReadings } from "../services/encode/encoder-readings.js";
-
-const at = (seconds, processedSeconds) => ({ takenAt: seconds * 1000, processedSeconds });
-
-test("a copy producing eight seconds of video per second reads as eight", () => {
-  assert.equal(speedFromReadings(at(10, 100), at(15, 140), 3), 8);
-});
-
-test("a stretch too short to divide by says nothing", () => {
-  assert.equal(speedFromReadings(at(10, 100), at(11, 108), 3), null);
-});
-
-test("a run that produced nothing between the readings says nothing", () => {
-  // What a repositioned run looks like before it reaches its new start.
-  assert.equal(speedFromReadings(at(10, 100), at(20, 100), 3), null);
-});
-
-test("a run that went BACKWARDS says nothing rather than a negative speed", () => {
-  assert.equal(speedFromReadings(at(10, 200), at(20, 100), 3), null);
-});
-
-test("a missing reading is not an answer", () => {
-  assert.equal(speedFromReadings(null, at(20, 100), 3), null);
-  assert.equal(speedFromReadings(at(10, 100), null, 3), null);
-});
-
-test("the pair is judged on wall clock, so a pause between them is the caller's problem", () => {
-  // Deliberate: this function cannot see a pause. The session drops its
-  // previous reading whenever the encoder is stopped or restarted, which is
-  // what makes every surviving pair an uninterrupted stretch.
-  assert.equal(speedFromReadings(at(0, 0), at(60, 60), 3), 1);
-});
+/**
+ * @file What two readings of a running encoder say about its speed.
+ *
+ * The case this exists for is a COPY. ffmpeg's own cumulative `speed=` counts
+ * the seconds the look-ahead cap keeps the encoder stopped, and a copy is
+ * stopped for most of its life — reaching the cap in about fifteen seconds and
+ * then waiting a minute. Read cumulatively, a copy running at 8x reports 1.6x,
+ * which filed as the price of copying would refuse rungs on a measurement of a
+ * pause.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { speedFromReadings } from "../services/encode/encoder-readings.js";
+
+const at = (seconds, processedSeconds) => ({ takenAt: seconds * 1000, processedSeconds });
+
+test("a copy producing eight seconds of video per second reads as eight", () => {
+  assert.equal(speedFromReadings(at(10, 100), at(15, 140), 3), 8);
+});
+
+test("a stretch too short to divide by says nothing", () => {
+  assert.equal(speedFromReadings(at(10, 100), at(11, 108), 3), null);
+});
+
+test("a run that produced nothing between the readings says nothing", () => {
+  // What a repositioned run looks like before it reaches its new start.
+  assert.equal(speedFromReadings(at(10, 100), at(20, 100), 3), null);
+});
+
+test("a run that went BACKWARDS says nothing rather than a negative speed", () => {
+  assert.equal(speedFromReadings(at(10, 200), at(20, 100), 3), null);
+});
+
+test("a missing reading is not an answer", () => {
+  assert.equal(speedFromReadings(null, at(20, 100), 3), null);
+  assert.equal(speedFromReadings(at(10, 100), null, 3), null);
+});
+
+test("the pair is judged on wall clock, so a pause between them is the caller's problem", () => {
+  // Deliberate: this function cannot see a pause. The session drops its
+  // previous reading whenever the encoder is stopped or restarted, which is
+  // what makes every surviving pair an uninterrupted stretch.
+  assert.equal(speedFromReadings(at(0, 0), at(60, 60), 3), 1);
+});

package/test/every-claimant-is-told-its-share.test.js

@@ -1,152 +1,152 @@
-/**
- * @file Everything that holds bytes is told how many it may hold.
- *
- * Measured 2026-09-14, by reading every file outside the storage layer that
- * touches the filesystem: three claimants had no share at all, and one held a
- * ceiling over bytes it did not own.
- *
- * - whole files: NO BOUND OF ANY KIND. A 2.8 GB film kept whole on a host whose
- *   disk is often a 32 GB card;
- * - diagnostics: bounded by a COUNT and never by a size. Two core dumps and
- *   five heap snapshots came to 3.2 GB on the addon host, and one wedge was
- *   captured thirteen times in six hours;
- * - the torrent pool's "disk cap" of 10 GB: a sum over WebTorrent's downloaded
- *   bitfield, so a piece held purely in MEMORY told against a ceiling called
- *   disk, while the bytes it meant to bound belong to the spill and to the
- *   whole files, which have owners of their own. It owned nothing and is gone.
- */
-
-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 { CompletedFiles } from "../services/storage/files/CompletedFiles.js";
-import { Diagnostics } from "../services/storage/Diagnostics.js";
-
-const KILOBYTE = 1024;
-
-/**
- * @param {number} length
- * @returns {() => AsyncGenerator<Buffer>}
- */
-function bytesOf(length) {
-  return async function* source() {
-    yield Buffer.alloc(length, 7);
-  };
-}
-
-/**
- * @returns {Promise<{ files: CompletedFiles, root: string }>}
- */
-async function filesInATempRoot() {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "whole-files-"));
-  return { files: new CompletedFiles({ root }), root };
-}
-
-test("a whole file is kept only while there is room for it", async () => {
-  const { files, root } = await filesInATempRoot();
-  try {
-    files.allow(4 * KILOBYTE);
-    const kept = await files.keep({
-      infoHash: "a".repeat(40), fileIndex: 0, length: 3 * KILOBYTE, name: "one.mkv", open: bytesOf(3 * KILOBYTE)
-    });
-    assert.ok(kept, "it fits, so it is kept");
-
-    const refused = await files.keep({
-      infoHash: "b".repeat(40), fileIndex: 0, length: 3 * KILOBYTE, name: "two.mkv", open: bytesOf(3 * KILOBYTE)
-    });
-    assert.equal(refused, null, "it does not fit, so it is not assembled at all");
-    assert.equal(files.size, 1, "and nothing already held was taken to make room during a write");
-  } finally {
-    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});
-
-test("over its share, the whole file nobody has read for longest goes", async () => {
-  const { files, root } = await filesInATempRoot();
-  try {
-    files.allow(Number.MAX_SAFE_INTEGER);
-    for (const [index, hash] of [["0", "a"], ["1", "b"], ["2", "c"]]) {
-      await files.keep({
-        infoHash: hash.repeat(40), fileIndex: Number(index), length: KILOBYTE, name: `${index}.mkv`, open: bytesOf(KILOBYTE)
-      });
-    }
-    // The first two are asked for; the third is not, so it is the one nobody
-    // wants. Losing it is not losing data — the torrent can fetch it again, and
-    // until it does the read falls back to the pieces.
-    files.find("a".repeat(40), 0);
-    files.find("b".repeat(40), 1);
-
-    const after = await files.allow(2 * KILOBYTE);
-
-    assert.equal(after.removed, 1);
-    assert.ok(files.find("a".repeat(40), 0), "a file just read was taken");
-    assert.ok(files.find("b".repeat(40), 1), "a file just read was taken");
-    assert.equal(files.find("c".repeat(40), 2), null, "the longest-unread should have gone");
-  } finally {
-    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});
-
-test("told nothing, whole files keep what they have — a share is not assumed", async () => {
-  const { files, root } = await filesInATempRoot();
-  try {
-    const kept = await files.keep({
-      infoHash: "a".repeat(40), fileIndex: 0, length: KILOBYTE, name: "one.mkv", open: bytesOf(KILOBYTE)
-    });
-    assert.ok(kept, "before the owner has divided anything there is nothing to refuse against");
-  } finally {
-    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});
-
-test("over its share the evidence stops being collected, and nothing recorded is deleted", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "diagnostics-"));
-  try {
-    await fs.writeFile(path.join(root, "core.MainThread.1.2"), Buffer.alloc(4 * KILOBYTE));
-    await fs.writeFile(path.join(root, "heap-x-1-2.heapsnapshot"), Buffer.alloc(2 * KILOBYTE));
-    // Not evidence: the proxy's own state lives in the same directory.
-    await fs.writeFile(path.join(root, "host-timings.json"), Buffer.alloc(KILOBYTE));
-
-    const said = [];
-    const diagnostics = new Diagnostics({
-      logger: { info: () => {}, warn: (line) => said.push(line) },
-      kinds: [
-        { name: "core dumps", directory: () => root, matches: (name) => name.startsWith("core.") },
-        { name: "heap snapshots", directory: () => root, matches: (name) => name.endsWith(".heapsnapshot") }
-      ]
-    });
-
-    assert.equal(await diagnostics.measure(), 6 * KILOBYTE, "the proxy's own state is not evidence");
-    assert.equal(
-      diagnostics.wanted(),
-      10 * KILOBYTE,
-      "what it holds plus one more of the largest kind seen — measured, not a fraction"
-    );
-
-    diagnostics.allow(7 * KILOBYTE);
-    assert.equal(diagnostics.mayKeep({ what: "a heap snapshot", bytes: KILOBYTE }), true, "there is room for a small one");
-    assert.equal(diagnostics.mayKeep({ what: "a heap snapshot", bytes: 4 * KILOBYTE }), false, "there is not for a large one");
-
-    assert.equal(said.length, 1, "a refusal is a line, never a silence");
-    assert.match(said[0], /was NOT kept/);
-    const left = (await fs.readdir(root)).sort();
-    assert.deepEqual(
-      left,
-      ["core.MainThread.1.2", "heap-x-1-2.heapsnapshot", "host-timings.json"],
-      "nothing already recorded may be removed to make room for more"
-    );
-  } finally {
-    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});
-
-test("before the owner has divided anything, the evidence is not refused", async () => {
-  const diagnostics = new Diagnostics({ kinds: [], logger: { info: () => {}, warn: () => {} } });
-  assert.equal(
-    diagnostics.mayKeep({ what: "a core dump", bytes: Number.MAX_SAFE_INTEGER }),
-    true,
-    "null is what a claimant that has not been told looks like, and it does not license growth by itself"
-  );
-});
+/**
+ * @file Everything that holds bytes is told how many it may hold.
+ *
+ * Measured 2026-09-14, by reading every file outside the storage layer that
+ * touches the filesystem: three claimants had no share at all, and one held a
+ * ceiling over bytes it did not own.
+ *
+ * - whole files: NO BOUND OF ANY KIND. A 2.8 GB film kept whole on a host whose
+ *   disk is often a 32 GB card;
+ * - diagnostics: bounded by a COUNT and never by a size. Two core dumps and
+ *   five heap snapshots came to 3.2 GB on the addon host, and one wedge was
+ *   captured thirteen times in six hours;
+ * - the torrent pool's "disk cap" of 10 GB: a sum over WebTorrent's downloaded
+ *   bitfield, so a piece held purely in MEMORY told against a ceiling called
+ *   disk, while the bytes it meant to bound belong to the spill and to the
+ *   whole files, which have owners of their own. It owned nothing and is gone.
+ */
+
+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 { CompletedFiles } from "../services/storage/files/CompletedFiles.js";
+import { Diagnostics } from "../services/storage/Diagnostics.js";
+
+const KILOBYTE = 1024;
+
+/**
+ * @param {number} length
+ * @returns {() => AsyncGenerator<Buffer>}
+ */
+function bytesOf(length) {
+  return async function* source() {
+    yield Buffer.alloc(length, 7);
+  };
+}
+
+/**
+ * @returns {Promise<{ files: CompletedFiles, root: string }>}
+ */
+async function filesInATempRoot() {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "whole-files-"));
+  return { files: new CompletedFiles({ root }), root };
+}
+
+test("a whole file is kept only while there is room for it", async () => {
+  const { files, root } = await filesInATempRoot();
+  try {
+    files.allow(4 * KILOBYTE);
+    const kept = await files.keep({
+      infoHash: "a".repeat(40), fileIndex: 0, length: 3 * KILOBYTE, name: "one.mkv", open: bytesOf(3 * KILOBYTE)
+    });
+    assert.ok(kept, "it fits, so it is kept");
+
+    const refused = await files.keep({
+      infoHash: "b".repeat(40), fileIndex: 0, length: 3 * KILOBYTE, name: "two.mkv", open: bytesOf(3 * KILOBYTE)
+    });
+    assert.equal(refused, null, "it does not fit, so it is not assembled at all");
+    assert.equal(files.size, 1, "and nothing already held was taken to make room during a write");
+  } finally {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("over its share, the whole file nobody has read for longest goes", async () => {
+  const { files, root } = await filesInATempRoot();
+  try {
+    files.allow(Number.MAX_SAFE_INTEGER);
+    for (const [index, hash] of [["0", "a"], ["1", "b"], ["2", "c"]]) {
+      await files.keep({
+        infoHash: hash.repeat(40), fileIndex: Number(index), length: KILOBYTE, name: `${index}.mkv`, open: bytesOf(KILOBYTE)
+      });
+    }
+    // The first two are asked for; the third is not, so it is the one nobody
+    // wants. Losing it is not losing data — the torrent can fetch it again, and
+    // until it does the read falls back to the pieces.
+    files.find("a".repeat(40), 0);
+    files.find("b".repeat(40), 1);
+
+    const after = await files.allow(2 * KILOBYTE);
+
+    assert.equal(after.removed, 1);
+    assert.ok(files.find("a".repeat(40), 0), "a file just read was taken");
+    assert.ok(files.find("b".repeat(40), 1), "a file just read was taken");
+    assert.equal(files.find("c".repeat(40), 2), null, "the longest-unread should have gone");
+  } finally {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("told nothing, whole files keep what they have — a share is not assumed", async () => {
+  const { files, root } = await filesInATempRoot();
+  try {
+    const kept = await files.keep({
+      infoHash: "a".repeat(40), fileIndex: 0, length: KILOBYTE, name: "one.mkv", open: bytesOf(KILOBYTE)
+    });
+    assert.ok(kept, "before the owner has divided anything there is nothing to refuse against");
+  } finally {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("over its share the evidence stops being collected, and nothing recorded is deleted", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "diagnostics-"));
+  try {
+    await fs.writeFile(path.join(root, "core.MainThread.1.2"), Buffer.alloc(4 * KILOBYTE));
+    await fs.writeFile(path.join(root, "heap-x-1-2.heapsnapshot"), Buffer.alloc(2 * KILOBYTE));
+    // Not evidence: the proxy's own state lives in the same directory.
+    await fs.writeFile(path.join(root, "host-timings.json"), Buffer.alloc(KILOBYTE));
+
+    const said = [];
+    const diagnostics = new Diagnostics({
+      logger: { info: () => {}, warn: (line) => said.push(line) },
+      kinds: [
+        { name: "core dumps", directory: () => root, matches: (name) => name.startsWith("core.") },
+        { name: "heap snapshots", directory: () => root, matches: (name) => name.endsWith(".heapsnapshot") }
+      ]
+    });
+
+    assert.equal(await diagnostics.measure(), 6 * KILOBYTE, "the proxy's own state is not evidence");
+    assert.equal(
+      diagnostics.wanted(),
+      10 * KILOBYTE,
+      "what it holds plus one more of the largest kind seen — measured, not a fraction"
+    );
+
+    diagnostics.allow(7 * KILOBYTE);
+    assert.equal(diagnostics.mayKeep({ what: "a heap snapshot", bytes: KILOBYTE }), true, "there is room for a small one");
+    assert.equal(diagnostics.mayKeep({ what: "a heap snapshot", bytes: 4 * KILOBYTE }), false, "there is not for a large one");
+
+    assert.equal(said.length, 1, "a refusal is a line, never a silence");
+    assert.match(said[0], /was NOT kept/);
+    const left = (await fs.readdir(root)).sort();
+    assert.deepEqual(
+      left,
+      ["core.MainThread.1.2", "heap-x-1-2.heapsnapshot", "host-timings.json"],
+      "nothing already recorded may be removed to make room for more"
+    );
+  } finally {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("before the owner has divided anything, the evidence is not refused", async () => {
+  const diagnostics = new Diagnostics({ kinds: [], logger: { info: () => {}, warn: () => {} } });
+  assert.equal(
+    diagnostics.mayKeep({ what: "a core dump", bytes: Number.MAX_SAFE_INTEGER }),
+    true,
+    "null is what a claimant that has not been told looks like, and it does not license growth by itself"
+  );
+});