@torrent-tv/proxy 2.89.17 → 2.89.19

package/test/fmp4-presentation-clock.test.js

@@ -1,148 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-import { producedThroughSeconds, readPresentationRanges, walkBoxes } from "../services/encode/segment-formats/mp4-boxes.js";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { SegmentStore } from "../services/storage/segment-store/SegmentStore.js";
-import { Viewer } from "../services/viewer/Viewer.js";
-
-function box(type, body) {
-  const header = Buffer.alloc(8);
-  header.writeUInt32BE(body.length + 8);
-  header.write(type, 4);
-  return Buffer.concat([header, body]);
-}
-
-function init(emptyMs, mediaTime, kind = "vide") {
-  const mvhd = Buffer.alloc(24);
-  mvhd.writeUInt32BE(1000, 12);
-  const tkhd = Buffer.alloc(20);
-  tkhd.writeUInt32BE(1, 12);
-  const mdhd = Buffer.alloc(24);
-  mdhd.writeUInt32BE(24000, 12);
-  const hdlr = Buffer.alloc(12);
-  hdlr.write(kind, 8);
-  const elst = Buffer.alloc(32);
-  elst.writeUInt32BE(2, 4);
-  elst.writeUInt32BE(emptyMs, 8);
-  elst.writeInt32BE(-1, 12);
-  elst.writeUInt32BE(1000, 20);
-  elst.writeInt32BE(mediaTime, 24);
-  return box("moov", Buffer.concat([box("mvhd", mvhd), box("trak", Buffer.concat([
-    box("tkhd", tkhd), box("edts", box("elst", elst)),
-    box("mdia", Buffer.concat([box("mdhd", mdhd), box("hdlr", hdlr)]))
-  ]))]));
-}
-
-function fragment(decodeTime, composition) {
-  const tfhd = Buffer.alloc(12);
-  tfhd.writeUIntBE(8, 1, 3);
-  tfhd.writeUInt32BE(1, 4);
-  tfhd.writeUInt32BE(1000, 8);
-  const tfdt = Buffer.alloc(12);
-  tfdt[0] = 1;
-  tfdt.writeBigUInt64BE(BigInt(decodeTime), 4);
-  const trun = Buffer.alloc(12);
-  trun.writeUIntBE(0x800, 1, 3);
-  trun.writeUInt32BE(1, 4);
-  trun.writeUInt32BE(composition, 8);
-  return box("moof", box("traf", Buffer.concat([
-    box("tfhd", tfhd), box("tfdt", tfdt), box("trun", trun)
-  ])));
-}
-
-test("an interrupted frame cannot prove coverage of a full future cut", () => {
-  const ranges = readPresentationRanges(Buffer.concat([init(456000, 0), fragment(0, 0)]));
-  assert.ok(producedThroughSeconds(ranges) > 456);
-  assert.ok(producedThroughSeconds(ranges) < 456.1);
-});
-
-test("a shared init preserves presentation times without adding composition delay twice", () => {
-  const shared = fmp4Format.prepareSharedInit(init(83, 2000));
-  const own = init(4125, 3000);
-  const media = Buffer.concat([fragment(0, 3000), fragment(48000, 3000)]);
-  const raw = Buffer.concat([own, media]);
-  const prepared = fmp4Format.prepareSegmentBytes(media, {
-    startSeconds: 4.125, initBytes: shared, rawBytes: raw
-  });
-  assert.deepEqual(fmp4Format.servedMediaRanges(readPresentationRanges(Buffer.concat([shared, prepared])), { initBytes: null }),
-    fmp4Format.servedMediaRanges(readPresentationRanges(raw), { initBytes: null }));
-  const times = [];
-  walkBoxes(prepared, (type, start) => {
-    if (type === "tfdt") times.push(Number(prepared.readBigUInt64BE(start + 4)));
-  });
-  assert.deepEqual(times, [98000, 146000]);
-});
-
-test("a piece states each range in ticks with the frame duration a browser allows it", () => {
-  const coverage = readPresentationRanges(Buffer.concat([init(0, 0, "vide"), fragment(24000, 0)]));
-  assert.deepEqual(coverage.tracks[0].ranges, [{ start: 24000n, end: 25000n, frame: 1000n }]);
-  assert.equal(coverage.tracks[0].timescale, 24000n);
-});
-
-test("a shared init first read after a seek also supports returning to the beginning", () => {
-  const shared = fmp4Format.prepareSharedInit(init(304083, 2000));
-  const media = fragment(0, 2000);
-  const raw = Buffer.concat([init(83, 2000), media]);
-  const prepared = fmp4Format.prepareSegmentBytes(media, {
-    startSeconds: 0.083, initBytes: shared, rawBytes: raw
-  });
-  assert.deepEqual(fmp4Format.servedMediaRanges(readPresentationRanges(Buffer.concat([shared, prepared])), { initBytes: null }),
-    fmp4Format.servedMediaRanges(readPresentationRanges(raw), { initBytes: null }));
-});
-
-test("HLS fragments use the separate init and the same timeline translation as serving", (t) => {
-  const root = mkdtempSync(path.join(os.tmpdir(), "presentation-ranges-"));
-  const store = new SegmentStore({ root });
-  t.after(() => {
-    store.dropAll("the check is over");
-    rmSync(root, { recursive: true, force: true });
-  });
-  const key = "encoded-video";
-  store.useFormat(key, fmp4Format);
-  const dir = store.directoryFor(key);
-  const media = fragment(0, 2000);
-  writeFileSync(path.join(dir, fmp4Format.segmentFileName(1)), media);
-  assert.equal(store.mediaRangesOf(key, 1, { startSeconds: 4 }), undefined);
-  const header = init(0, 0);
-  writeFileSync(path.join(dir, fmp4Format.initFileName), header);
-  const served = fmp4Format.prepareSegmentBytes(media, { initBytes: header, startSeconds: 4 });
-  assert.deepEqual(store.mediaRangesOf(key, 1, { startSeconds: 4 }),
-    readPresentationRanges(Buffer.concat([header, served])));
-  assert.ok(store.mediaRangesOf(key, 1).tracks[0].ranges[0].start > 4n * 24000n);
-});
-
-test("a decode gap between fragments is two ranges, for video as for audio", () => {
-  // Joining across a gap is the browser's decision, made in the viewer
-  // component; the piece states what it holds.
-  const media = Buffer.concat([fragment(0, 0), fragment(72000, 0)]);
-  for (const kind of ["vide", "soun"]) {
-    const coverage = readPresentationRanges(Buffer.concat([init(0, 0, kind), media]));
-    assert.deepEqual(coverage.tracks[0].ranges.map(({ start, end }) => [start, end]),
-      [[0n, 1000n], [72000n, 73000n]]);
-  }
-});
-
-test("served ranges move every track by the session init's position, in ticks", () => {
-  const audioHeader = init(0, 0, "soun");
-  const audio = readPresentationRanges(Buffer.concat([audioHeader, fragment(96000, 0)]));
-  assert.equal(fmp4Format.servedMediaRanges(audio, { initBytes: audioHeader }).ranges[0].start, 96000n);
-  const shared = fmp4Format.prepareSharedInit(init(83, 2000));
-  const video = readPresentationRanges(Buffer.concat([init(83, 2000), fragment(0, 2000)]));
-  // The piece's own edit puts its first frame at round(83 ms * 24000) = 1992
-  // ticks; the served bytes carry the composition delay the shared init's
-  // edit removes, which is what a page's timestampOffset then takes back.
-  assert.equal(video.tracks[0].ranges[0].start, 1992n);
-  assert.equal(fmp4Format.servedMediaRanges(video, { initBytes: shared }).ranges[0].start, 1992n + 2000n);
-  assert.deepEqual(fmp4Format.servedMediaRanges(video, { initBytes: null }).ranges, video.tracks[0].ranges);
-});
-
-test("a viewer retains only finite per-track player clock offsets", () => {
-  const viewer = new Viewer("clock-reading", 1);
-  viewer.report({ timestampOffsets: { video: -0.083, audio: 0, media: 400 } }, 2);
-  assert.deepEqual(viewer.linkReading().timestampOffsets, { video: -0.083, audio: 0 });
-  viewer.report({ timestampOffsets: { video: Number.POSITIVE_INFINITY } }, 3);
-  assert.deepEqual(viewer.linkReading().timestampOffsets, {});
-});

package/test/fmp4-self-contained.test.js

@@ -1,80 +0,0 @@
-/**
- * Splitting a self-contained fMP4 piece into an init segment and a media
- * segment.
- *
- * The muxer that takes explicit cut times writes every piece whole —
- * `ftyp moov moof mdat … mfra` — but HLS wants one init named by `#EXT-X-MAP`
- * and media segments carrying only fragments. Cutting at the wrong offset does
- * not fail loudly; it produces something that parses as garbage, which is why
- * the boundaries are pinned here rather than trusted.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-
-/**
- * A piece shaped like the muxer's output. Sizes are what matters, not contents.
- *
- * @param {{ withIndex?: boolean }} [options]
- * @returns {{ piece: Buffer, initLength: number, fragmentsLength: number }}
- */
-function makePiece({ withIndex = true } = {}) {
-  const box = (type, bodyLength) => {
-    const buffer = Buffer.alloc(8 + bodyLength);
-    buffer.writeUInt32BE(8 + bodyLength, 0);
-    buffer.write(type, 4, "latin1");
-    buffer.fill(0x5a, 8);
-    return buffer;
-  };
-  const ftyp = box("ftyp", 24);
-  const moov = box("moov", 400);
-  const moof = box("moof", 120);
-  const mdat = box("mdat", 900);
-  const mfra = box("mfra", 40);
-  const parts = withIndex ? [ftyp, moov, moof, mdat, mfra] : [ftyp, moov, moof, mdat];
-  return {
-    piece: Buffer.concat(parts),
-    initLength: ftyp.length + moov.length,
-    fragmentsLength: moof.length + mdat.length
-  };
-}
-
-test("the init is everything before the first fragment", () => {
-  const { piece, initLength } = makePiece();
-  const init = fmp4Format.extractInit(piece);
-  assert.ok(init, "no init found in a piece that has one");
-  assert.equal(init.length, initLength, "init must end exactly where the first fragment begins");
-  assert.equal(init.toString("latin1", 4, 8), "ftyp", "init must start at the file header");
-});
-
-test("the media segment is the fragments alone, index dropped", () => {
-  const { piece, initLength, fragmentsLength } = makePiece();
-  const media = fmp4Format.stripInit(piece);
-  assert.equal(media.toString("latin1", 4, 8), "moof", "a media segment must begin at a fragment");
-  assert.equal(
-    media.length,
-    fragmentsLength,
-    "the trailing random-access index must be dropped: its offsets describe a file that no longer exists"
-  );
-  assert.equal(piece.length, initLength + fragmentsLength + 48, "test fixture sanity");
-});
-
-test("a piece without a trailing index keeps everything to the end", () => {
-  const { piece, fragmentsLength } = makePiece({ withIndex: false });
-  assert.equal(fmp4Format.stripInit(piece).length, fragmentsLength);
-});
-
-test("a segment that is already fragments-only is left alone", () => {
-  const alreadyMedia = fmp4Format.stripInit(makePiece().piece);
-  assert.deepEqual(
-    fmp4Format.stripInit(alreadyMedia),
-    alreadyMedia,
-    "stripping twice must not eat the first fragment"
-  );
-  assert.equal(
-    fmp4Format.extractInit(alreadyMedia),
-    null,
-    "there is no init to lift out of a media segment, and inventing one would corrupt playback"
-  );
-});

package/test/fmp4-timestamps.test.js

@@ -1,140 +0,0 @@
-/**
- * Stamping a segment's position onto its fragments.
- *
- * A segment produced by the explicit-cut muxer holds SEVERAL fragments per
- * track — `frag_keyframe` opens one at every keyframe, while a cut point comes
- * only every few keyframes. Writing the segment's start into each of them made
- * them all claim the same decode time, and the player re-fetched the segment
- * forever. The positions inside a segment must therefore survive.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { stampSegmentStartTime } from "../services/encode/segment-formats/mp4-boxes.js";
-
-/**
- * @param {string} type
- * @param {Buffer} body
- * @returns {Buffer}
- */
-function box(type, body) {
-  const header = Buffer.alloc(8);
-  header.writeUInt32BE(8 + body.length, 0);
-  header.write(type, 4, "latin1");
-  return Buffer.concat([header, body]);
-}
-
-/**
- * One fragment: `moof > traf > (tfhd, tfdt)`, plus the payload it describes.
- *
- * @param {{ trackId: number, decodeTime: number, version?: 0 | 1 }} fragment
- * @returns {Buffer}
- */
-function makeFragment({ trackId, decodeTime, version = 1 }) {
-  const tfhdBody = Buffer.alloc(8);
-  tfhdBody.writeUInt32BE(trackId, 4);
-  const tfdtBody = Buffer.alloc(version === 1 ? 12 : 8);
-  tfdtBody[0] = version;
-  if (version === 1) {
-    tfdtBody.writeBigUInt64BE(BigInt(decodeTime), 4);
-  } else {
-    tfdtBody.writeUInt32BE(decodeTime, 4);
-  }
-  const traf = box("traf", Buffer.concat([box("tfhd", tfhdBody), box("tfdt", tfdtBody)]));
-  return Buffer.concat([box("moof", traf), box("mdat", Buffer.alloc(16, 0x5a))]);
-}
-
-/**
- * Every `tfdt` in order, as `[trackId, decodeTime]`.
- *
- * @param {Buffer} segment
- * @returns {Array<[number, number]>}
- */
-function readDecodeTimes(segment) {
-  const found = [];
-  let offset = 0;
-  let trackId = 0;
-  while (offset + 8 <= segment.length) {
-    const size = segment.readUInt32BE(offset);
-    const type = segment.toString("latin1", offset + 4, offset + 8);
-    if (type === "tfhd") {
-      trackId = segment.readUInt32BE(offset + 12);
-    } else if (type === "tfdt") {
-      const version = segment[offset + 8];
-      found.push([
-        trackId,
-        version === 1 ? Number(segment.readBigUInt64BE(offset + 12)) : segment.readUInt32BE(offset + 12)
-      ]);
-    }
-    // Descend into the containers on the way to `tfdt`; skip anything else
-    // whole, so `mdat` is never walked into.
-    offset += type === "moof" || type === "traf" ? 8 : size;
-  }
-  return found;
-}
-
-test("fragments keep their distance from the start of the segment", () => {
-  // A 6 s segment holding three fragments at 0, 2 and 4 s of its own clock —
-  // the shape measured on the field host.
-  const timescale = 16_000;
-  const segment = Buffer.concat([
-    makeFragment({ trackId: 1, decodeTime: 0 }),
-    makeFragment({ trackId: 1, decodeTime: 2 * timescale }),
-    makeFragment({ trackId: 1, decodeTime: 4 * timescale })
-  ]);
-
-  const stamped = stampSegmentStartTime(segment, 6, new Map([[1, timescale]]));
-
-  assert.deepEqual(
-    readDecodeTimes(stamped).map(([, time]) => time / timescale),
-    [6, 8, 10],
-    "each fragment must land at the segment's start plus its own offset"
-  );
-});
-
-test("each track is shifted by its own base", () => {
-  const videoScale = 16_000;
-  const audioScale = 44_100;
-  // Audio does not start at zero: its frames do not align with the video's.
-  const segment = Buffer.concat([
-    makeFragment({ trackId: 1, decodeTime: 0 }),
-    makeFragment({ trackId: 2, decodeTime: 1024 }),
-    makeFragment({ trackId: 1, decodeTime: 2 * videoScale }),
-    makeFragment({ trackId: 2, decodeTime: 1024 + 2 * audioScale })
-  ]);
-
-  const stamped = stampSegmentStartTime(
-    segment,
-    6,
-    new Map([
-      [1, videoScale],
-      [2, audioScale]
-    ])
-  );
-
-  assert.deepEqual(readDecodeTimes(stamped), [
-    [1, 6 * videoScale],
-    [2, 6 * audioScale],
-    [1, 8 * videoScale],
-    [2, 8 * audioScale]
-  ]);
-});
-
-test("a single fragment is written outright, as before", () => {
-  const stamped = stampSegmentStartTime(
-    makeFragment({ trackId: 1, decodeTime: 1280 }),
-    12,
-    new Map([[1, 16_000]])
-  );
-  assert.deepEqual(readDecodeTimes(stamped), [[1, 12 * 16_000]]);
-});
-
-test("a 32-bit field too small for the position is left alone", () => {
-  const segment = makeFragment({ trackId: 1, decodeTime: 0, version: 0 });
-  const stamped = stampSegmentStartTime(segment, 1_000_000, new Map([[1, 90_000]]));
-  assert.deepEqual(
-    readDecodeTimes(stamped),
-    [[1, 0]],
-    "a wrapped value would send the player somewhere arbitrary; leaving it is the lesser harm"
-  );
-});

package/test/fmp4-track-completeness.test.js

@@ -1,41 +0,0 @@
-/**
- * @file A segment that is short of a track must not be served.
- *
- * A run that is terminated closes its current output file properly — trailing
- * index and all — but the file holds only what had been muxed by then, and
- * after a seek-restart that is routinely one track of two. Nothing about it
- * looks unfinished, so the readiness rule called it done and served it, and the
- * player could not complete the seek. Measured 2026-08-06: segment #133 carried
- * one `tfdt` where its neighbours carried two, every request for it was
- * answered in 98 ms, and the viewer sat on a spinner.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-// Build a minimal init declaring two tracks, and fragments declaring one/two.
-function box(type, body) {
-  const b = Buffer.alloc(8 + body.length);
-  b.writeUInt32BE(8 + body.length, 0); b.write(type, 4, "latin1"); body.copy(b, 8);
-  return b;
-}
-function mdhd(timescale) { const b = Buffer.alloc(20); b.writeUInt32BE(timescale, 12); return box("mdhd", b); }
-function tkhd(id) { const b = Buffer.alloc(84); b.writeUInt32BE(id, 12); return box("tkhd", b); }
-function trak(id, ts) { return box("trak", Buffer.concat([tkhd(id), box("mdia", mdhd(ts))])); }
-const init = box("moov", Buffer.concat([trak(1, 16000), trak(2, 48000)]));
-function tfhd(id) { const b = Buffer.alloc(8); b.writeUInt32BE(id, 4); return box("tfhd", b); }
-function moof(ids) { return box("moof", Buffer.concat(ids.map((id) => box("traf", tfhd(id))))); }
-
-test("a segment with every track is accepted", () => {
-  assert.equal(fmp4Format.hasEveryTrack(moof([1, 2]), init), true);
-});
-test("a segment left short of a track by a killed run is refused", () => {
-  assert.equal(fmp4Format.hasEveryTrack(moof([1]), init), false,
-    "one track of two is what a terminated run leaves behind, and it looks complete");
-});
-test("an empty file is refused", () => {
-  assert.equal(fmp4Format.hasEveryTrack(Buffer.alloc(0), init), false);
-});
-test("without an init there is nothing to compare against, so it is allowed", () => {
-  assert.equal(fmp4Format.hasEveryTrack(moof([1]), null), true);
-});

package/test/format-keyed-outputs.test.js

@@ -1,78 +0,0 @@
-/**
- * @file An output is named by the format it produces, and nothing may put
- * pieces of another format under that name.
- *
- * Two ways that could still happen once the name became the format: a
- * directory left by an earlier version, whose key named the box a viewer asked
- * for and so cannot say what format is inside; and a hardware encoder failing,
- * after which the proxy encodes with software while outputs named by the failed
- * encoder are still being watched.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { existsSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { managerWithOwnStore } from "./helpers/manager.js";
-import { outputSpec } from "./helpers/output-spec.js";
-import { ENCODE_EXIT } from "../services/encode/encode-exit.js";
-import { SourceFile } from "../services/media/SourceFile.js";
-
-test("a directory whose key names an asked-for box is not adopted, and one naming a format is", (t) => {
-  const { store, root, manager, cleanup } = managerWithOwnStore();
-  t.after(cleanup);
-  const oldKey = "torrent:abc:fmt=fmp4:grid=even@0:video-only:v=0/enc:1280x720:budget";
-  const newKey = outputSpec({ sourceKey: "torrent:abc", transcodeVideo: true, width: 1280, height: 720, audioSeparate: true }).toKey();
-  const oldDir = store.directoryFor(oldKey);
-  const newDir = store.directoryFor(newKey);
-  writeFileSync(path.join(oldDir, "segment-00000.mp4"), Buffer.alloc(10));
-  writeFileSync(path.join(newDir, "segment-00000.mp4"), Buffer.alloc(10));
-
-  const result = manager.lifecycle.adoptSegmentsLeftBehind();
-
-  assert.equal(result.adopted, 1);
-  assert.equal(result.dropped, 1);
-  assert.equal(existsSync(oldDir), false, "the old directory goes");
-  assert.equal(existsSync(newDir), true, "the named format stays");
-  assert.ok(root);
-});
-
-test("when a hardware encoder fails, the outputs it named are closed rather than continued by software", async (t) => {
-  const { manager, cleanup } = managerWithOwnStore({
-    videoEncoder: { kind: "vaapi", name: "h264_vaapi", inputArgs: [] }
-  });
-  t.after(async () => {
-    await manager.lifecycle.disposeAll();
-    cleanup();
-  });
-  manager.encodeRuns.planEncodersNow = () => {};
-  manager.encodeRuns.planEncodersSoon = () => {};
-  const file = new SourceFile({ sourceKey: "torrent:abc", fileIndex: 0, name: "film.mkv" });
-  const record = (id, encoder) => {
-    const spec = outputSpec({ sourceKey: "torrent:abc", transcodeVideo: true, width: 1280, height: 720, encoder });
-    const output = { id, spec, get outputKey() { return this.spec.toKey(); }, file };
-    manager.outputs.set(id, output);
-    return output;
-  };
-  const failing = record("aaaaaaaa00000001", "h264_vaapi");
-  const software = record("aaaaaaaa00000002", "libx264");
-  const run = { from: 0, to: -1, argsDescribed: "ffmpeg …" };
-  manager.encodeOrchestrator.adopt(failing.outputKey, run);
-
-  manager.encodeRuns.noteRunEnded(failing, run, {
-    address: failing.outputKey,
-    run,
-    ending: ENCODE_EXIT.FAILED,
-    from: 0,
-    to: -1,
-    livedMs: 30_000,
-    because: "vaapi failed",
-    lastError: "vaapi failed",
-    producedCount: 3
-  });
-  await new Promise((resolve) => setImmediate(resolve));
-
-  assert.equal(manager.encoders.current.kind, "software");
-  assert.equal(manager.outputs.has(failing.id), false, "an output of the failed encoder is closed");
-  assert.equal(manager.outputs.has(software.id), true, "an output of another encoder is untouched");
-});

package/test/health-metrics.test.js

@@ -1,36 +0,0 @@
-/**
- * @file What a proxy says about itself, and what the pool scores it on.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import os from "node:os";
-
-import { collectHealthMetrics } from "../services/transport/health-collector.js";
-import { availableMemory, availableMemoryBytes } from "../services/storage/machine-memory.js";
-
-test("free memory is what could be given out, not what is idle this instant", () => {
-  const available = availableMemory();
-  assert.ok(Number.isFinite(available.bytes) && available.bytes > 0);
-
-  // On Linux this is the kernel's own `MemAvailable`, not `os.freemem()`: the
-  // kernel keeps free memory low on purpose and fills the rest with cache, which
-  // it hands back the moment anything asks. The old reading was `os.freemem()`,
-  // so a host with 4 GB of cache and 200 MB genuinely free reported itself nearly
-  // full while it had 4.2 GB to give — and that figure weighs 0.4 of every
-  // proxy's score. Asked of the reading itself: comparing it with a second
-  // reading taken a moment later measures whatever else the machine was doing.
-  if (os.platform() === "linux") {
-    assert.equal(available.measured, true, "the kernel's own estimate was not read");
-  }
-});
-
-test("the health report is three bounded numbers", () => {
-  const metrics = collectHealthMetrics({ availableMemoryBytes });
-  assert.ok(metrics.cpuLoad >= 0);
-  assert.ok(metrics.memFree > 0 && metrics.memFree <= 1);
-  assert.ok(Number.isInteger(metrics.uptime) && metrics.uptime >= 0);
-  // Three decimals, so a value that has not really moved does not produce a
-  // different message on every poll.
-  assert.equal(metrics.memFree, Math.round(metrics.memFree * 1000) / 1000);
-});

package/test/held-read-ownership.test.js

@@ -1,77 +0,0 @@
-/**
- * @file A read of what is downloaded asks for nothing, and hands the other
- * thread memory that is its own.
- *
- * Until 2026-10-01 the read opened the torrent's own file stream on bytes that
- * had not arrived; that stream selects pieces itself, outside the demand
- * register, and waited up to thirty seconds — 36 such reads at a torrent's open
- * competed with the file being watched. And the bytes it returns are now handed
- * to the main thread instead of copied, which is safe only for a buffer that is
- * the whole of its own memory. Fakes only.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { Readable } from "node:stream";
-import { MessageChannel } from "node:worker_threads";
-import { createHash } from "node:crypto";
-
-import { ownsItsMemory, readHeldBytes } from "../services/torrent/worker/held-bytes.js";
-
-const digest = (bytes) => createHash("sha256").update(bytes).digest("hex");
-
-/** A torrent of one file whose stream serves views of one shared store buffer. */
-function torrentOver(store, held) {
-  const streams = [];
-  const file = {
-    name: "film.mkv",
-    length: store.length,
-    offset: 0,
-    createReadStream({ start, end }) {
-      streams.push({ start, end });
-      return Readable.from([store.subarray(start, end + 1)]);
-    }
-  };
-  return {
-    streams,
-    torrent: { pieceLength: 16, bitfield: { get: (index) => held(index) }, files: [file] }
-  };
-}
-
-test("a range not wholly downloaded is answered at once with nothing, and no stream is opened", async () => {
-  const store = Buffer.alloc(64, 1);
-  const { torrent, streams } = torrentOver(store, (index) => index !== 2);
-  assert.equal(await readHeldBytes(torrent, 0, 0, 63), null);
-  assert.equal(streams.length, 0, "nothing was asked of the torrent");
-  assert.notEqual(await readHeldBytes(torrent, 0, 0, 31), null, "a range that is here is read");
-});
-
-test("what a held read returns owns its memory; a pool slice and shared memory do not", async () => {
-  const store = Buffer.from(Array.from({ length: 64 }, (_, index) => index));
-  const { torrent } = torrentOver(store, () => true);
-  const bytes = await readHeldBytes(torrent, 0, 3, 40);
-  assert.equal(ownsItsMemory(bytes), true);
-  assert.equal(ownsItsMemory(Buffer.from("small")), false, "a slice of Node's pool");
-  assert.equal(ownsItsMemory(new Uint8Array(new SharedArrayBuffer(8))), false, "shared memory");
-  assert.equal(ownsItsMemory(store.subarray(4, 8)), false, "a view into another buffer");
-});
-
-test("handing a read's bytes to another thread leaves the store and an overlapping read as they were", async () => {
-  const store = Buffer.from(Array.from({ length: 256 }, (_, index) => index % 251));
-  const before = digest(store);
-  const { torrent } = torrentOver(store, () => true);
-  const [first, second] = await Promise.all([readHeldBytes(torrent, 0, 10, 200), readHeldBytes(torrent, 0, 50, 120)]);
-  const secondBefore = digest(second);
-
-  const { port1, port2 } = new MessageChannel();
-  const received = new Promise((resolve) => port2.once("message", resolve));
-  port1.postMessage({ bytes: first }, [first.buffer]);
-  const message = await received;
-  port1.close();
-  port2.close();
-
-  assert.equal(first.byteLength, 0, "the sender no longer holds the memory it handed over");
-  assert.deepEqual(Buffer.from(message.bytes), store.subarray(10, 201), "the receiver has every byte");
-  assert.equal(digest(store), before, "the store's own bytes are untouched");
-  assert.equal(digest(second), secondBefore, "the overlapping read is untouched");
-});