@torrent-tv/proxy 2.89.16 → 2.89.18

package/test/output-catalog.test.js

@@ -1,39 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { OutputCatalog } from "../services/encode/output/OutputCatalog.js";
-
-test("the catalog owns creation and access times", () => {
-  let now = 100;
-  const registry = new OutputCatalog({ now: () => now });
-  const output = { id: "picture" };
-  registry.set(output.id, output);
-
-  now = 250;
-  registry.touch(output);
-
-  assert.equal(registry.startedAt(output), 100);
-  assert.equal(registry.lastAccessedAt(output), 250);
-  assert.equal("startedAt" in output, false);
-  assert.equal("lastAccessedAt" in output, false);
-});
-
-test("expiry is decided from the catalog's access time", () => {
-  let now = 100;
-  const registry = new OutputCatalog({ now: () => now });
-  registry.set("old", { id: "old" });
-  now = 200;
-  registry.set("fresh", { id: "fresh" });
-
-  assert.deepEqual(registry.expiredBefore(150), ["old"]);
-});
-
-test("removal deletes both the output and its lifetime", () => {
-  const registry = new OutputCatalog({ now: () => 100 });
-  const output = { id: "picture" };
-  registry.set(output.id, output);
-  registry.delete(output.id);
-
-  assert.equal(registry.get(output.id), undefined);
-  assert.equal(registry.startedAt(output), null);
-  assert.equal(registry.touch(output, 200), false);
-});

package/test/output-shape.test.js

@@ -1,21 +0,0 @@
-/**
- * @file The shape an encoder is given for an output.
- *
- * The format itself is the output's identity (`OutputSpec`), decided before
- * the output is named; this is that format in the terms the encoder takes.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { Output } from "../services/encode/output/Output.js";
-
-test("a copied picture has no box of its own, and says so with zeroes", () => {
-  // Zero means the source's own size, which is what a copy is by definition:
-  // no box asked for can change one byte of it.
-  const copied = new Output({ encodeWidth: 0, encodeHeight: 0, outputFps: 24 });
-
-  assert.equal(copied.encodeWidth, 0);
-  assert.equal(copied.encodeHeight, 0);
-  assert.equal(copied.softwarePreset, null, "and no speed setting, having no encoder");
-});
-

package/test/output-spec.test.js

@@ -1,251 +0,0 @@
-import assert from "node:assert/strict";
-import { softwareRateControlFor } from "../services/encode/args.js";
-import test from "node:test";
-import { createHash } from "node:crypto";
-import { AudioOutput, CutGrid, isOutputName, OutputSpec, VideoOutput } from "../services/encode/output/OutputSpec.js";
-
-const TORRENT = "torrent:11f0929918e2b5aa2e5b71ecdbe5c0f1a4bbf7d1";
-
-/**
- * The picture of a file, copied, cut at that file's own keyframes.
- *
- * @param {object} [over]
- * @returns {OutputSpec}
- */
-function copiedPicture(over = {}) {
-  return new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "fmp4",
-    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
-    video: new VideoOutput({ fileIndex: 0, encode: null }),
-    audio: null,
-    ...over
-  });
-}
-
-test("two viewers who chose different soundtracks share one copied picture", () => {
-  // The measurement of 2026-09-03: both sessions described the same thing word
-  // for word and answered `segment-00000.mp4` with the same 4141899 bytes. The
-  // soundtrack they picked is not a property of a picture that carries no
-  // sound, so it cannot tell the two apart.
-  assert.equal(copiedPicture().toKey(), copiedPicture().toKey());
-  assert.equal(copiedPicture().carries, "video-only");
-});
-
-test("the viewer's viewport does not fork a picture that is copied", () => {
-  // A copy is the source's own size whatever box was asked for, so there is
-  // nowhere for a target to appear in the key.
-  const key = copiedPicture().toKey();
-  assert.ok(!key.includes("x"), `a copied picture states no box: ${key}`);
-});
-
-function encoded(over = {}) {
-  return copiedPicture({
-    video: new VideoOutput({
-      fileIndex: 0,
-      encode: { encoder: "libx264", width: 1280, height: 720, fps: 24, preset: "veryfast", tonemap: false, ...over }
-    })
-  });
-}
-
-test("two heights of one picture are two outputs", () => {
-  assert.notEqual(encoded().toKey(), encoded({ width: 854, height: 480 }).toKey());
-});
-
-test("an output is the format produced, and every part of it that reaches the header tells two apart", () => {
-  const base = encoded().toKey();
-  assert.notEqual(base, encoded({ preset: "ultrafast" }).toKey(), "the speed setting changes the PPS");
-  assert.notEqual(base, encoded({ encoder: "h264_nvenc" }).toKey(), "another encoder writes another SPS");
-  assert.notEqual(base, encoded({ fps: 30 }).toKey(), "the frame rate");
-  assert.notEqual(base, encoded({ tonemap: true }).toKey(), "a tone-mapped picture");
-});
-
-test("how the format was asked for is not part of it", () => {
-  const asked = new VideoOutput({
-    fileIndex: 0,
-    encode: { encoder: "libx264", width: 1280, height: 720, fps: 24, preset: "veryfast", tonemap: false, exactSize: true }
-  });
-  assert.equal(copiedPicture({ video: asked }).toKey(), encoded().toKey());
-});
-
-test("a key reads back into the output it names", () => {
-  const muxed = new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "mpegts",
-    grid: new CutGrid({ kind: "uniform", fileIndex: 2 }),
-    video: new VideoOutput({
-      fileIndex: 2,
-      encode: { encoder: "libx264", width: 854, height: 480, fps: 25, preset: null, tonemap: true }
-    }),
-    audio: new AudioOutput({ fileIndex: 5, trackIndex: 1, transcode: true })
-  });
-  for (const spec of [copiedPicture(), encoded(), muxed]) {
-    assert.equal(OutputSpec.fromKey(spec.toKey())?.toKey(), spec.toKey());
-  }
-});
-
-test("a key naming the box a viewer asked for does not read back, because it cannot say what format is inside", () => {
-  assert.equal(OutputSpec.fromKey(`${TORRENT}:fmt=fmp4:grid=even@0:video-only:v=0/enc:1280x720:exact`), null);
-  assert.equal(OutputSpec.fromKey(`${TORRENT}:fmt=fmp4:grid=even@0:video-only:v=0/enc:1280x720:budget`), null);
-});
-
-test("the bitrate limit is part of the output: two limits are two outputs, and the key reads back", () => {
-  // Roadmap item 97, step 10. A limit changes the bytes of every piece, so it
-  // names the output; the level is the nominal output's, so it is the same for
-  // both limits of one size and their headers agree.
-  const nominal = softwareRateControlFor({ width: 1280, height: 720, fps: 24 });
-  const lower = softwareRateControlFor({ width: 1280, height: 720, fps: 24, capKbps: 1400 });
-  const atNominal = encoded({ rateControl: nominal });
-  const atLower = encoded({ rateControl: lower });
-
-  assert.notEqual(atNominal.toKey(), atLower.toKey());
-  assert.notEqual(atNominal.toKey(), encoded().toKey(), "a limit and none are two outputs too");
-  assert.equal(nominal.level, lower.level);
-  for (const spec of [atNominal, atLower, encoded()]) {
-    assert.equal(OutputSpec.fromKey(spec.toKey())?.toKey(), spec.toKey());
-  }
-  assert.deepEqual(OutputSpec.fromKey(atLower.toKey()).video.encode.rateControl, lower);
-});
-
-test("a key written before the limit was part of it does not read back", () => {
-  // Its directory could hold pieces made under any limit the budget had moved
-  // it to, so nothing can say what is inside, and it is not served.
-  const current = encoded().toKey();
-  assert.equal(OutputSpec.fromKey(current.replace("/vbv=-", "")), null);
-});
-
-test("a soundtrack is named by the file it lives in and the track inside it", () => {
-  // Not by the flat number the browser sends: that number spans the picture's
-  // own tracks and the files beside it, so it means different things for
-  // different pictures of one torrent.
-  const dub = new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "fmp4",
-    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
-    audio: new AudioOutput({ fileIndex: 7, trackIndex: 0, transcode: true })
-  });
-  assert.equal(dub.carries, "audio-only");
-  assert.ok(dub.toKey().includes("a=7/0/aac"), dub.toKey());
-});
-
-test("one soundtrack cut for two different pictures is two outputs", () => {
-  // The grid of a soundtrack is the picture's, so a rendition made for episode
-  // one cannot stand in for one made for episode two even when the dub is the
-  // same file.
-  const forFirst = new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "fmp4",
-    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
-    audio: new AudioOutput({ fileIndex: 7, trackIndex: 0, transcode: true })
-  });
-  const forSecond = new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "fmp4",
-    grid: new CutGrid({ kind: "keyframe", fileIndex: 1 }),
-    audio: new AudioOutput({ fileIndex: 7, trackIndex: 0, transcode: true })
-  });
-  assert.notEqual(forFirst.toKey(), forSecond.toKey());
-});
-
-test("a copied soundtrack and a re-encoded one are two outputs", () => {
-  const copied = new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "fmp4",
-    grid: new CutGrid({ kind: "uniform", fileIndex: 0 }),
-    audio: new AudioOutput({ fileIndex: 0, trackIndex: 1, transcode: false })
-  });
-  const encoded = new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "fmp4",
-    grid: new CutGrid({ kind: "uniform", fileIndex: 0 }),
-    audio: new AudioOutput({ fileIndex: 0, trackIndex: 1, transcode: true })
-  });
-  assert.notEqual(copied.toKey(), encoded.toKey());
-});
-
-test("a browser without rendition groups gets an output carrying both tracks", () => {
-  const muxed = new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "mpegts",
-    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
-    video: new VideoOutput({ fileIndex: 0, encode: null }),
-    audio: new AudioOutput({ fileIndex: 0, trackIndex: 2, transcode: true })
-  });
-  assert.equal(muxed.carries, "muxed");
-  // And there the soundtrack DOES tell two of them apart, because the output
-  // really carries it.
-  const other = new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "mpegts",
-    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
-    video: new VideoOutput({ fileIndex: 0, encode: null }),
-    audio: new AudioOutput({ fileIndex: 0, trackIndex: 3, transcode: true })
-  });
-  assert.notEqual(muxed.toKey(), other.toKey());
-});
-
-test("the picture, its soundtrack and the two of them muxed are three outputs", () => {
-  const video = copiedPicture();
-  const audio = new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "fmp4",
-    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
-    audio: new AudioOutput({ fileIndex: 0, trackIndex: 0, transcode: true })
-  });
-  const muxed = copiedPicture({
-    audio: new AudioOutput({ fileIndex: 0, trackIndex: 0, transcode: true })
-  });
-  assert.equal(new Set([video.toKey(), audio.toKey(), muxed.toKey()]).size, 3);
-});
-
-test("two containers of the same tracks are two outputs", () => {
-  assert.notEqual(copiedPicture().toKey(), copiedPicture({ segmentFormatId: "mpegts" }).toKey());
-});
-
-test("the same tracks of two different torrents are two outputs", () => {
-  assert.notEqual(copiedPicture().toKey(), copiedPicture({ sourceKey: "torrent:0000" }).toKey());
-});
-
-test("a picture cut at keyframes and the same picture cut on the even grid are two outputs", () => {
-  assert.notEqual(
-    copiedPicture().toKey(),
-    copiedPicture({ grid: new CutGrid({ kind: "uniform", fileIndex: 0 }) }).toKey()
-  );
-});
-
-test("an output's name follows from its identity and from nothing else", () => {
-  // MANY VIEWERS OF ONE OUTPUT address one name because the name is the
-  // output's. Nobody arranges it, and nothing about the request enters it: two
-  // people opening the same film at different moments and at different places
-  // are handed the same name.
-  assert.equal(copiedPicture().toName(), copiedPicture().toName());
-  assert.notEqual(
-    copiedPicture().toName(),
-    copiedPicture({ video: new VideoOutput({ fileIndex: 1, encode: null }) }).toName(),
-    "and two different outputs are two different names"
-  );
-  // Stated against the key itself, which is the one thing that proves nothing
-  // ELSE got mixed in. Two specs built in one test run agree even if the name
-  // secretly carried the clock, because the clock has not moved between them —
-  // and "however far apart they arrive" is the whole property.
-  assert.equal(
-    copiedPicture().toName(),
-    createHash("sha256").update(copiedPicture().toKey()).digest("hex").slice(0, 16)
-  );
-});
-
-test("a name is safe to carry whole, and the guard that admits it agrees", () => {
-  // The name reaches the filesystem: it is what the produced pieces of this
-  // output are found under. So the shape is asserted here AND where a request
-  // is admitted, and the two must be changed together — they were not, the
-  // first time this name was minted, and every guarded route would have refused
-  // every request while no check said a word.
-  const name = copiedPicture().toName();
-
-  assert.ok(isOutputName(name), "the guard admits what the minting produces");
-  assert.equal(encodeURIComponent(name), name, "and it needs no escaping to be carried whole");
-  // What the guard is FOR.
-  assert.equal(isOutputName("../../etc/passwd"), false);
-  assert.equal(isOutputName("aaaaaaaa1111222"), false, "fifteen is not sixteen");
-  assert.equal(isOutputName("11111111-2222-3333-4444-555555555555"), false, "and the old shape is gone");
-});

package/test/output-speed.test.js

@@ -1,92 +0,0 @@
-/**
- * @file How fast this machine produces one output.
- *
- * The figure every decision in the encoding layer rests on: where an encoder
- * goes and how many run are both worked out from arrivals, and an arrival is a
- * distance divided by this. There must therefore ALWAYS be an answer, and each
- * of the three that can be given is a measurement rather than a guess.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { EncodeCost } from "../services/encode/quality/EncodeCost.js";
-import { OutputCatalog } from "../services/encode/output/OutputCatalog.js";
-import { qualityStateOf } from "../services/encode/quality/OutputQualityState.js";
-import { outputSpec } from "./helpers/output-spec.js";
-
-const PICTURE = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
-
-/**
- * @param {object[]} sessions
- * @param {{ copySpeedX?: number | null, benchmark?: object[] | null }} host
- */
-function costOf(sessions, host = {}) {
-  const outputs = new OutputCatalog();
-  sessions.forEach(({ lastAloneSpeed, ...session }, index) => {
-    // What a run measured belongs to the quality component's state of the output.
-    qualityStateOf(session).lastAloneSpeed = lastAloneSpeed ?? undefined;
-    outputs.set(String(index), session);
-  });
-  return new EncodeCost({
-    runsFor: () => [],
-    stateFor: () => "IDLE",
-    outputs,
-    host: () => ({
-      benchmark: host.benchmark ?? null,
-      decodeModel: null,
-      contentionPenalties: null,
-      copySpeedX: host.copySpeedX ?? null,
-      availability: null
-    }),
-    audioCostKey: () => "",
-    runningEncoders: () => 0,
-    encodersRunningNow: () => 0,
-    torrentCostSecFor: () => 0
-  });
-}
-
-test("a run on this output outranks every prediction", () => {
-  // It is this machine, this material and these settings. Nothing said before
-  // the fact beats something seen happening.
-  const cost = costOf(
-    [{ outputKey: PICTURE, spec: outputSpec(), lastAloneSpeed: 9.5 }],
-    { copySpeedX: 600 }
-  );
-  assert.equal(cost.speedForOutput(PICTURE), 9.5);
-});
-
-test("a copied picture is priced by the startup copy measurement", () => {
-  // The branch that had no figure at all until it was measured: copying neither
-  // decodes nor encodes, so neither the preset benchmark nor the decode model
-  // describes it, and a copied output was planned with no speed until its own
-  // run had been running long enough to report one.
-  const cost = costOf(
-    [{ outputKey: PICTURE, spec: outputSpec(), lastAloneSpeed: null }],
-    { copySpeedX: 602 }
-  );
-  assert.equal(cost.speedForOutput(PICTURE), 602);
-});
-
-test("the fastest reading wins where several sessions produce one output", () => {
-  // Two sessions whose output parameters agree ARE one output, so what either
-  // of them measured about this machine is true of the other.
-  const cost = costOf([
-    { outputKey: PICTURE, spec: outputSpec(), lastAloneSpeed: 4 },
-    { outputKey: PICTURE, spec: outputSpec(), lastAloneSpeed: 7 }
-  ]);
-  assert.equal(cost.speedForOutput(PICTURE), 7);
-});
-
-test("an output absent from the live registry says nothing about what the machine is doing", () => {
-  const cost = costOf([], { copySpeedX: 602 });
-  assert.equal(cost.speedForOutput(PICTURE), 0, "no registered output, so nothing to say");
-});
-
-test("another output's reading is not borrowed", () => {
-  // Two outputs are two different pieces of work — a picture re-encoded to 480p
-  // and the same picture copied are not the same speed.
-  const cost = costOf([
-    { outputKey: "other", spec: outputSpec(), lastAloneSpeed: 40 }
-  ]);
-  assert.equal(cost.speedForOutput(PICTURE), 0);
-});

package/test/outputs-being-prepared.test.js

@@ -1,40 +0,0 @@
-/**
- * @file The places preparations hold on the machine are read off the viewers'
- * own records (roadmap item 97, step 13): a step being warmed and a move to
- * another limit of the height on screen are one list, and a place ends with
- * the record — or the viewer — that holds it.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { Viewers } from "../services/viewer/Viewers.js";
-import { outputsBeingPrepared } from "../services/viewer/choices.js";
-
-const PICTURE = { id: "1111111122223333", outputKey: "picture" };
-
-test("a warmed step and a move between limits are one list of places", () => {
-  const viewers = new Viewers();
-  const warming = viewers.of(PICTURE, "viewer-a");
-  warming.warmingVariantId = "2222222233334444";
-  const moving = viewers.of(PICTURE, "viewer-b");
-  moving.sameHeightSwitch = { outputId: "3333333344445555", outputKey: "limit", askedHeights: [720] };
-  assert.deepEqual([...outputsBeingPrepared(viewers)].sort(), ["2222222233334444", "3333333344445555"]);
-});
-
-test("one output prepared for two viewers is one place", () => {
-  const viewers = new Viewers();
-  viewers.of(PICTURE, "viewer-a").warmingVariantId = "2222222233334444";
-  viewers.of(PICTURE, "viewer-b").sameHeightSwitch = { outputId: "2222222233334444", outputKey: "step" };
-  assert.equal(outputsBeingPrepared(viewers).size, 1);
-});
-
-test("a place ends with its record, and with the viewer", () => {
-  const viewers = new Viewers();
-  const viewer = viewers.of(PICTURE, "viewer-a");
-  viewer.warmingVariantId = "2222222233334444";
-  viewer.warmingVariantId = null;
-  assert.equal(outputsBeingPrepared(viewers).size, 0, "the record cleared");
-  viewers.of(PICTURE, "viewer-b").warmingVariantId = "2222222233334444";
-  viewers.hasGone("viewer-b");
-  assert.equal(outputsBeingPrepared(viewers).size, 0, "the viewer gone");
-});

package/test/packet-witness-ring.test.js

@@ -1,236 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { EventEmitter } from "node:events";
-import { mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-
-import {
-  adoptOrphanRingFiles,
-  createPacketWitness,
-  WITNESS_RING_BASENAME
-} from "../services/transport/packet-witness.js";
-
-/**
- * A stand-in for a spawned tcpdump: it records how it was called and stays
- * "running" until something kills it.
- */
-class FakeChild extends EventEmitter {
-  constructor(command, args) {
-    super();
-    this.command = command;
-    this.args = args;
-    this.killed = false;
-    this.signals = [];
-  }
-
-  kill(signal) {
-    this.signals.push(signal);
-    if (!this.killed) {
-      this.killed = true;
-      // A real child exits asynchronously, which is what the code must wait for.
-      setImmediate(() => this.emit("close", 0, signal));
-    }
-    return true;
-  }
-}
-
-/**
- * @returns {{ spawnProcess: Function, children: FakeChild[], rings: FakeChild[] }}
- */
-function makeSpawn() {
-  const children = [];
-  const spawnProcess = (command, args) => {
-    const child = new FakeChild(command, args);
-    children.push(child);
-    if (args.includes("--version")) {
-      // The availability probe: answer at once, like a present tcpdump.
-      setImmediate(() => child.emit("spawn"));
-    }
-    return child;
-  };
-  return {
-    spawnProcess,
-    children,
-    get rings() {
-      return children.filter((child) => !child.args.includes("--version"));
-    }
-  };
-}
-
-/**
- * Wait until `check` holds, rather than for a chosen interval.
- *
- * A fixed sleep passes alone and fails in a full run — the defect roadmap item
- * 51 names — and the work here is several awaits deep (probe, stop, readdir,
- * copy, restart), so its duration is whatever the machine is busy with.
- *
- * @param {() => boolean | Promise<boolean>} check
- * @param {string} what
- * @returns {Promise<void>}
- */
-async function waitFor(check, what) {
-  const deadline = Date.now() + 10_000;
-  for (;;) {
-    if (await check()) {
-      return;
-    }
-    if (Date.now() > deadline) {
-      throw new Error(`timed out waiting for ${what}`);
-    }
-    await new Promise((resolve) => setTimeout(resolve, 5));
-  }
-}
-
-/** Let every already-queued microtask and immediate run. */
-const settle = () => new Promise((resolve) => setTimeout(resolve, 20));
-
-async function withDir(run) {
-  const dir = await mkdtemp(path.join(os.tmpdir(), "witness-ring-"));
-  try {
-    await run(dir);
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-}
-
-test("the ring runs while a channel is open and stops with the last one", async () => {
-  await withDir(async (dir) => {
-    const spawn = makeSpawn();
-    const witness = createPacketWitness({
-      log: () => {},
-      dir,
-      port: 9090,
-      spawnProcess: spawn.spawnProcess
-    });
-
-    witness.holdRing();
-    witness.holdRing();
-    await waitFor(() => spawn.rings.length === 1, "the ring to start");
-    assert.equal(spawn.rings.length, 1, "a second channel must not start a second ring");
-    assert.equal(spawn.rings[0].killed, false);
-
-    witness.releaseRing();
-    await settle();
-    assert.equal(spawn.rings[0].killed, false, "one channel left still wants the ring");
-
-    witness.releaseRing();
-    await waitFor(() => spawn.rings[0].killed, "the ring to stop");
-  });
-});
-
-test("a channel that opens and closes while the ring is starting leaves nothing running", async () => {
-  await withDir(async (dir) => {
-    const spawn = makeSpawn();
-    const witness = createPacketWitness({
-      log: () => {},
-      dir,
-      port: 9090,
-      spawnProcess: spawn.spawnProcess
-    });
-    // Release before the availability probe has resolved — the start is still
-    // in flight. Without the second look after the await this leaves a tcpdump
-    // nobody holds and nobody will ever stop.
-    witness.holdRing();
-    witness.releaseRing();
-    await waitFor(
-      () => spawn.rings.every((child) => child.killed),
-      "any ring started mid-flight to be stopped"
-    );
-    const alive = spawn.rings.filter((child) => !child.killed);
-    assert.deepEqual(alive, [], "no ring may outlive the channels that wanted it");
-  });
-});
-
-test("the ring's files are removed once nobody is being served", async () => {
-  await withDir(async (dir) => {
-    const spawn = makeSpawn();
-    const witness = createPacketWitness({
-      log: () => {},
-      dir,
-      port: 9090,
-      spawnProcess: spawn.spawnProcess
-    });
-    witness.holdRing();
-    await waitFor(() => spawn.rings.length === 1, "the ring to start");
-    await writeFile(path.join(dir, `${WITNESS_RING_BASENAME}0`), "pcap");
-    witness.releaseRing();
-    await waitFor(async () => (await readdir(dir)).length === 0, "the ring files to be removed");
-  });
-});
-
-test("a wedge keeps the ring's history, and the ring keeps recording afterwards", async () => {
-  await withDir(async (dir) => {
-    const spawn = makeSpawn();
-    const lines = [];
-    const witness = createPacketWitness({
-      log: (message) => lines.push(message),
-      dir,
-      port: 9090,
-      spawnProcess: spawn.spawnProcess
-    });
-    witness.holdRing();
-    await waitFor(() => spawn.rings.length === 1, "the ring to start");
-    await writeFile(path.join(dir, `${WITNESS_RING_BASENAME}0`), "before-the-freeze");
-    await writeFile(path.join(dir, `${WITNESS_RING_BASENAME}1`), "also-before");
-
-    const started = witness.maybeCapture({
-      sessionId: "68296f7d00000000",
-      tag: "68296f7d",
-      label: "proxy",
-      remote: { address: "2001:db8::1", port: 61649 },
-      queuedBytes: 67_372_267,
-      stuckForMs: 4000
-    });
-    assert.equal(started, true);
-    await waitFor(
-      async () => (await readdir(dir)).filter((name) => name.includes(".before")).length === 2,
-      "both ring files to be copied aside"
-    );
-
-    const kept = (await readdir(dir)).filter((name) => name.includes(".before"));
-    assert.equal(kept.length, 2, "both ring files must be kept, not just the finished one");
-    assert.ok(kept.every((name) => name.startsWith("packet-witness.68296f7d.")));
-    // Stopped to flush, then started again: two ring processes over the episode.
-    await waitFor(() => spawn.rings.length >= 2, "the ring to resume after the copy");
-    assert.equal(spawn.rings.at(-1).killed, false);
-    assert.ok(lines.some((line) => line.includes("kept 2 ring file(s)")));
-
-    // End the tail capture: it would otherwise sit out its whole window, and
-    // its timer would hold this process open.
-    for (const child of spawn.children) {
-      child.kill("SIGTERM");
-    }
-    await settle();
-  });
-});
-
-test("dispose stops the ring and clears its files", async () => {
-  await withDir(async (dir) => {
-    const spawn = makeSpawn();
-    const witness = createPacketWitness({
-      log: () => {},
-      dir,
-      port: 9090,
-      spawnProcess: spawn.spawnProcess
-    });
-    witness.holdRing();
-    await waitFor(() => spawn.rings.length === 1, "the ring to start");
-    await writeFile(path.join(dir, `${WITNESS_RING_BASENAME}0`), "pcap");
-    await witness.dispose();
-    assert.equal(spawn.rings.at(-1).killed, true);
-    assert.deepEqual(await readdir(dir), []);
-  });
-});
-
-test("ring files left by a killed process are kept, not deleted by the next one", async () => {
-  await withDir(async (dir) => {
-    await writeFile(path.join(dir, `${WITNESS_RING_BASENAME}0`), "the seconds before the crash");
-    await writeFile(path.join(dir, `${WITNESS_RING_BASENAME}2`), "and these");
-    const adopted = await adoptOrphanRingFiles(dir);
-    assert.equal(adopted.length, 2);
-    const left = await readdir(dir);
-    assert.equal(left.filter((name) => name.startsWith(WITNESS_RING_BASENAME)).length, 0);
-    assert.ok(left.every((name) => name.startsWith("packet-witness.orphan.")));
-  });
-});