@torrent-tv/proxy 2.89.17 → 2.89.19

package/test/encode-run-state.test.js

@@ -1,314 +0,0 @@
-/**
- * @file The encoder-run table, exercised as a graph.
- *
- * These are properties of the specification, not of any run: no ffmpeg, no
- * torrent, no filesystem, no clock. What they buy is the thing five field
- * failures in a row were — an empty cell — being visible before a release
- * rather than after one.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  ABSENT_EDGE_INVARIANTS,
-  ENCODE_RUN_EVENT,
-  ENCODE_RUN_STATE,
-  ENCODE_RUN_SUPERSTATE,
-  INITIAL_RUN_STATE,
-  answerForMissingSegment,
-  declaredContainment,
-  declaredEdges,
-  isInputBeingRead,
-  isWithin,
-  mayRestart,
-  nextState,
-  processCanBeSignalled,
-  wireState
-} from "../services/encode/encode-run-state.js";
-
-const ALL_STATES = Object.values(ENCODE_RUN_STATE);
-const ALL_EVENTS = Object.values(ENCODE_RUN_EVENT);
-
-// ------------------------------------------------------------ graph discipline
-
-test("the relation is deterministic", () => {
-  for (const state of ALL_STATES) {
-    for (const event of ALL_EVENTS) {
-      assert.equal(nextState(state, event), nextState(state, event));
-    }
-  }
-});
-
-test("every pair is answered, and nothing throws", () => {
-  for (const state of ALL_STATES) {
-    for (const event of ALL_EVENTS) {
-      const target = nextState(state, event);
-      assert.ok(
-        target === null || ALL_STATES.includes(target),
-        `${state} + ${event} answered ${String(target)}, which is neither a state nor "ignored"`
-      );
-    }
-  }
-  // Nonsense in, "ignored" out — never an exception. The machine this pattern
-  // replaces threw from inside an event handler, which left the caller's work
-  // half applied.
-  assert.equal(nextState("NOT_A_STATE", ENCODE_RUN_EVENT.SPAWNED), null);
-  assert.equal(nextState(ENCODE_RUN_STATE.IDLE, "NOT_AN_EVENT"), null);
-  assert.equal(nextState(undefined, undefined), null);
-});
-
-test("one target per state and event — no pair is declared twice", () => {
-  const seen = new Set();
-  for (const edge of declaredEdges()) {
-    const pair = `${edge.from}+${edge.event}`;
-    assert.ok(!seen.has(pair), `${pair} is declared more than once`);
-    seen.add(pair);
-  }
-});
-
-test("the table cannot be edited through what it hands out", () => {
-  const [first] = declaredEdges();
-  const mutated = declaredEdges();
-  mutated[0].to = "TAMPERED";
-  assert.equal(declaredEdges()[0].to, first.to);
-  const containment = declaredContainment();
-  containment[0].parent = "TAMPERED";
-  assert.notEqual(declaredContainment()[0].parent, "TAMPERED");
-});
-
-test("every state is reachable from where a run begins", () => {
-  const seen = new Set([INITIAL_RUN_STATE]);
-  const queue = [INITIAL_RUN_STATE];
-  while (queue.length > 0) {
-    const state = queue.shift();
-    for (const event of ALL_EVENTS) {
-      const target = nextState(state, event);
-      if (target && !seen.has(target)) {
-        seen.add(target);
-        queue.push(target);
-      }
-    }
-  }
-  assert.deepEqual(
-    ALL_STATES.filter((state) => !seen.has(state)),
-    [],
-    "a state no sequence of events can enter is either dead code or a missing edge"
-  );
-});
-
-test("no state is a dead end — every one can start a run again", () => {
-  for (const state of ALL_STATES) {
-    assert.equal(
-      nextState(state, ENCODE_RUN_EVENT.SPAWNED),
-      ENCODE_RUN_STATE.STARTING,
-      `${state} must be able to spawn a run: a session that cannot restart answers 500 for ever, ` +
-        "which is what the roadmap calls the empty cell"
-    );
-  }
-});
-
-test("the two edges that lead back to their own state are deliberate", () => {
-  const selfEdges = [];
-  for (const state of ALL_STATES) {
-    for (const event of ALL_EVENTS) {
-      if (nextState(state, event) === state) {
-        selfEdges.push(`${state} + ${event}`);
-      }
-    }
-  }
-  assert.deepEqual(
-    selfEdges.sort(),
-    [
-      // A new run spawned while one was starting: the state is right already,
-      // and nothing in the caller re-runs on entry — the spawn has happened.
-      `${ENCODE_RUN_STATE.STARTING} + ${ENCODE_RUN_EVENT.SPAWNED}`,
-      // Suspending what is suspended. The caller returns early before signalling,
-      // so this is the answer to an event that cannot actually be raised twice.
-      `${ENCODE_RUN_STATE.SUSPENDED} + ${ENCODE_RUN_EVENT.SUSPEND_ORDERED}`
-    ].sort(),
-    "an edge that leads back to its own state must be argued for, not acquired"
-  );
-});
-
-test("the table stays small enough to hold in the head", () => {
-  assert.ok(
-    declaredEdges().length <= 12,
-    `${declaredEdges().length} declared edges — a near-complete digraph asserts nothing`
-  );
-});
-
-// ------------------------------------------------------- what must not happen
-
-test("the absent edges are absent", () => {
-  for (const invariant of ABSENT_EDGE_INVARIANTS) {
-    assert.notEqual(
-      nextState(invariant.from, invariant.event),
-      invariant.mustNotReach,
-      `${invariant.from} + ${invariant.event} reached ${invariant.mustNotReach}: ${invariant.because}`
-    );
-  }
-});
-
-test("an event that means nothing here is ignored, not obeyed", () => {
-  assert.equal(nextState(ENCODE_RUN_STATE.IDLE, ENCODE_RUN_EVENT.FIRST_SEGMENT), null);
-  assert.equal(nextState(ENCODE_RUN_STATE.IDLE, ENCODE_RUN_EVENT.EXITED_COMPLETE), null);
-  assert.equal(nextState(ENCODE_RUN_STATE.STOPPED, ENCODE_RUN_EVENT.RESUME_ORDERED), null);
-  assert.equal(nextState(ENCODE_RUN_STATE.ENDED_COMPLETE, ENCODE_RUN_EVENT.SUSPEND_ORDERED), null);
-  assert.equal(nextState(ENCODE_RUN_STATE.PRODUCING, ENCODE_RUN_EVENT.RETRY_DUE), null);
-});
-
-// ------------------------------------------------------------------ hierarchy
-
-test("an edge on a superstate reaches every state inside it", () => {
-  const alive = ALL_STATES.filter((state) => isWithin(state, ENCODE_RUN_SUPERSTATE.ALIVE));
-  assert.deepEqual(
-    alive.sort(),
-    [ENCODE_RUN_STATE.PRODUCING, ENCODE_RUN_STATE.STARTING, ENCODE_RUN_STATE.SUSPENDED].sort()
-  );
-  for (const state of alive) {
-    assert.equal(nextState(state, ENCODE_RUN_EVENT.EXITED_FAILED), ENCODE_RUN_STATE.ENDED_FAILED);
-    assert.equal(nextState(state, ENCODE_RUN_EVENT.EXITED_INPUT_LOST), ENCODE_RUN_STATE.RETRY_WAIT);
-    assert.equal(nextState(state, ENCODE_RUN_EVENT.STOP_ORDERED), ENCODE_RUN_STATE.STOPPED);
-  }
-  const working = ALL_STATES.filter((state) => isWithin(state, ENCODE_RUN_SUPERSTATE.WORKING));
-  assert.deepEqual(working.sort(), [...alive, ENCODE_RUN_STATE.RETRY_WAIT].sort());
-  for (const state of ALL_STATES) {
-    assert.ok(isWithin(state, ENCODE_RUN_SUPERSTATE.RUN), `${state} must sit inside RUN`);
-  }
-});
-
-test("a state's own edge wins over the one it inherits", () => {
-  // STARTING inherits SPAWNED from RUN and declares FIRST_SEGMENT itself; the
-  // walk must stop at the first hit rather than continue up the chain.
-  assert.equal(
-    nextState(ENCODE_RUN_STATE.STARTING, ENCODE_RUN_EVENT.FIRST_SEGMENT),
-    ENCODE_RUN_STATE.PRODUCING
-  );
-  assert.equal(
-    nextState(ENCODE_RUN_STATE.SUSPENDED, ENCODE_RUN_EVENT.RESUME_ORDERED),
-    ENCODE_RUN_STATE.PRODUCING
-  );
-});
-
-// -------------------------------------------------------------------- outputs
-
-test("only a live run reads its input", () => {
-  assert.equal(isInputBeingRead(ENCODE_RUN_STATE.STARTING), true);
-  assert.equal(isInputBeingRead(ENCODE_RUN_STATE.PRODUCING), true);
-  assert.equal(
-    isInputBeingRead(ENCODE_RUN_STATE.SUSPENDED),
-    false,
-    "a suspended encoder reads nothing — the reader's window is then satisfied, WebTorrent drops " +
-      "the selection, and the download dies with the swarm open (eleven minutes, 2026-08-05)"
-  );
-  for (const state of [
-    ENCODE_RUN_STATE.IDLE,
-    ENCODE_RUN_STATE.RETRY_WAIT,
-    ENCODE_RUN_STATE.STOPPED,
-    ENCODE_RUN_STATE.ENDED_COMPLETE,
-    ENCODE_RUN_STATE.ENDED_FAILED
-  ]) {
-    assert.equal(isInputBeingRead(state), false, `${state} has no process to read anything`);
-  }
-});
-
-test("a signal may be sent only where a process exists", () => {
-  for (const state of ALL_STATES) {
-    assert.equal(
-      processCanBeSignalled(state),
-      isWithin(state, ENCODE_RUN_SUPERSTATE.ALIVE),
-      `${state} answered the wrong thing about whether it holds a process`
-    );
-  }
-});
-
-test("a missing segment is held everywhere except a terminal failure", () => {
-  for (const state of ALL_STATES) {
-    assert.equal(
-      answerForMissingSegment(state),
-      state === ENCODE_RUN_STATE.ENDED_FAILED ? "fail" : "hold",
-      `${state} must give one answer for a missing segment, not one per call site`
-    );
-  }
-});
-
-test("the wire state is a function of the run state alone", () => {
-  assert.equal(wireState(ENCODE_RUN_STATE.IDLE), "starting");
-  assert.equal(wireState(ENCODE_RUN_STATE.RETRY_WAIT), "starting");
-  assert.equal(wireState(ENCODE_RUN_STATE.STARTING), "running");
-  assert.equal(wireState(ENCODE_RUN_STATE.PRODUCING), "running");
-  assert.equal(wireState(ENCODE_RUN_STATE.SUSPENDED), "running");
-  assert.equal(wireState(ENCODE_RUN_STATE.STOPPED), "running");
-  assert.equal(wireState(ENCODE_RUN_STATE.ENDED_COMPLETE), "ready");
-  assert.equal(wireState(ENCODE_RUN_STATE.ENDED_FAILED), "failed");
-  for (const state of ALL_STATES) {
-    assert.ok(
-      ["starting", "running", "ready", "failed"].includes(wireState(state)),
-      `${state} produced a wire state the browser has never been told about`
-    );
-  }
-});
-
-test("only a finished file refuses to be repositioned", () => {
-  for (const state of ALL_STATES) {
-    assert.equal(mayRestart(state), state !== ENCODE_RUN_STATE.ENDED_COMPLETE);
-  }
-});
-
-// ------------------------------------------------- the failures, by their name
-
-test("the sawtooth of 2.9.93 is not expressible", () => {
-  // Any segment request released a suspended encoder, and the run drifted from
-  // 155 s to 922 s ahead of the viewer in three minutes. Resuming is an output
-  // of how far ahead the run is, computed by the caller — never an edge hung on
-  // a request arriving.
-  assert.equal(nextState(ENCODE_RUN_STATE.SUSPENDED, ENCODE_RUN_EVENT.FIRST_SEGMENT), null);
-  assert.equal(
-    nextState(ENCODE_RUN_STATE.SUSPENDED, ENCODE_RUN_EVENT.RESUME_ORDERED),
-    ENCODE_RUN_STATE.PRODUCING
-  );
-});
-
-test("a dead run cannot be mistaken for one that is covering the seek", () => {
-  // the process handle pointed at a corpse, so every later seek was waved through
-  // as "already covered by the running encode" and the session answered 500 for
-  // as long as the viewer kept trying.
-  assert.equal(processCanBeSignalled(ENCODE_RUN_STATE.ENDED_FAILED), false);
-  assert.equal(isInputBeingRead(ENCODE_RUN_STATE.ENDED_FAILED), false);
-  assert.equal(
-    nextState(ENCODE_RUN_STATE.ENDED_FAILED, ENCODE_RUN_EVENT.SPAWNED),
-    ENCODE_RUN_STATE.STARTING,
-    "and the way out of it is a spawn — the edge whose absence is the empty cell"
-  );
-});
-
-test("a rung the viewer left is not the same as a run that has not started", () => {
-  // Both are "no process" in the field set this replaces, and they call for
-  // opposite answers: one must not be revived by its own held requests, the
-  // other is waiting to be spawned.
-  assert.notEqual(ENCODE_RUN_STATE.STOPPED, ENCODE_RUN_STATE.IDLE);
-  assert.equal(nextState(ENCODE_RUN_STATE.STOPPED, ENCODE_RUN_EVENT.RESUME_ORDERED), null);
-  assert.equal(nextState(ENCODE_RUN_STATE.IDLE, ENCODE_RUN_EVENT.SPAWNED), ENCODE_RUN_STATE.STARTING);
-});
-
-test("an input that dried up is not a finished file", () => {
-  // ffmpeg exits 0 for both, and the difference had to be recovered by
-  // comparing what was produced against the published playlist (2.9.104).
-  assert.equal(
-    nextState(ENCODE_RUN_STATE.PRODUCING, ENCODE_RUN_EVENT.EXITED_SHORT),
-    ENCODE_RUN_STATE.ENDED_FAILED
-  );
-  assert.equal(
-    nextState(ENCODE_RUN_STATE.PRODUCING, ENCODE_RUN_EVENT.EXITED_COMPLETE),
-    ENCODE_RUN_STATE.ENDED_COMPLETE
-  );
-});
-
-test("losing the input holds the viewer's requests instead of failing them", () => {
-  const afterLoss = nextState(ENCODE_RUN_STATE.PRODUCING, ENCODE_RUN_EVENT.EXITED_INPUT_LOST);
-  assert.equal(afterLoss, ENCODE_RUN_STATE.RETRY_WAIT);
-  assert.equal(answerForMissingSegment(afterLoss), "hold");
-  assert.equal(wireState(afterLoss), "starting");
-  assert.equal(nextState(afterLoss, ENCODE_RUN_EVENT.RETRY_DUE), ENCODE_RUN_STATE.IDLE);
-});

package/test/encode-run.test.js

@@ -1,248 +0,0 @@
-/**
- * @file One encoder's lifetime: the stretch it was given, where it got to, and
- * whether its ending was the normal one.
- *
- * The process is injected, so none of this needs ffmpeg. What is checked is the
- * accounting the user asked for on 2026-09-04: exactly one ending is normal,
- * every other one says why, and none of them goes unrecorded.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { EventEmitter } from "node:events";
-import { EncodeRun } from "../services/encode/EncodeRun.js";
-import { ENCODE_EXIT } from "../services/encode/encode-exit.js";
-import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
-import { fakeProcess, silentLogger } from "./helpers/encode-run.js";
-
-/**
- * A process that does nothing until the test says what became of it.
- */
-class FakeProcess extends EventEmitter {
-  constructor() {
-    super();
-    this.pid = 4242;
-    this.signals = [];
-  }
-
-  kill(signal) {
-    this.signals.push(signal);
-  }
-
-  exitWith(code, signal = null) {
-    this.emit("exit", code, signal);
-    this.emit("close", code, signal);
-  }
-}
-
-/**
- * @param {Partial<{from:number,to:number}>} [span]
- */
-function makeRun(span = {}) {
-  const lines = [];
-  const ends = [];
-  const process_ = new FakeProcess();
-  const run = new EncodeRun({
-    address: "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/enc/libx264/854x480@24/veryfast/none/vbv=-",
-    encoder: new SoftwareEncoder(),
-    from: span.from ?? 10,
-    to: span.to ?? 14,
-    buildArgs: () => ["-i", "in", "out"],
-    spawn: () => process_,
-    logger: {
-      info: (line) => lines.push(["info", line]),
-      warn: (line) => lines.push(["warn", line])
-    },
-    now: () => 1000,
-    onEnded: (ended) => ends.push(ended),
-    because: "nobody is making #10 and a viewer is waiting for it"
-  });
-  return { run, process: process_, lines, ends };
-}
-
-test("a start says why it is starting and with what", () => {
-  // The argument list alone cannot say whether this was a first open, a seek, a
-  // quality step or a move off covered material — and with several runs at once
-  // that is the only way to tell one start from another.
-  const { lines } = makeRun();
-  const [level, line] = lines[0];
-  assert.equal(level, "info");
-  // A run is named by what it produces: the stretch it was given, on the output
-  // it makes segments of. No other live run of that output can hold it.
-  assert.match(line, /encode-run #10\.\.#14 of torrent:abc:/);
-  assert.match(line, /nobody is making #10/);
-  assert.match(line, /ffmpeg -i in out/);
-});
-
-test("its head is the next number it will make, and moves as it makes them", () => {
-  const { run } = makeRun();
-  assert.equal(run.head, 10);
-  run.noteProduced(10);
-  run.noteProduced(11);
-  assert.equal(run.head, 12);
-  assert.equal(run.reached, 11);
-});
-
-test("reaching the end of its stretch and exiting is the one normal ending", () => {
-  const { run, process, ends, lines } = makeRun({ from: 10, to: 12 });
-  for (const index of [10, 11, 12]) {
-    run.noteProduced(index);
-  }
-  process.exitWith(0, null);
-  assert.equal(ends.length, 1);
-  assert.equal(ends[0].ending, ENCODE_EXIT.COMPLETE);
-  assert.equal(ends[0].normal, true);
-  assert.equal(lines.at(-1)[0], "info", "a normal ending is not a warning");
-});
-
-test("exiting cleanly short of its stretch is abnormal and says where it stopped", () => {
-  // ffmpeg exits zero both at the end of a file and when its input stops
-  // producing bytes; over a torrent the two look identical to it.
-  const { run, process, ends } = makeRun({ from: 10, to: 14 });
-  run.noteProduced(10);
-  run.noteProduced(11);
-  process.exitWith(0, null);
-  assert.equal(ends[0].ending, ENCODE_EXIT.SHORT);
-  assert.equal(ends[0].normal, false);
-  assert.equal(ends[0].reached, 11);
-  assert.match(ends[0].because, /#11 of #14/);
-});
-
-test("a non-zero exit is a failure carrying its code", () => {
-  const { process, ends, lines } = makeRun();
-  process.exitWith(255, null);
-  assert.equal(ends[0].ending, ENCODE_EXIT.FAILED);
-  assert.equal(ends[0].code, 255);
-  assert.equal(lines.at(-1)[0], "warn");
-});
-
-test("our own kill is abnormal too, and carries the reason we gave", () => {
-  // Hiding it among the normal endings would make a count of abnormal endings
-  // useless, which is the whole point of counting them.
-  const { run, process, ends } = makeRun();
-  run.stop("moved past 20 segments that are already made");
-  assert.deepEqual(process.signals, ["SIGTERM"]);
-  process.exitWith(null, "SIGTERM");
-  assert.equal(ends[0].ending, ENCODE_EXIT.STOPPED);
-  assert.equal(ends[0].normal, false);
-  assert.match(ends[0].because, /already made/);
-});
-
-test("an ending reports the stretch, how far it got and how long it lived", () => {
-  const { run, process, ends } = makeRun({ from: 10, to: 14 });
-  run.noteProduced(10);
-  process.exitWith(1, null);
-  const ended = ends[0];
-  assert.equal(ended.from, 10);
-  assert.equal(ended.to, 14);
-  assert.equal(ended.reached, 10);
-  assert.equal(ended.livedMs, 0, "the clock is injected, so this is exact");
-  assert.equal(ended.address.includes("854x480"), true);
-});
-
-test("a process that could not be started ends like any other failure", () => {
-  const { process, ends } = makeRun();
-  process.emit("error", new Error("ENOENT"));
-  assert.equal(ends[0].ending, ENCODE_EXIT.FAILED);
-  assert.match(ends[0].because, /ENOENT/);
-});
-
-test("its speed is film made between closed pieces over its own working time", () => {
-  const clock = { at: 1000 };
-  const process_ = new FakeProcess();
-  process_.stdout = new EventEmitter();
-  process_.stdio = [null, process_.stdout, null, new EventEmitter()];
-  const readings = [];
-  const run = new EncodeRun({
-    address: "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy",
-    encoder: new SoftwareEncoder(),
-    from: 0,
-    to: 9,
-    buildArgs: () => [],
-    spawn: () => process_,
-    logger: { info() {}, warn() {} },
-    now: () => clock.at,
-    onSpeedMeasured: (reading) => readings.push(reading)
-  });
-  assert.equal(run.speedX, 0, "nothing measured yet");
-  const report = (seconds) => process_.stdout.emit("data", `out_time_ms=${seconds * 1_000_000}\n`);
-  const closed = (name) => process_.stdio[3].emit("data", `${name}\n`);
-  report(0);
-  closed("a");
-  clock.at += 1000;
-  report(4);
-  closed("b"); // "a" is published: the reckoning starts here
-  assert.equal(run.speedX, 0, "one closed piece measures nothing");
-  // The input waits for the swarm for 30 s; that is not the run's work.
-  run.inputWaitBegins();
-  clock.at += 30_000;
-  run.inputWaitEnds();
-  clock.at += 2000;
-  report(12);
-  closed("c"); // "b" is published
-  assert.equal(run.speedX, 4, "8 s of film over 2 s of work");
-  assert.deepEqual(readings, [{ speed: 4, at: 34_000 }], "told once, with when");
-});
-
-test("a segment number behind its own start is not its to claim", () => {
-  const { run } = makeRun({ from: 10, to: 14 });
-  run.noteProduced(4);
-  assert.deepEqual(run.produced, []);
-});
-
-test("CSV closure times survive split channel chunks and a zero first-entry start", () => {
-  const process_ = new FakeProcess();
-  process_.stdio = [null, null, null, new EventEmitter()];
-  const closed = [];
-  const run = new EncodeRun({
-    address: "audio", encoder: new SoftwareEncoder(), from: 13, to: 14,
-    buildArgs: () => [], spawn: () => process_, logger: { info() {}, warn() {} },
-    indexOfName: name => Number(name.match(/(\d+)\.mp4$/)[1]),
-    onClosed: (name, timing) => { closed.push({ name, timing }); return name; }
-  });
-  process_.stdio[3].emit("data", "making-0-00013.mp4,0.000000,81.364");
-  process_.stdio[3].emit("data", "000\nmaking-0-00014.mp4,81.364000,91.800000\n");
-  process_.exitWith(0);
-  assert.equal(run.reached, 14);
-  assert.deepEqual(closed.map(({ timing }) => timing), [
-    { endMicros: 81_364_000n },
-    { endMicros: 91_800_000n }
-  ]);
-});
-
-test("a refused publication stops its claim and ends as a publication failure", () => {
-  const process_ = new FakeProcess();
-  process_.stdio = [null, null, null, new EventEmitter()];
-  const ends = [];
-  const run = new EncodeRun({
-    address: "audio", encoder: new SoftwareEncoder(), from: 13, to: 14,
-    buildArgs: () => [], spawn: () => process_, logger: { info() {}, warn() {} },
-    onClosed: () => { throw new Error("piece 13 is incomplete"); },
-    onEnded: ended => ends.push(ended)
-  });
-  process_.stdio[3].emit("data", "making-0-00013.mp4,71.55,71.56\nmaking-0-00014.mp4,71.56,91.8\n");
-  assert.deepEqual(process_.signals, ["SIGTERM"]);
-  process_.exitWith(0);
-  assert.equal(run.isAlive, false);
-  assert.equal(ends[0].ending, ENCODE_EXIT.PUBLICATION_FAILED);
-  assert.equal(ends[0].because, "piece 13 is incomplete");
-});
-
-test("a run whose process never started is not signalled, because pid 0 is our own process group", () => {
-  // Node reports a failed start (ENOENT) on a later turn; until then the child's
-  // process id is 0, and a signal sent to it is `kill(0, …)` — every process in
-  // our group, the proxy included. Measured 2026-10-03 under `node --test`.
-  const child = fakeProcess({ pid: null });
-  const run = new EncodeRun({
-    address: "torrent:abc:video-only:v=0/copy",
-    encoder: { name: "libx264", kind: "software" },
-    from: 0,
-    to: 4,
-    buildArgs: () => [],
-    spawn: () => child,
-    logger: silentLogger,
-    because: "a test asked for it"
-  });
-  run.stop("the viewer left");
-  assert.deepEqual(child.signals, [], "a process that did not start was sent a signal");
-});

package/test/encode-slope.test.js

@@ -1,46 +0,0 @@
-/**
- * @file The slope that turns ffmpeg's progress reports into a preset's speed.
- *
- * Written against the faults a review found in it on 2026-08-15, each of which
- * would have opened the quality ladder rather than closing it: a window of no
- * width at all, and a position ffmpeg reports as the smallest signed 64-bit
- * integer when it has none yet.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { slopeOf } from "../services/encode/hwaccel.js";
-
-const at = (wallSec, outSec) => ({ wallSec, outSec });
-
-test("a steady run measures its own speed", () => {
-  assert.equal(slopeOf([at(1, 10), at(2, 14)]), 4);
-});
-
-test("a window of no width is refused, however tempting the numbers", () => {
-  // Two reports a millisecond apart: 0.042 s of video over 0.001 s of clock is
-  // 42x, on a host that may be doing 3x.
-  assert.equal(slopeOf([at(1.0, 10), at(1.001, 10.042)], 0.2), null);
-});
-
-test("a run that produced nothing between two reports says nothing", () => {
-  assert.equal(slopeOf([at(1, 10), at(3, 10)]), null);
-});
-
-test("one report is not a measurement", () => {
-  assert.equal(slopeOf([at(1, 10)]), null);
-  assert.equal(slopeOf([]), null);
-});
-
-test("an impossible speed is a fault, not a fast machine", () => {
-  // Nothing encodes 640x360 five thousand times realtime; a reading that says
-  // so is a measurement fault, and letting it through raises the bar every
-  // ladder decision is taken from.
-  assert.equal(slopeOf([at(1, 0), at(2, 5000)]), null);
-});
-
-test("the narrowest allowed window is honoured", () => {
-  assert.equal(slopeOf([at(1.0, 10), at(1.3, 11)], 0.5), null);
-  assert.ok(slopeOf([at(1.0, 10), at(1.6, 12)], 0.5) > 0);
-});

package/test/encoded-output.test.js

@@ -1,39 +0,0 @@
-/**
- * @file An output holds what is born with it, and not what is produced.
- *
- * Decided with the user 2026-09-16: which pieces are made is the segment
- * store's, and which encoders run is the encoding orchestrator's. A second
- * holder of either is how the stale second owner stopped playback outright.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { EncodedOutput } from "../services/encode/output/EncodedOutput.js";
-import { outputSpec } from "./helpers/output-spec.js";
-
-function made() {
-  return new EncodedOutput({
-    id: "aaaaaaaabbbbcccc",
-    spec: outputSpec({ transcodeVideo: true, width: 1280, height: 720 }),
-    file: { key: "source-1:0" },
-    keyframes: null,
-    timeline: null,
-    segmentFormat: null,
-    output: null,
-    useSyntheticPlaylist: true,
-    playlistText: "#EXTM3U\n",
-    variantHeight: 720
-  });
-}
-
-test("its address is its format, read from the spec and kept nowhere else", () => {
-  const output = made();
-  assert.equal(output.outputKey, output.spec.toKey());
-});
-
-test("it keeps no statement of what has been produced or what is running", () => {
-  const output = made();
-  for (const field of ["runs", "runState", "progress", "produced", "ready", "state", "lastError", "failedStartCount"]) {
-    assert.equal(field in output, false, `${field} belongs to the store or the encoding orchestrator`);
-  }
-});