@torrent-tv/proxy 2.89.7 → 2.89.9

package/test/episode-naming.test.js

@@ -1,131 +1,131 @@
-/**
- * @file What a picture's name says about which episode it is, and what a whole
- * torrent's pictures are taken together.
- *
- * Every name below is taken from a release in the survey collection, except
- * where a test says it is built to reach an edge.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readEpisodeMarker } from "../services/torrent/episode-naming.js";
-import { TorrentContents } from "../services/torrent/Contents.js";
-
-test("season and episode with the episode title after them", () => {
-  assert.deepEqual(readEpisodeMarker({ name: "s01e02_Murder.in.the.Mews.avi", folders: ["Season_01"] }), {
-    season: 1,
-    episodes: [2],
-    part: null,
-    special: false,
-    showHint: "",
-    titleHint: "Murder.in.the.Mews"
-  });
-});
-
-test("a separator between the season and the episode is still one marker", () => {
-  const marker = readEpisodeMarker({ name: "s03.e01_The.Mysterious.Affair.at.Styles.avi" });
-  assert.equal(marker.season, 3);
-  assert.deepEqual(marker.episodes, [1]);
-  assert.equal(marker.titleHint, "The.Mysterious.Affair.at.Styles");
-});
-
-test("a part of one episode is its own field and leaves the title", () => {
-  const marker = readEpisodeMarker({ name: "s02e01_Peril.at.End.House_Part.1.avi" });
-  assert.equal(marker.part, 1);
-  assert.equal(marker.titleHint, "Peril.at.End.House");
-  assert.deepEqual(marker.episodes, [1]);
-});
-
-test("the show name comes before the marker and release tags after it", () => {
-  const marker = readEpisodeMarker({ name: "Reacher.S04E01.1080p.rus.LostFilm.TV.mkv" });
-  assert.equal(marker.season, 4);
-  assert.equal(marker.showHint, "Reacher");
-  assert.equal(marker.titleHint, "1080p.rus.LostFilm.TV");
-});
-
-test("one file carrying several episodes lists all of them", () => {
-  assert.deepEqual(readEpisodeMarker({ name: "Show.S01E01E02.mkv" }).episodes, [1, 2]);
-  assert.deepEqual(readEpisodeMarker({ name: "Show.S01E01-E03.mkv" }).episodes, [1, 2, 3]);
-  assert.deepEqual(readEpisodeMarker({ name: "Show.S01E01-02.mkv" }).episodes, [1, 2]);
-});
-
-test("a claim of more episodes than a file carries is not a marker", () => {
-  assert.equal(readEpisodeMarker({ name: "Show.S01E01-40.mkv" }), null);
-});
-
-test("season 0 and a name calling itself a special are specials", () => {
-  assert.equal(readEpisodeMarker({ name: "Show.S00E03.mkv" }).special, true);
-  assert.equal(readEpisodeMarker({ name: "Show - 05 Special.mkv" }).special, true);
-  assert.equal(readEpisodeMarker({ name: "Show.S01E03.mkv" }).special, false);
-});
-
-test("the numbering anime releases use, with no season in it", () => {
-  const marker = readEpisodeMarker({ name: "[HorribleSubs] Drifters - 01 [1080p].mkv" });
-  assert.equal(marker.season, null);
-  assert.deepEqual(marker.episodes, [1]);
-  assert.equal(marker.showHint, "[HorribleSubs] Drifters");
-});
-
-test("a season stated just before the dash number is read", () => {
-  const marker = readEpisodeMarker({ name: "Koukaku Kidoutai (2026) S1 - 01.mkv" });
-  assert.equal(marker.season, 1);
-  assert.equal(marker.showHint, "Koukaku Kidoutai (2026)");
-});
-
-test("a season folder gives the season to an episode number without one", () => {
-  const marker = readEpisodeMarker({ name: "Episode.05.mkv", folders: ["Сезон 2"] });
-  assert.equal(marker.season, 2);
-  assert.deepEqual(marker.episodes, [5]);
-});
-
-test("names that state no episode say nothing", () => {
-  for (const name of [
-    "Despicable.Me.4.2024.1080p.BluRay.x264-EniaHD.mkv",
-    "Movie - 2024 [1080p].mkv",
-    "WALL-E.2008.1080p.mkv",
-    "Mortal.Kombat.II.1080p.rus.LostFilm.TV.mkv",
-    "Video.1920x1080.mkv",
-    "VTS_01_1.VOB"
-  ]) {
-    assert.equal(readEpisodeMarker({ name }), null, name);
-  }
-});
-
-/**
- * @param {string} name
- * @param {string[]} relatives
- * @returns {TorrentContents}
- */
-function contents(name, relatives) {
-  return new TorrentContents({
-    name,
-    files: relatives.map((relative) => ({
-      path: `${name}/${relative}`,
-      name: relative.slice(relative.lastIndexOf("/") + 1),
-      length: 1
-    }))
-  });
-}
-
-test("one picture is a single work", () => {
-  assert.equal(new TorrentContents({ name: "Film.mkv", files: [{ path: "Film.mkv", name: "Film.mkv", length: 1 }] }).shape, "single");
-});
-
-test("numbered pictures of one show are a series, and an unnumbered one stays in it", () => {
-  const pack = contents("Poirot", ["Season_01/s01e01_A.avi", "Season_01/s01e02_B.avi", "Special.avi"]);
-  assert.equal(pack.shape, "series");
-  assert.equal(pack.items.find((item) => item.name === "Special.avi").episode, null);
-});
-
-test("pictures without numbers are not called a collection, only not known", () => {
-  assert.equal(contents("Trilogy", ["One.2010.mkv", "Two.2013.mkv", "Three.2017.mkv"]).shape, "undetermined");
-  assert.equal(contents("Film", ["Film.mkv", "Film.S01E01.mkv"]).shape, "undetermined");
-});
-
-test("two differently named shows are not one series", () => {
-  assert.equal(contents("Mixed", ["Alpha.S01E01.mkv", "Beta.S01E01.mkv"]).shape, "undetermined");
-  assert.equal(
-    contents("Drifters", ["[HorribleSubs] Drifters - 01 [1080p].mkv", "[Other] Drifters - 02 [720p].mkv"]).shape,
-    "series"
-  );
-});
+/**
+ * @file What a picture's name says about which episode it is, and what a whole
+ * torrent's pictures are taken together.
+ *
+ * Every name below is taken from a release in the survey collection, except
+ * where a test says it is built to reach an edge.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readEpisodeMarker } from "../services/torrent/episode-naming.js";
+import { TorrentContents } from "../services/torrent/Contents.js";
+
+test("season and episode with the episode title after them", () => {
+  assert.deepEqual(readEpisodeMarker({ name: "s01e02_Murder.in.the.Mews.avi", folders: ["Season_01"] }), {
+    season: 1,
+    episodes: [2],
+    part: null,
+    special: false,
+    showHint: "",
+    titleHint: "Murder.in.the.Mews"
+  });
+});
+
+test("a separator between the season and the episode is still one marker", () => {
+  const marker = readEpisodeMarker({ name: "s03.e01_The.Mysterious.Affair.at.Styles.avi" });
+  assert.equal(marker.season, 3);
+  assert.deepEqual(marker.episodes, [1]);
+  assert.equal(marker.titleHint, "The.Mysterious.Affair.at.Styles");
+});
+
+test("a part of one episode is its own field and leaves the title", () => {
+  const marker = readEpisodeMarker({ name: "s02e01_Peril.at.End.House_Part.1.avi" });
+  assert.equal(marker.part, 1);
+  assert.equal(marker.titleHint, "Peril.at.End.House");
+  assert.deepEqual(marker.episodes, [1]);
+});
+
+test("the show name comes before the marker and release tags after it", () => {
+  const marker = readEpisodeMarker({ name: "Reacher.S04E01.1080p.rus.LostFilm.TV.mkv" });
+  assert.equal(marker.season, 4);
+  assert.equal(marker.showHint, "Reacher");
+  assert.equal(marker.titleHint, "1080p.rus.LostFilm.TV");
+});
+
+test("one file carrying several episodes lists all of them", () => {
+  assert.deepEqual(readEpisodeMarker({ name: "Show.S01E01E02.mkv" }).episodes, [1, 2]);
+  assert.deepEqual(readEpisodeMarker({ name: "Show.S01E01-E03.mkv" }).episodes, [1, 2, 3]);
+  assert.deepEqual(readEpisodeMarker({ name: "Show.S01E01-02.mkv" }).episodes, [1, 2]);
+});
+
+test("a claim of more episodes than a file carries is not a marker", () => {
+  assert.equal(readEpisodeMarker({ name: "Show.S01E01-40.mkv" }), null);
+});
+
+test("season 0 and a name calling itself a special are specials", () => {
+  assert.equal(readEpisodeMarker({ name: "Show.S00E03.mkv" }).special, true);
+  assert.equal(readEpisodeMarker({ name: "Show - 05 Special.mkv" }).special, true);
+  assert.equal(readEpisodeMarker({ name: "Show.S01E03.mkv" }).special, false);
+});
+
+test("the numbering anime releases use, with no season in it", () => {
+  const marker = readEpisodeMarker({ name: "[HorribleSubs] Drifters - 01 [1080p].mkv" });
+  assert.equal(marker.season, null);
+  assert.deepEqual(marker.episodes, [1]);
+  assert.equal(marker.showHint, "[HorribleSubs] Drifters");
+});
+
+test("a season stated just before the dash number is read", () => {
+  const marker = readEpisodeMarker({ name: "Koukaku Kidoutai (2026) S1 - 01.mkv" });
+  assert.equal(marker.season, 1);
+  assert.equal(marker.showHint, "Koukaku Kidoutai (2026)");
+});
+
+test("a season folder gives the season to an episode number without one", () => {
+  const marker = readEpisodeMarker({ name: "Episode.05.mkv", folders: ["Сезон 2"] });
+  assert.equal(marker.season, 2);
+  assert.deepEqual(marker.episodes, [5]);
+});
+
+test("names that state no episode say nothing", () => {
+  for (const name of [
+    "Despicable.Me.4.2024.1080p.BluRay.x264-EniaHD.mkv",
+    "Movie - 2024 [1080p].mkv",
+    "WALL-E.2008.1080p.mkv",
+    "Mortal.Kombat.II.1080p.rus.LostFilm.TV.mkv",
+    "Video.1920x1080.mkv",
+    "VTS_01_1.VOB"
+  ]) {
+    assert.equal(readEpisodeMarker({ name }), null, name);
+  }
+});
+
+/**
+ * @param {string} name
+ * @param {string[]} relatives
+ * @returns {TorrentContents}
+ */
+function contents(name, relatives) {
+  return new TorrentContents({
+    name,
+    files: relatives.map((relative) => ({
+      path: `${name}/${relative}`,
+      name: relative.slice(relative.lastIndexOf("/") + 1),
+      length: 1
+    }))
+  });
+}
+
+test("one picture is a single work", () => {
+  assert.equal(new TorrentContents({ name: "Film.mkv", files: [{ path: "Film.mkv", name: "Film.mkv", length: 1 }] }).shape, "single");
+});
+
+test("numbered pictures of one show are a series, and an unnumbered one stays in it", () => {
+  const pack = contents("Poirot", ["Season_01/s01e01_A.avi", "Season_01/s01e02_B.avi", "Special.avi"]);
+  assert.equal(pack.shape, "series");
+  assert.equal(pack.items.find((item) => item.name === "Special.avi").episode, null);
+});
+
+test("pictures without numbers are not called a collection, only not known", () => {
+  assert.equal(contents("Trilogy", ["One.2010.mkv", "Two.2013.mkv", "Three.2017.mkv"]).shape, "undetermined");
+  assert.equal(contents("Film", ["Film.mkv", "Film.S01E01.mkv"]).shape, "undetermined");
+});
+
+test("two differently named shows are not one series", () => {
+  assert.equal(contents("Mixed", ["Alpha.S01E01.mkv", "Beta.S01E01.mkv"]).shape, "undetermined");
+  assert.equal(
+    contents("Drifters", ["[HorribleSubs] Drifters - 01 [1080p].mkv", "[Other] Drifters - 02 [720p].mkv"]).shape,
+    "series"
+  );
+});

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"
+  );
+});