@torrent-tv/proxy 2.89.17 → 2.89.19

package/test/split-a-stretch.test.js

@@ -1,139 +0,0 @@
-/**
- * @file Where a second encoder joins a stretch, and whether it is worth having.
- *
- * Both halves are arithmetic and neither was asked before. The stretch used to
- * be halved, unconditionally:
- *
- *     widestFrom = from + Math.floor(Math.min(room, to - from + 1) / 2)
- *
- * Halving IS the answer when both encoders are fresh and owe the same. It is not
- * when one of them is already partway through a piece, and it never asked the
- * other question at all — whether two encoders under this host's measured
- * contention beat one at full speed.
- *
- * The derivation. A stretch of unmade film runs from `from` to `to`; whoever is
- * already on it stands at `from` and owes `w` before the piece under it exists;
- * a fresh one placed at `x` owes `d` — its start and then a whole piece — and
- * both then work at the rate two encoders leave each other:
- *
- *     the one there closes [from, x-1]:  w + (x - 1 - from) / r   rises with x
- *     the fresh one closes [x, to]:      d + (to - x)     / r     falls with x
- *
- *     x* = (from + to + 1) / 2  +  (d - w) * r / 2
- *
- * The shift is `firstByteWait / (2 * perPiece)` pieces, so it depends on how
- * long a piece takes here: 0.24 of a piece at 4.45x on a 4.2 s grid, but 0.96 at
- * 8.9x and 2.14 at 20x — a whole segment and more on the copy branch, where a
- * piece is short and a start is not. Measuring only the re-encode rate
- * understated it.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { planEncoders } from "../services/encode/EncodePlan.js";
-import { CoverageMap } from "../services/encode/CoverageMap.js";
-
-const SEGMENT_SECONDS = 4.2;
-const LAST = 199;
-
-/**
- * One encoder on a long stretch nobody has made, and room for more.
- *
- * @param {{ speedX: number, penalty: number, head?: number, ageMs?: number,
- *   maxRuns?: number }} params
- * @returns {{ actions: object[], run: object }}
- */
-function planFor({ speedX, penalty, head = 0, ageMs = 60_000, maxRuns = 3, runs = null }) {
-  const coverage = new CoverageMap({ segmentCount: LAST + 1 });
-  const run = { from: 0, to: -1, head, speedX, isAlive: true, startedAt: 1_000_000 };
-  const live = runs ?? [run];
-  for (const one of live) {
-    coverage.claim(one, one.from, one.to);
-  }
-  return {
-    run,
-    actions: planEncoders({
-      coverage,
-      // One zone over the whole film, due now, so nothing but the arithmetic of
-      // sharing it decides anything.
-      windows: [{ from: 0, to: LAST, priority: 100, withinSeconds: 0, behind: false }],
-      runs: live,
-      maxRuns,
-      segmentSeconds: SEGMENT_SECONDS,
-      speedX,
-      killCostSec: 0.04,
-      firstByteWaitSec: 0.9,
-      moveCostSec: 0.94,
-      refetchSecPerFilmSecond: 0,
-      // Measured on the addon host: 1.70 at 854x480, 1.98 at 1920x1080. Raised
-      // to the power of how many others there are, so a third costs again.
-      contentionPenaltyFor: (others) => (others <= 0 ? 1 : penalty ** others),
-      now: 1_000_000 + ageMs
-    })
-  };
-}
-
-test("one encoder that reaches everything in time is left to do it alone", () => {
-  // A zone whose deadline GROWS with distance — which is what the map states,
-  // one segment at a time — is comfortably served by one encoder at 4.45x: #199
-  // is due in 835 s and arrives in 189 s. So there is no position to fill and
-  // nothing to split, whatever the budget says.
-  //
-  // Measured rather than assumed: this is what the plan answers, and the test
-  // was written expecting two encoders before it was run.
-  const { actions } = planFor({ speedX: 4.45, penalty: 1, maxRuns: 3 });
-
-  assert.deepEqual(
-    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
-    ["keep #0..#-1"],
-    "one encoder, its road to the end of the film"
-  );
-});
-
-test("a stretch nobody is on is split at the middle, and the halves bound each other", () => {
-  // Both encoders are fresh, so both owe the same and `d - w` is zero: the
-  // meeting point is the midpoint, which is what halving always said. What is
-  // new is that each one's road ENDS where the next begins, so neither writes
-  // into the other's names.
-  const actions = planFor({ speedX: 4.45, penalty: 1, maxRuns: 2, runs: [] }).actions;
-
-  assert.deepEqual(
-    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
-    ["start #0..#100", "start #101..#199"],
-    "0..199 halved at 100"
-  );
-});
-
-test("a third encoder halves the widest half that is left", () => {
-  const actions = planFor({ speedX: 4.45, penalty: 1, maxRuns: 3, runs: [] }).actions;
-
-  assert.deepEqual(
-    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
-    ["start #0..#50", "start #51..#100", "start #101..#199"],
-    "the first half is halved again, greedily, widest first"
-  );
-});
-
-test("a stretch of one piece is not split at all", () => {
-  const coverage = new CoverageMap({ segmentCount: 2 });
-  const actions = planEncoders({
-    coverage,
-    windows: [{ from: 0, to: 0, priority: 100, withinSeconds: 0, behind: false }],
-    runs: [],
-    maxRuns: 3,
-    segmentSeconds: SEGMENT_SECONDS,
-    speedX: 8.9,
-    killCostSec: 0.04,
-    firstByteWaitSec: 0.9,
-    moveCostSec: 0.94,
-    refetchSecPerFilmSecond: 0,
-    contentionPenaltyFor: () => 1,
-    now: 1_000_000
-  });
-
-  assert.equal(
-    actions.filter((one) => one.type === "start").length,
-    1,
-    "there is nothing to share"
-  );
-});

package/test/stale-request-after-seek.test.js

@@ -1,158 +0,0 @@
-/**
- * @file A segment request steers nothing.
- *
- * Field 2026-08-17: the viewer seeked to 2083.4 s, both runs restarted at
- * segment #373, and a request for #371 — issued before the seek and reissued by
- * the player a second later — moved the encoder to #370. The viewer was at
- * #374 and waited for the encoder to come back to them.
- *
- * That was answered first by a guard: a request behind what the viewer had
- * REPORTED was refused, while the same traffic still moved the encoder when
- * nothing had been reported. The guard is gone with the thing it guarded. A
- * request for a file is not a statement about where anybody is, and nothing
- * about it belongs in the decision of where encoders go — that is read from the
- * priority map, which is built from where the viewers are and from nothing else.
- *
- * So the rule pinned here is now the whole rule, and it has no exception: a
- * request moves neither the encoder nor the viewer, whether or not the viewer
- * has said anything.
- */
-
-import assert from "node:assert/strict";
-import { SourceFile } from "../services/media/SourceFile.js";
-import { Timeline } from "../services/encode/output/Timeline.js";
-import test from "node:test";
-import { mkdtemp, rm } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-
-import { wireOutputs } from "../services/server/wire-outputs.js";
-import { startRunOn } from "./helpers/encode-run.js";
-import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-
-const SEGMENT_SECONDS = 4;
-const RUN_STARTS_AT = 373;
-const BEHIND_INDEX = 371;
-const SESSION_ID = "2222222233334444";
-
-/**
- * A live session whose run begins at #373 and whose directory is empty, so any
- * segment request is a request for something not yet produced.
- *
- * @returns {Promise<{ manager: object, session: object, dirPath: string }>}
- */
-async function sessionWithRunAt373() {
-  const dirPath = await mkdtemp(path.join(os.tmpdir(), "stale-request-"));
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  const session = {
-    id: SESSION_ID,
-    dirPath,
-    timeline: new Timeline({
-      boundaries: Array.from({ length: 901 }, (_, index) => index * SEGMENT_SECONDS),
-      cutGrid: "uniform"
-    }),
-    state: "ready",
-    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.mkv" }),
-    get inputFile() { return this.file; },
-    get audioFile() { return this.file; },
-    segmentFormat: fmp4Format,
-    segmentCount: 900,
-    startedAt: Date.now(),
-    lastAccessedAt: Date.now(),
-    runs: new Set(),
-    consumers: new Set(),
-    viewers: new Map(),
-    progress: { processedSeconds: RUN_STARTS_AT * SEGMENT_SECONDS },
-    useSyntheticPlaylist: true,
-    playlistText: "#EXTM3U\n",
-    lastError: "",
-    waitEpoch: 0
-  };
-  manager.outputs.set(SESSION_ID, session);
-  startRunOn(session, { from: RUN_STARTS_AT, usesExplicitCuts: true, speedX: 2 });
-  return { manager, session, dirPath };
-}
-
-/**
- * @param {object} manager
- * @param {object} session
- * @param {string} dirPath
- */
-async function tidy(manager, session, dirPath) {
-  if (session.seekSettleTimer) {
-    clearTimeout(session.seekSettleTimer);
-    session.seekSettleTimer = null;
-  }
-  manager.outputs.clear();
-  manager.stop?.();
-  await rm(dirPath, { recursive: true, force: true });
-}
-
-test("a request behind where the viewer said they are does not move the encoder", async (t) => {
-  const { manager, session, dirPath } = await sessionWithRunAt373();
-  t.after(async () => {
-    await tidy(manager, session, dirPath);
-  });
-
-  // The viewer stated their position: 2083.4 s, which is segment #520 here.
-  manager.viewerRequests.requestSeek(SESSION_ID, 2083.4, "viewer-1");
-
-  await manager.serving.getFileStream(
-    SESSION_ID,
-    fmp4Format.segmentFileName(BEHIND_INDEX)
-  );
-
-  // The field log's line was `seek settle → restart at segment #370`. Nothing
-  // aims an encoder from here at all now, so there is no destination for a
-  // stale request to become.
-  assert.equal(
-    session.seekTarget ?? null,
-    null,
-    "a request behind the viewer must not become the encoder's destination"
-  );
-  assert.equal(
-    session.seekSettleTimer ?? null,
-    null,
-    "and it must not arm a restart"
-  );
-});
-
-test("the same traffic moves nothing when the viewer has said nothing either", async (t) => {
-  const { manager, session, dirPath } = await sessionWithRunAt373();
-  t.after(async () => {
-    await tidy(manager, session, dirPath);
-  });
-
-  // THE CONTROL, INVERTED. It used to be that without a reported seek this very
-  // traffic DID move the encoder — the guard applied only to a viewer who had
-  // spoken. That exception is the thing that was removed: a request is evidence
-  // about what a player is reading, never about where a person is, and an
-  // encoder placed from it is placed from a number the player picked.
-  await manager.serving.getFileStream(
-    SESSION_ID,
-    fmp4Format.segmentFileName(BEHIND_INDEX)
-  );
-
-  assert.equal(session.seekTarget ?? null, null);
-  assert.equal(session.seekSettleTimer ?? null, null);
-});
-
-test("a request cannot move the viewer's position backwards", async (t) => {
-  const { manager, session, dirPath } = await sessionWithRunAt373();
-  t.after(async () => {
-    await tidy(manager, session, dirPath);
-  });
-
-  manager.viewerRequests.requestSeek(SESSION_ID, 2083.4, "viewer-1");
-  await manager.serving.getFileStream(SESSION_ID, fmp4Format.segmentFileName(BEHIND_INDEX));
-
-  assert.ok(
-    Math.abs((manager.viewers.get("viewer-1")?.positionSeconds() ?? -1) - 2083.4) < 1,
-    "a stale request must not rewrite what the viewer said about themselves"
-  );
-});

package/test/startup-readings.test.js

@@ -1,124 +0,0 @@
-/**
- * @file What this host must have measured before the first viewer arrives.
- *
- * The quality offer, the number of encoders and every decision about moving one
- * are arithmetic over four figures: how fast this host encodes, how fast it
- * decodes, what a second job costs it, and what starting and stopping an
- * encoder cost. A figure nobody measured is reported as zero, and zero does not
- * read as "unknown" — it reads as "free" or "instant", and the arithmetic then
- * answers confidently and wrongly.
- *
- * Two gaps this pins, both found 2026-09-10:
- *
- * 1. three of the four ran only when the chosen encoder was SOFTWARE, and two
- *    of those three are not about the encoder at all — a host with a GPU
- *    decodes in software just the same, and what a second job costs is a
- *    property of the machine. A GPU host measured none of them;
- * 2. starting and stopping were learned only from runs that had already ENDED,
- *    so at a cold open both were zero and moving an encoder was free. Field
- *    2026-09-08: an encoder moved between two adjacent numbers every half
- *    second and produced nothing.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
-import { NvencEncoder } from "../services/encode/NvencEncoder.js";
-import { QsvEncoder } from "../services/encode/QsvEncoder.js";
-import { VaapiEncoder } from "../services/encode/VaapiEncoder.js";
-import { V4l2m2mEncoder } from "../services/encode/V4l2m2mEncoder.js";
-import { RunCosts } from "../services/encode/run-costs.js";
-
-const HERE = path.dirname(fileURLToPath(import.meta.url));
-
-test("every encoder kind can say how to measure itself", () => {
-  const kinds = [
-    new SoftwareEncoder(),
-    new NvencEncoder(),
-    new QsvEncoder(),
-    new VaapiEncoder("/dev/dri/renderD128"),
-    new V4l2m2mEncoder()
-  ];
-  for (const encoder of kinds) {
-    const args = encoder.benchmarkArgs(null);
-    assert.ok(Array.isArray(args) && args.length >= 2, `${encoder.name} says nothing`);
-    assert.ok(args.includes("-c:v"), `${encoder.name} does not name a codec`);
-    assert.ok(
-      args.some((arg) => String(arg).includes(encoder.name)),
-      `${encoder.name} does not name itself`
-    );
-  }
-});
-
-test("a kind with a ladder is measured at every rung of it", () => {
-  for (const encoder of [new SoftwareEncoder(), new NvencEncoder(), new QsvEncoder()]) {
-    const ladder = encoder.speedLadder;
-    assert.ok(ladder.values.length > 1, `${encoder.name} declares no ladder to walk`);
-    const rungs = ladder.values.map((rung) => encoder.benchmarkArgs(rung).join(" "));
-    assert.equal(new Set(rungs).size, ladder.values.length, `${encoder.name} gives the same arguments for different rungs`);
-  }
-});
-
-test("nothing about the machine is asked only of a software encoder", () => {
-  // Decoding and contention are properties of the host. Asked only where the
-  // encoder was software, a host with a GPU had neither, and the quality offer
-  // could not price a re-encode nor a second process.
-  const server = readFileSync(path.join(HERE, "..", "server.js"), "utf8");
-  for (const call of ["benchmarkDecodeCost", "benchmarkContention"]) {
-    const at = server.indexOf(call);
-    assert.ok(at > 0, `${call} is not called at startup at all`);
-    const before = server.slice(Math.max(0, at - 200), at);
-    assert.equal(
-      before.includes('kind === "software"'),
-      false,
-      `${call} is still gated on the encoder being software`
-    );
-  }
-});
-
-test("the calibration is given the encoder that will actually run, and software beside it", () => {
-  const server = readFileSync(path.join(HERE, "..", "server.js"), "utf8");
-  assert.match(
-    server,
-    /calibrateEncoder\(\{[^}]*encoder: videoEncoder/,
-    "the calibration is not told which encoder to measure"
-  );
-  assert.match(
-    server,
-    /calibrateEncoder\(\{[^}]*encoder: softwareDescriptor\(\)/,
-    "software, which a failing device falls back to, is not calibrated"
-  );
-});
-
-test("a start and a stop are measured before any viewer, and reach the plan", () => {
-  const server = readFileSync(path.join(HERE, "..", "server.js"), "utf8");
-  assert.match(server, /await measureStartAndStop\(/, "nothing measures a start at startup");
-  assert.match(server, /\n    startStopCost,/, "the reading never reaches the wiring of the encoding");
-
-  const manager = readFileSync(path.join(HERE, "..", "services", "server", "wire-outputs.js"), "utf8");
-  assert.match(
-    manager,
-    /noteStartupCosts\(startStopCost\)/,
-    "the reading never reaches the encoding orchestrator"
-  );
-});
-
-test("with a startup reading, a cold plan is not told that starting is free", () => {
-  const costs = new RunCosts();
-  assert.equal(costs.seconds().firstByteWaitSec, 0, "nothing measured yet is nothing");
-
-  costs.noteStartup({ firstByteWaitSec: 0.68, killCostSec: 0.02 });
-  const cold = costs.seconds();
-  assert.equal(cold.firstByteWaitSec, 0.68, "the startup reading is not used");
-  assert.equal(cold.killCostSec, 0.02);
-
-  // A real run replaces it: the startup figure is where the plan starts from,
-  // not where it stays.
-  costs.note({ firstOutputMs: 4000, dyingMs: 300 });
-  const warm = costs.seconds();
-  assert.equal(warm.firstByteWaitSec, 4);
-  assert.equal(warm.killCostSec, 0.3);
-});

package/test/stream-route.test.js

@@ -1,237 +0,0 @@
-/**
- * @file What `/stream` does with a HEAD request.
- *
- * Fastify answers HEAD from the GET handler, so without an explicit branch a
- * HEAD started a read of the entire file. Node discards the body, but the read
- * itself runs on and the response never completes, which blocks the next
- * request on that keep-alive connection. The keyframe index asks for the file
- * size with exactly such a HEAD before every transcode session.
- */
-
-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 { handleStreamGet } from "../routes/stream/get.js";
-import { WorkerTorrentPool } from "../services/torrent/worker/pool-adapter.js";
-
-/**
- * Minimal stand-ins for the parts of Fastify and the pool this route touches.
- *
- * @param {{ method: string, range?: string }} request
- * @returns {{ req: object, reply: object, sent: object, opened: string[], state: object }}
- */
-function harness({ method, range }) {
-  const opened = [];
-  const state = { prioritized: [] };
-
-  const sent = { code: 200, headers: {}, body: undefined, called: false };
-  const reply = {
-    code(value) {
-      sent.code = value;
-      return reply;
-    },
-    header(name, value) {
-      sent.headers[name.toLowerCase()] = value;
-      return reply;
-    },
-    send(body) {
-      sent.called = true;
-      sent.body = body;
-      return reply;
-    },
-    hijack() {
-      sent.hijacked = true;
-    },
-    raw: {
-      // `bindRelease` listens here; HEAD writes its response here.
-      once() {},
-      writeHead(code, headers) {
-        sent.code = code;
-        for (const [name, value] of Object.entries(headers)) {
-          sent.headers[name.toLowerCase()] = value;
-        }
-      },
-      end() {
-        sent.called = true;
-      }
-    }
-  };
-
-  const file = {
-    name: "movie.mkv",
-    length: 5_869_669_065,
-    createReadStream(options = {}) {
-      opened.push(`${options.start ?? 0}-${options.end ?? "end"}`);
-      return { on() {} };
-    }
-  };
-
-  const torrentPool = {
-    async getTorrent() {
-      return { files: [file], sourceKey: "key" };
-    },
-    prioritizeByteRange(_torrent, fileIndex, byteStart, _windowBytes, options) {
-      state.prioritized.push({ byteStart, wholeFileRead: options?.wholeFileRead === true });
-    }
-  };
-
-  const req = {
-    method,
-    query: { sourceType: "magnet", source: "magnet:?xt=urn:btih:abc", fileIndex: "0" },
-    headers: range ? { range } : {},
-    raw: { once() {} }
-  };
-
-  return { req, reply, sent, opened, state, deps: { sourceRegistry: { get: () => null }, torrentPool } };
-}
-
-test("HEAD reports the size without opening a read", async () => {
-  const { req, reply, sent, opened, state, deps } = harness({ method: "HEAD" });
-
-  await handleStreamGet(req, reply, deps);
-
-  assert.deepEqual(opened, [], "HEAD started a read of the file");
-  assert.deepEqual(state.prioritized, [], "HEAD asked the swarm for a read it never made");
-  // The real size, not the zero Fastify substitutes for an empty payload — the
-  // keyframe index reads this header and treats 0 as "no index".
-  assert.equal(sent.headers["content-length"], "5869669065");
-  assert.equal(sent.headers["accept-ranges"], "bytes");
-  assert.equal(sent.called, true, "HEAD never completed its response");
-  assert.equal(sent.body, undefined, "HEAD answered with a body");
-});
-
-test("GET still streams the bytes", async () => {
-  const { req, reply, sent, opened, deps } = harness({ method: "GET" });
-
-  await handleStreamGet(req, reply, deps);
-
-  assert.equal(opened.length, 1, "GET did not open a read");
-  assert.equal(sent.headers["content-length"], "5869669065");
-});
-
-test("GET with a range streams only that range", async () => {
-  const { req, reply, sent, opened, deps } = harness({ method: "GET", range: "bytes=100-199" });
-
-  await handleStreamGet(req, reply, deps);
-
-  assert.deepEqual(opened, ["100-199"]);
-  assert.equal(sent.code, 206);
-  assert.equal(sent.headers["content-range"], "bytes 100-199/5869669065");
-  assert.equal(sent.headers["content-length"], "100");
-});
-
-// A request with no byte range says nothing about where the viewer is: ffmpeg
-// opens its input with a plain GET and abandons it the moment it seeks, and the
-// keyframe index and the codec probe do the same — four such reads around every
-// encoder restart. Reported as ordinary reads at offset 0, they undid the seek
-// that had just happened and sent the swarm walking the file from its first
-// missing piece; a seek to 89.1% of a 4.7 GB film downloaded 2.47 GB that way.
-test("a range-less GET is reported as a whole-file read", async () => {
-  const { req, reply, state, deps } = harness({ method: "GET" });
-
-  await handleStreamGet(req, reply, deps);
-
-  assert.deepEqual(state.prioritized, [{ byteStart: 0, wholeFileRead: true }]);
-});
-
-test("a ranged GET is reported as a real read position", async () => {
-  const { req, reply, state, deps } = harness({ method: "GET", range: "bytes=4390000000-" });
-
-  await handleStreamGet(req, reply, deps);
-
-  assert.deepEqual(state.prioritized, [{ byteStart: 4_390_000_000, wholeFileRead: false }]);
-});
-
-test("a file downloaded whole is served from disk without touching the torrent", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "stream-whole-"));
-  const where = path.join(root, "0");
-  const bytes = Buffer.from("a film that is a file now", "utf8");
-  await fs.writeFile(where, bytes);
-  try {
-    const { req, reply, sent, deps } = harness({ method: "GET", range: "bytes=2-6" });
-    let asked = false;
-    const wholeFiles = new Map([
-      ["abc/0", { path: where, length: bytes.length, name: "film.mkv" }]
-    ]);
-    // Supply the worker boundary explicitly: no Worker or torrent is started.
-    deps.torrentPool = new WorkerTorrentPool({}, {
-      wholeFiles,
-      async getTorrent() {
-        asked = true;
-        throw new Error("the worker must not be asked for completed bytes");
-      }
-    });
-    assert.equal(deps.torrentPool.wholeFiles, wholeFiles);
-    // The source key IS the identity — `torrent:<infohash>` — and it is all the
-    // route needs to find the file.
-    deps.sourceRegistry = { get: () => ({ sourceType: "torrent", source: "magnet:?xt=urn:btih:abc" }) };
-    req.query = { sourceKey: "torrent:abc", fileIndex: "0" };
-
-    await handleStreamGet(req, reply, deps);
-
-    assert.equal(asked, false, "the torrent was asked for");
-    assert.equal(sent.code, 206);
-    assert.equal(sent.headers["content-range"], `bytes 2-6/${bytes.length}`);
-    assert.equal(sent.headers["content-length"], "5");
-    const chunks = [];
-    for await (const chunk of sent.body) chunks.push(chunk);
-    assert.deepEqual(Buffer.concat(chunks), bytes.subarray(2, 7));
-  } finally {
-    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});
-
-test("an announced file removed before opening falls back to the torrent before headers", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "stream-removed-"));
-  try {
-    const { req, reply, sent, opened, deps } = harness({ method: "GET", range: "bytes=2-6" });
-    deps.torrentPool.wholeFiles = new Map([
-      ["abc/0", { path: path.join(root, "missing"), length: 10, name: "gone.mkv" }]
-    ]);
-    deps.sourceRegistry = { get: () => ({ sourceType: "magnet", source: "magnet:?xt=urn:btih:abc" }) };
-    req.query = { sourceKey: "torrent:abc", fileIndex: "0" };
-    await handleStreamGet(req, reply, deps);
-    assert.deepEqual(opened, ["2-6"]);
-    assert.equal(deps.torrentPool.wholeFiles.size, 0);
-    assert.equal(sent.headers["content-range"], "bytes 2-6/5869669065");
-  } finally {
-    await fs.rm(root, { recursive: true, force: true });
-  }
-});
-
-test("a file this proxy does not have whole still goes to the torrent", async () => {
-  const { req, reply, state, deps } = harness({ method: "GET", range: "bytes=0-99" });
-  deps.torrentPool.wholeFiles = new Map([["other/7", { path: "/nowhere", length: 1, name: "x" }]]);
-  await handleStreamGet(req, reply, deps);
-  assert.equal(state.prioritized.length, 1, "the ordinary path was not taken");
-});
-
-test("every wait of an encoder's input read is marked for the run its URL names", async () => {
-  // The run's processing speed is read over its own working time; the time its
-  // input waits for the swarm is what this marks (RunClock).
-  const { req, reply, deps } = harness({ method: "GET", range: "bytes=0-5" });
-  const { files: [file] } = await deps.torrentPool.getTorrent();
-  const pieces = [Buffer.from("abc"), Buffer.from("def")];
-  file.createFragmentReader = () => ({
-    cancel() {},
-    async *[Symbol.asyncIterator]() {
-      for (const bytes of pieces) {
-        yield { bytes, release() {} };
-      }
-    }
-  });
-  reply.raw.write = (_bytes, done) => done();
-  reply.raw.writableEnded = false;
-  reply.raw.destroyed = false;
-  req.query.session = "output-1";
-  req.query.run = "7";
-  const marks = [];
-  deps.noteInputWaiting = (runToken, waiting) => marks.push([runToken, waiting]);
-
-  await handleStreamGet(req, reply, deps);
-
-  assert.deepEqual(marks, [[7, true], [7, false], [7, true], [7, false], [7, true], [7, false]],
-    "a wait before each fragment and one before the end, each closed");
-});