@torrent-tv/proxy 2.89.17 → 2.89.18

package/test/matroska-cues-track.test.js

@@ -1,192 +0,0 @@
-/**
- * @file The container's table names a track, and only the picture's entries are
- * cut points.
- *
- * Measured 2026-08-18 on the two files the field sessions were recorded from:
- * `Minions.and.Monsters.1080p.mkv` carries 2778 cue entries for its video track
- * — one every 2.002 s — and 4669 more across four subtitle tracks;
- * `Moana.2 … MegaPeer.mkv` carries 1055 for video and 5007 across five subtitle
- * tracks. Read without the track, both sets went into the cut list together,
- * and ffmpeg — which can only cut a copied picture at a real keyframe at or
- * after the time it is asked for — moved every such cut forward to the next
- * keyframe. That is the whole of the disagreement the field reported: 2.002 s
- * on the first file, a median of 6.3 s and a worst case of 21 s on the second,
- * and never once negative.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { MatroskaContainer } from "../services/media/container/MatroskaContainer.js";
-
-const ID_EBML = 0x1a45dfa3;
-const ID_SEGMENT = 0x18538067;
-const ID_SEEK_HEAD = 0x114d9b74;
-const ID_SEEK = 0x4dbb;
-const ID_SEEK_ID = 0x53ab;
-const ID_SEEK_POSITION = 0x53ac;
-const ID_INFO = 0x1549a966;
-const ID_TIMESTAMP_SCALE = 0x2ad7b1;
-const ID_TRACKS = 0x1654ae6b;
-const ID_TRACK_ENTRY = 0xae;
-const ID_TRACK_NUMBER = 0xd7;
-const ID_TRACK_TYPE = 0x83;
-const ID_CUES = 0x1c53bb6b;
-const ID_CUE_POINT = 0xbb;
-const ID_CUE_TIME = 0xb3;
-const ID_CUE_TRACK_POSITIONS = 0xb7;
-const ID_CUE_TRACK = 0xf7;
-const ID_CUE_CLUSTER_POSITION = 0xf1;
-
-/** An element id, as the bytes the specification gives it. */
-function idBytes(id) {
-  const bytes = [];
-  let rest = id;
-  while (rest > 0) {
-    bytes.unshift(rest & 0xff);
-    rest = Math.floor(rest / 256);
-  }
-  return Buffer.from(bytes);
-}
-
-/** A size, as a four-byte EBML variable-length integer. */
-function sizeBytes(size) {
-  const buffer = Buffer.alloc(4);
-  buffer.writeUInt32BE(size, 0);
-  buffer[0] |= 0x10;
-  return buffer;
-}
-
-function element(id, payload) {
-  return Buffer.concat([idBytes(id), sizeBytes(payload.length), payload]);
-}
-
-/** An unsigned value, in as few bytes as it needs. */
-function uintElement(id, value) {
-  const bytes = [];
-  let rest = value;
-  do {
-    bytes.unshift(rest & 0xff);
-    rest = Math.floor(rest / 256);
-  } while (rest > 0);
-  return element(id, Buffer.from(bytes));
-}
-
-function cuePoint(timeMs, tracks) {
-  return element(ID_CUE_POINT, Buffer.concat([
-    uintElement(ID_CUE_TIME, timeMs),
-    ...tracks.map((track) => element(ID_CUE_TRACK_POSITIONS, Buffer.concat([
-      uintElement(ID_CUE_TRACK, track),
-      uintElement(ID_CUE_CLUSTER_POSITION, 4096)
-    ])))
-  ]));
-}
-
-/**
- * A file with the shape the field files have: one picture, one set of subtitles,
- * and a table that indexes both.
- *
- * @param {{ withTracks?: boolean }} [options]
- * @returns {Buffer}
- */
-function buildFile({ withTracks = true, cueTrack = null } = {}) {
-  const info = element(ID_INFO, uintElement(ID_TIMESTAMP_SCALE, 1_000_000));
-  const tracks = element(ID_TRACKS, Buffer.concat([
-    element(ID_TRACK_ENTRY, Buffer.concat([
-      uintElement(ID_TRACK_NUMBER, 1),
-      uintElement(ID_TRACK_TYPE, 1) // video
-    ])),
-    element(ID_TRACK_ENTRY, Buffer.concat([
-      uintElement(ID_TRACK_NUMBER, 2),
-      uintElement(ID_TRACK_TYPE, 17) // subtitles
-    ]))
-  ]));
-  const forPicture = cueTrack ?? 1;
-  const forSubtitles = cueTrack ?? 2;
-  const cues = element(ID_CUES, Buffer.concat([
-    cuePoint(0, [forPicture]),
-    cuePoint(1070, [forSubtitles]),
-    cuePoint(2002, [forPicture]),
-    cuePoint(3141, [forSubtitles]),
-    cuePoint(4004, [forPicture])
-  ]));
-
-  const seekEntry = (targetId, position) => element(ID_SEEK, Buffer.concat([
-    element(ID_SEEK_ID, idBytes(targetId)),
-    element(ID_SEEK_POSITION, (() => {
-      const buffer = Buffer.alloc(4);
-      buffer.writeUInt32BE(position, 0);
-      return buffer;
-    })())
-  ]));
-  // Positions are relative to the Segment's payload, so the SeekHead has to be
-  // measured before they can be stated. Its own length does not change when the
-  // placeholders become real values: every size and position here is written at
-  // a fixed width.
-  const draft = element(ID_SEEK_HEAD, Buffer.concat([
-    seekEntry(ID_INFO, 0),
-    ...(withTracks ? [seekEntry(ID_TRACKS, 0)] : []),
-    seekEntry(ID_CUES, 0)
-  ]));
-  const infoAt = draft.length;
-  const tracksAt = infoAt + info.length;
-  const cuesAt = withTracks ? tracksAt + tracks.length : infoAt + info.length;
-  const seekHead = element(ID_SEEK_HEAD, Buffer.concat([
-    seekEntry(ID_INFO, infoAt),
-    ...(withTracks ? [seekEntry(ID_TRACKS, tracksAt)] : []),
-    seekEntry(ID_CUES, cuesAt)
-  ]));
-
-  const segmentPayload = Buffer.concat(
-    withTracks ? [seekHead, info, tracks, cues] : [seekHead, info, cues]
-  );
-  return Buffer.concat([
-    element(ID_EBML, Buffer.from([0x42, 0x86, 0x81, 0x01])),
-    element(ID_SEGMENT, segmentPayload)
-  ]);
-}
-
-function readerOver(file) {
-  return async (start, end) => {
-    const last = Math.min(end, file.length - 1);
-    return start > last ? null : file.subarray(start, last + 1);
-  };
-}
-
-test("only the picture's entries become cut times", async () => {
-  const file = buildFile();
-
-  const times = await MatroskaContainer.readKeyframeTimes(readerOver(file), file.length);
-
-  assert.deepEqual(
-    times.map((time) => Number(time.toFixed(3))),
-    [0, 2.002, 4.004],
-    "the subtitle entries at 1.070 and 3.141 are not keyframes, and a cut asked for there lands late"
-  );
-});
-
-test("a table whose entries name no known track is still used", async () => {
-  // The cue points reference track 9, which Tracks never declares. Filtering
-  // leaves nothing — and returning nothing would put an even grid on a copied
-  // picture, the failure this reader exists to prevent.
-  const file = buildFile({ cueTrack: 9 });
-
-  const times = await MatroskaContainer.readKeyframeTimes(readerOver(file), file.length);
-
-  assert.deepEqual(
-    times.map((time) => Number(time.toFixed(3))),
-    [0, 1.07, 2.002, 3.141, 4.004],
-    "an unrecognised table beats no table at all"
-  );
-});
-
-test("a file whose tracks cannot be read keeps every entry", async () => {
-  const file = buildFile({ withTracks: false });
-
-  const times = await MatroskaContainer.readKeyframeTimes(readerOver(file), file.length);
-
-  assert.deepEqual(
-    times.map((time) => Number(time.toFixed(3))),
-    [0, 1.07, 2.002, 3.141, 4.004],
-    "with nothing to tell the tracks apart, the old behaviour is the only one available"
-  );
-});

package/test/media-time.test.js

@@ -1,62 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  addRange,
-  compare,
-  contiguousEnd,
-  fromSeconds,
-  joins,
-  mediaTime,
-  toSeconds
-} from "../services/viewer/media-time.js";
-
-const at16k = (ticks) => mediaTime(BigInt(ticks), 16000n);
-
-test("a number of seconds is converted to the exact fraction it denotes", () => {
-  assert.deepEqual(fromSeconds(0.5), { ticks: 1n, timescale: 2n });
-  assert.deepEqual(fromSeconds(-0.25), { ticks: -1n, timescale: 4n });
-  assert.equal(toSeconds(fromSeconds(88.67299999999999)), 88.67299999999999);
-  // The double nearest 88.673 is not 88.673, and the comparison says so.
-  assert.notEqual(compare(fromSeconds(88.673), at16k(1418768)), 0);
-  assert.equal(compare(fromSeconds(88.67299999999999), fromSeconds(88.673)), -1);
-});
-
-test("equal ticks join whatever their seconds look like", () => {
-  const ranges = [];
-  addRange(ranges, { start: at16k(0), end: at16k(1418768), frame: at16k(0) });
-  addRange(ranges, { start: at16k(1418768), end: at16k(1482768), frame: at16k(0) });
-  assert.equal(ranges.length, 1);
-  assert.equal(compare(contiguousEnd(ranges, at16k(0)), at16k(1482768)), 0);
-});
-
-test("Gecko's bound: a gap joins when twice the gap is within both frames", () => {
-  assert.equal(joins(at16k(672), at16k(672), at16k(672)), true);
-  assert.equal(joins(at16k(673), at16k(672), at16k(672)), false);
-  // A range whose frames are not known allows nothing of its own.
-  assert.equal(joins(at16k(336), at16k(0), at16k(672)), true);
-  assert.equal(joins(at16k(337), at16k(0), at16k(672)), false);
-});
-
-test("WebKit's bound: no gap wider than 2002/24000 s joins, however long the frames", () => {
-  const frame = mediaTime(24000n, 24000n);
-  assert.equal(joins(mediaTime(2002n, 24000n), frame, frame), true);
-  assert.equal(joins(mediaTime(2003n, 24000n), frame, frame), false);
-});
-
-test("a merged range keeps the larger frame, as Gecko's Interval::Span does", () => {
-  const ranges = [];
-  addRange(ranges, { start: at16k(0), end: at16k(1000), frame: at16k(100) });
-  addRange(ranges, { start: at16k(1000), end: at16k(2000), frame: at16k(900) });
-  addRange(ranges, { start: at16k(2500), end: at16k(3000), frame: at16k(100) });
-  assert.equal(ranges.length, 1);
-  assert.equal(compare(ranges[0].frame, at16k(900)), 0);
-});
-
-test("ranges a browser does not join stay apart, in order", () => {
-  const ranges = [];
-  addRange(ranges, { start: at16k(5000), end: at16k(6000), frame: at16k(10) });
-  addRange(ranges, { start: at16k(0), end: at16k(1000), frame: at16k(10) });
-  assert.deepEqual(ranges.map(({ start }) => start.ticks), [0n, 5000n]);
-  assert.equal(compare(contiguousEnd(ranges, at16k(500)), at16k(1000)), 0);
-  assert.equal(compare(contiguousEnd(ranges, at16k(2000)), at16k(2000)), 0);
-});

package/test/memory-budget.test.js

@@ -1,390 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  describeMemory,
-  readingIsWorthWriting,
-  summariseMappings,
-  watchedFigures
-} from "../services/storage/memory-report.js";
-import {
-  divideAllowance,
-  forgetMachineMemory,
-  machineAllowanceBytes,
-  machineReserveBytes,
-  noteMachineMemory,
-  SharedPieceStore
-} from "../services/storage/piece-store/shared-piece-store.js";
-import { mkdtemp, rm } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-
-const MEGABYTE = 1024 * 1024;
-const GIGABYTE = 1024 * MEGABYTE;
-
-test("the stores are allowed what the machine has, less what others were seen to need", () => {
-  // Not a share of what is free. A share is a number chosen out of nothing, and
-  // the three that were here until 2026-09-02 — a quarter, a 64 MB floor, a
-  // 512 MB ceiling — all came from one observation of one host on 2026-08-03.
-  // `MemAvailable` is what can be taken ON TOP of what is held, so what the
-  // stores already hold is added back to get the ceiling they could reach.
-  assert.equal(
-    machineAllowanceBytes(2 * GIGABYTE, 300 * MEGABYTE, 0),
-    2 * GIGABYTE + 300 * MEGABYTE
-  );
-  assert.equal(
-    machineAllowanceBytes(2 * GIGABYTE, 300 * MEGABYTE, 500 * MEGABYTE),
-    2 * GIGABYTE - 200 * MEGABYTE
-  );
-  assert.equal(
-    machineAllowanceBytes(100 * MEGABYTE, 0, 4 * GIGABYTE),
-    0,
-    "a reserve larger than everything leaves nothing, and says so rather than going negative"
-  );
-});
-
-test("what to leave for everyone else is measured, starts at nothing, and ages out", () => {
-  // Field 2026-09-02: while this proxy held 76-133 MB the machine's available
-  // memory fell from 2378 MB to 306 MB and came back. That fall was somebody
-  // else's, and it is the quantity to leave room for. On a quiet host the same
-  // reading stays near zero, which is the right answer there.
-  forgetMachineMemory();
-  assert.equal(noteMachineMemory(2378 * MEGABYTE, 100 * MEGABYTE), 0, "nothing is reserved on faith");
-
-  // A fall of 2072 MB while the stores grew by 20 MB: 2052 MB of it was theirs.
-  assert.equal(noteMachineMemory(306 * MEGABYTE, 120 * MEGABYTE), 2052 * MEGABYTE);
-
-  // Memory coming back does not lower what has been seen to be needed — the
-  // spike can happen again, and that is what there has to be room for.
-  assert.equal(noteMachineMemory(3567 * MEGABYTE, 120 * MEGABYTE), 2052 * MEGABYTE);
-
-  // But it does not stand for ever either. A window of observations, not a
-  // high-water: one spike hours ago must stop squeezing the stores, which is
-  // the same mistake the block re-use gap would make with an all-time maximum.
-  for (let quiet = 0; quiet < 60; quiet += 1) {
-    noteMachineMemory(3567 * MEGABYTE, 120 * MEGABYTE);
-  }
-  assert.equal(machineReserveBytes(), 0, "an hour of quiet leaves the spike behind");
-});
-
-test("everyone gets what they asked for while the asks fit", () => {
-  // The usual case by a wide margin: two readers of one film declare 32-192 MB
-  // between them against gigabytes of free memory, so the machine's limit never
-  // binds and the demand is what decides.
-  assert.deepEqual(
-    divideAllowance([100 * MEGABYTE, 50 * MEGABYTE], GIGABYTE),
-    [100 * MEGABYTE, 50 * MEGABYTE]
-  );
-
-  // When they do not fit, each is cut in proportion to what it asked, so a
-  // store wanting little is not cut to make room for one wanting much.
-  const cut = divideAllowance([300 * MEGABYTE, 100 * MEGABYTE], 200 * MEGABYTE);
-  assert.equal(cut[0], 150 * MEGABYTE);
-  assert.equal(cut[1], 50 * MEGABYTE);
-  assert.equal(cut[0] + cut[1], 200 * MEGABYTE);
-
-  assert.deepEqual(divideAllowance([], GIGABYTE), []);
-  assert.deepEqual(divideAllowance([0, 0], 0), [0, 0], "nobody asking takes nothing");
-});
-
-test("the memory line says bytes, and names what it could not measure", () => {
-  const usage = {
-    rss: 2422628 * 1024,
-    heapUsed: 180 * MEGABYTE,
-    heapTotal: 220 * MEGABYTE,
-    external: 900 * MEGABYTE,
-    arrayBuffers: 850 * MEGABYTE
-  };
-  const measured = describeMemory({
-    process: usage,
-    availableBytes: 1900 * MEGABYTE,
-    availableMeasured: true,
-    stores: [
-      {
-        name: "a film",
-        residentBytes: 504 * MEGABYTE,
-        committedBytes: 504 * MEGABYTE,
-        spilledBytes: 0,
-        budgetBytes: 512 * MEGABYTE
-      }
-    ]
-  });
-  // The figures the kernel's own kill line quoted, so the two can be compared.
-  assert.match(measured, /rss=2366MB/);
-  assert.match(measured, /1 torrent store\(s\) holding 504MB, committed 504MB of 512MB allowed/);
-  assert.match(measured, /machine has 1900MB available$/);
-
-  const estimated = describeMemory({
-    process: usage,
-    availableBytes: 1900 * MEGABYTE,
-    availableMeasured: false,
-    stores: []
-  });
-  assert.match(estimated, /no torrent stores/);
-  assert.match(estimated, /estimated — \/proc\/meminfo could not be read/);
-});
-
-test("holding and having taken are separate figures, and the line says both", () => {
-  // The shape that hid 650 MB on 2026-08-28: eighteen pieces held, sixty-four
-  // slots taken and never given back, and a line that only mentioned the first.
-  const line = describeMemory({
-    process: { rss: 893 * MEGABYTE, heapUsed: 29 * MEGABYTE, heapTotal: 34 * MEGABYTE, external: 11 * MEGABYTE, arrayBuffers: 7 * MEGABYTE },
-    availableBytes: 2287 * MEGABYTE,
-    availableMeasured: true,
-    anonymousBytes: 870 * MEGABYTE,
-    diskFreeBytes: 12000 * MEGABYTE,
-    stores: [
-      {
-        name: "a film",
-        residentBytes: 144 * MEGABYTE,
-        committedBytes: 512 * MEGABYTE,
-        spilledBytes: 2904 * MEGABYTE,
-        budgetBytes: 512 * MEGABYTE
-      }
-    ]
-  });
-  assert.match(line, /holding 144MB, committed 512MB of 512MB allowed, 2904MB spilled to disk/);
-  assert.match(line, /anon=870MB/);
-  assert.match(line, /12000MB free on disk$/);
-});
-
-test("a thread's reading leaves out what belongs to the process", () => {
-  // `rss` and the kernel's rollup are process-wide and are read once, on the
-  // main thread. What the torrent worker can say — and the only place it can be
-  // said — is its own isolate, where the piece pool actually lives.
-  const line = describeMemory({
-    scope: "thread",
-    label: "torrent worker",
-    process: { rss: 893 * MEGABYTE, heapUsed: 12 * MEGABYTE, heapTotal: 20 * MEGABYTE, external: 530 * MEGABYTE, arrayBuffers: 512 * MEGABYTE },
-    stores: [
-      {
-        name: "a film",
-        residentBytes: 144 * MEGABYTE,
-        committedBytes: 512 * MEGABYTE,
-        spilledBytes: 0,
-        budgetBytes: 512 * MEGABYTE
-      }
-    ]
-  });
-  assert.match(line, /^memory \(torrent worker\): heap=12MB\/20MB/);
-  assert.match(line, /arrayBuffers=512MB/);
-  assert.doesNotMatch(line, /rss=/);
-  assert.doesNotMatch(line, /machine has/);
-});
-
-test("a store's allowance follows the machine, in both directions", async () => {
-  // The defect: a store created on an idle machine kept an idle machine's
-  // allowance for life and went on growing into memory the host no longer had.
-  const directory = await mkdtemp(path.join(os.tmpdir(), "budget-revision-"));
-  const store = new SharedPieceStore(1024, {
-    path: directory,
-    name: "revision",
-    memoryBytes: 64 * 1024
-  });
-  try {
-    const born = store.stats().budgetBytes;
-    assert.ok(born > 0);
-
-    // The machine fills up: the ceiling comes down and growth stops there.
-    const lowered = store.reviseGrowthCeiling(8 * 1024);
-    assert.ok(lowered.ceilingBytes < born, "a busier machine buys fewer slots");
-    assert.equal(store.stats().budgetBytes, lowered.ceilingBytes, "the line says what is allowed now");
-
-    // The machine empties again: the ceiling rises with it, PAST where this
-    // store started. Until 2026-09-02 it could not — the ceiling was capped at
-    // a figure computed once in the constructor, so a torrent opened while the
-    // machine was full kept a small allowance for its whole life however much
-    // memory was freed afterwards.
-    const raised = store.reviseGrowthCeiling(1024 * 1024 * 1024);
-    assert.ok(raised.ceilingBytes > born, "an emptier machine buys more slots than it started with");
-    assert.equal(store.stats().budgetBytes, raised.ceilingBytes);
-  } finally {
-    await new Promise((resolve) => store.destroy(resolve));
-    await rm(directory, { recursive: true, force: true });
-  }
-});
-
-test("the line says how far the heap is from the ceiling it is killed for reaching", () => {
-  // The worker died three times for reaching 2240 MB while its own line said
-  // "heap=30MB" and nothing said what 30 MB was 30 MB of.
-  const line = describeMemory({
-    scope: "thread",
-    label: "torrent worker",
-    process: {
-      rss: 2549 * MEGABYTE,
-      heapUsed: 1800 * MEGABYTE,
-      heapTotal: 1904 * MEGABYTE,
-      external: 40 * MEGABYTE,
-      arrayBuffers: 20 * MEGABYTE,
-      heapLimit: 2240 * MEGABYTE
-    },
-    stores: []
-  });
-  assert.match(line, /heap=1800MB\/1904MB of 2240MB allowed/);
-
-  const withoutLimit = describeMemory({
-    scope: "thread",
-    label: "torrent worker",
-    process: { rss: 0, heapUsed: 12 * MEGABYTE, heapTotal: 20 * MEGABYTE, external: 0, arrayBuffers: 0 },
-    stores: []
-  });
-  assert.match(withoutLimit, /heap=12MB\/20MB external=/, "an unknown ceiling is left out, not printed as zero");
-});
-
-test("a reading is written when it moved, or when the silence has gone on long enough", () => {
-  const changeBytes = 25 * MEGABYTE;
-  const quietMs = 60_000;
-  const still = {
-    watchedBytes: 100 * MEGABYTE,
-    lastWrittenBytes: 100 * MEGABYTE,
-    sinceWrittenMs: 1_000,
-    changeBytes,
-    quietMs
-  };
-
-  assert.equal(readingIsWorthWriting(still), false, "a second of nothing is not worth a line");
-  assert.equal(
-    readingIsWorthWriting({ ...still, sinceWrittenMs: 60_000 }),
-    true,
-    "a quiet minute is still written, so a healthy session reads as it always did"
-  );
-  // The rise that killed the worker: 818 MB to 2203 MB inside one old sample.
-  assert.equal(
-    readingIsWorthWriting({ ...still, watchedBytes: 130 * MEGABYTE }),
-    true,
-    "growth of a quarter of a gigabyte cannot wait for the minute to be up"
-  );
-  assert.equal(
-    readingIsWorthWriting({ ...still, watchedBytes: 70 * MEGABYTE }),
-    true,
-    "memory given back is as interesting as memory taken"
-  );
-  assert.equal(
-    readingIsWorthWriting({ ...still, quietMs: 0 }),
-    true,
-    "no quiet interval means every reading is written, which is the process scope"
-  );
-});
-
-/**
- * The shape of the anonymous memory, not only its size. Three shapes, three
- * different diagnoses of the same number — see `summariseMappings`.
- */
-const SMAPS = [
-  "aaaad4000000-aaaad4c00000 r-xp 00000000 fe:01 1234    /usr/local/bin/node",
-  "Size:              12288 kB",
-  "Rss:               12000 kB",
-  "aaaae0000000-aaaae4000000 rw-p 00000000 00:00 0       [heap]",
-  "Size:              65536 kB",
-  "Rss:               40960 kB",
-  "ffff80000000-ffff80400000 rw-p 00000000 00:00 0 ",
-  "Size:               4096 kB",
-  "Rss:                4096 kB",
-  "ffff81000000-ffff81400000 rw-p 00000000 00:00 0 ",
-  "Size:               4096 kB",
-  "Rss:                4096 kB",
-  "ffff82000000-ffff82100000 rw-p 00000000 00:00 0 ",
-  "Size:               1024 kB",
-  "Rss:                 512 kB",
-  "ffff83000000-ffff84000000 rw-p 00000000 00:00 0 ",
-  "Size:              16384 kB",
-  "Rss:                   0 kB",
-  ""
-].join("\n");
-
-test("the mappings are grouped by the shape that names the cause", () => {
-  const summary = summariseMappings(SMAPS);
-  assert.equal(summary.heapBytes, 40960 * 1024, "the allocator's break-managed arena stands alone");
-  assert.equal(summary.largeCount, 2, "two anonymous mappings of four megabytes");
-  assert.equal(summary.largeBytes, 8192 * 1024);
-  assert.equal(summary.largestBytes, 4096 * 1024);
-  assert.equal(summary.smallCount, 1);
-  assert.equal(summary.smallBytes, 512 * 1024);
-  assert.equal(summary.fileBytes, 12000 * 1024, "the executable is not a leak");
-});
-
-test("a mapping that is reserved but untouched costs nothing and is not counted", () => {
-  // The 16 MB mapping above has Rss 0: address space, not memory. Counting it
-  // would put tens of gigabytes of V8's reservations into the reading.
-  assert.equal(summariseMappings(SMAPS).largeCount, 2);
-});
-
-test("no /proc, or nothing readable, is answered with zeroes rather than a throw", () => {
-  const empty = summariseMappings("");
-  assert.equal(empty.heapBytes, 0);
-  assert.equal(empty.largeCount, 0);
-  assert.deepEqual(summariseMappings(null), empty);
-});
-
-test("the mapping shape is said in the line, and left out when it is not known", () => {
-  const withShape = describeMemory({
-    process: { rss: 900 * MEGABYTE, heapUsed: 27 * MEGABYTE, heapTotal: 30 * MEGABYTE, external: 6 * MEGABYTE, arrayBuffers: 2 * MEGABYTE },
-    availableBytes: 800 * MEGABYTE,
-    availableMeasured: true,
-    anonymousBytes: 870 * MEGABYTE,
-    mappings: summariseMappings(SMAPS),
-    stores: []
-  });
-  assert.match(withShape, /mappings=\[heap 40MB, 2 anon ≥2MB = 8MB \(largest 4MB\), 1 anon <2MB = 1MB, files 12MB\]/);
-
-  const withoutShape = describeMemory({
-    process: { rss: 900 * MEGABYTE, heapUsed: 27 * MEGABYTE, heapTotal: 30 * MEGABYTE, external: 6 * MEGABYTE, arrayBuffers: 2 * MEGABYTE },
-    availableBytes: 800 * MEGABYTE,
-    availableMeasured: true,
-    anonymousBytes: 870 * MEGABYTE,
-    stores: []
-  });
-  assert.ok(!withoutShape.includes("mappings="), "an unread breakdown is absent, not zeroed");
-});
-
-test("a thread's line is earned by any of its three figures, not by the heap alone", () => {
-  // 2026-09-02, the session that ended in two out-of-memory kills: the worker's
-  // heap stood at 33-45 MB for the whole of it while its buffers went from 130
-  // to 950 MB. Watching the heap alone, nothing ever earned a line and every
-  // reading of the quantity that grew came out on the quiet minute.
-  const before = watchedFigures("thread", {
-    rss: 0, heapTotal: 38 * MEGABYTE, external: 14 * MEGABYTE, arrayBuffers: 130 * MEGABYTE
-  });
-  const after = watchedFigures("thread", {
-    rss: 0, heapTotal: 38 * MEGABYTE, external: 14 * MEGABYTE, arrayBuffers: 515 * MEGABYTE
-  });
-  assert.equal(before.heap, after.heap, "the heap is what did NOT move");
-
-  const moved = Object.entries(after).some(([name, bytes]) => readingIsWorthWriting({
-    watchedBytes: bytes,
-    lastWrittenBytes: before[name],
-    sinceWrittenMs: 1_000,
-    changeBytes: 25 * MEGABYTE,
-    quietMs: 60_000
-  }));
-  assert.equal(moved, true, "buffers growing by 385 MB earns a line of its own");
-
-  assert.deepEqual(
-    Object.keys(watchedFigures("process", { rss: 5, heapTotal: 1, external: 2, arrayBuffers: 3 })),
-    ["rss"],
-    "a process is killed for its resident memory and watches that"
-  );
-});
-
-test("figures a caller reads for itself land on the same line as the memory", () => {
-  const line = describeMemory({
-    scope: "thread",
-    label: "torrent worker",
-    process: {
-      rss: 0, heapUsed: 34 * MEGABYTE, heapTotal: 46 * MEGABYTE,
-      external: 54 * MEGABYTE, arrayBuffers: 393 * MEGABYTE, heapLimit: 0
-    },
-    stores: [],
-    extra: "piece buffers 21544 let go, 21482 collected, 62 still alive against 53 the store holds"
-  });
-  assert.match(line, /arrayBuffers=393MB/);
-  assert.match(line, /62 still alive against 53 the store holds$/);
-  assert.doesNotMatch(
-    describeMemory({
-      scope: "thread",
-      process: { rss: 0, heapUsed: 1, heapTotal: 2, external: 3, arrayBuffers: 4, heapLimit: 0 }
-    }),
-    /;\s*$/,
-    "nothing to add leaves no dangling separator"
-  );
-});