@torrent-tv/proxy 2.89.16 → 2.89.18

package/test/move-cost.test.js

@@ -1,216 +0,0 @@
-/**
- * @file What moving a running encoder costs, and what the plan does while
- * nobody has measured it.
- *
- * Field 2026-09-08: 39 moves in one session, 24 of them between three adjacent
- * numbers — #58 to #59, #59 to #58, #58 to #60, #60 to #58, six times each,
- * about 0.8 s apart — while the viewer's picture stood still for 116.7 s in
- * three interruptions, the worst of them 91.8 s. The zone the viewer's own
- * position defines slides forward one number at a time, and every slide made
- * standing one number behind it score worse than standing in it.
- *
- * THREE FAULTS IN THE ARITHMETIC, and no threshold anywhere. There was one for
- * a while — "a move must beat staying by at least what moving costs" — and it
- * was a prop under a comparison that was wrong rather than indifferent. It is
- * gone.
- *
- * 1. **A body was charged a whole piece for the one it was already making.**
- *    `arrival = delay + (index - at + 1) / rate` is right for a body that does
- *    not exist yet and wrong for a run 0.8 s into a 0.9 s piece. `delaySec` is
- *    now when the body finishes the piece it STANDS ON, so from #58 reaching #59
- *    costs 0.14 + 0.94 = 1.08 s against 1.88 s for a kill and a cold start — a
- *    decision by eight hundred milliseconds, where the double charge had made it
- *    a coin flip lost by ten.
- * 2. **The piece was priced at the unpenalised rate** while arrivals used the
- *    penalised one, so every extra body looked cheaper than it is and the plan
- *    bought a second encoder where one served. One rate, the one in force.
- * 3. **`withinSeconds: null` was read through `Number()`**, where it is 0, so
- *    the film BEHIND the viewers was due immediately and was the most urgent
- *    material in the file. It bought encoders and it took the run standing in
- *    front of the viewer, because that run was the nearest body to it.
- *
- * And what a move costs is `Infinity` until something has been measured, because
- * a move is irreversible while leaving the encoder alone is always available. A
- * run killed before producing anything is a measurement too — a lower bound on
- * the first output — which is the only reading a thrash can supply.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { RunCosts } from "../services/encode/run-costs.js";
-import { planEncoders } from "../services/encode/EncodePlan.js";
-import { CoverageMap } from "../services/encode/CoverageMap.js";
-
-test("nothing measured is a plain zero, and the floor is derived where the arithmetic is", () => {
-  const costs = new RunCosts();
-
-  const { firstByteWaitSec, killCostSec } = costs.seconds();
-  assert.equal(firstByteWaitSec, 0, "no reading is said as none, not as a guess");
-  assert.equal(killCostSec, 0);
-  // There was an `Infinity` here — the cost of a move, made unaffordable until
-  // something had been measured, on the reasoning that an unmeasured price must
-  // not license an irreversible act. It was an exception in a model that needs
-  // none: a first piece cannot appear faster than it takes to ENCODE one, and
-  // how fast this host encodes is measured before any viewer exists, so the
-  // floor belongs where the arithmetic is.
-  assert.equal("moveCostSec" in costs.seconds(), false, "no such figure any more");
-});
-
-test("a run killed before producing anything is a lower bound on the first output", () => {
-  const costs = new RunCosts();
-
-  // Exactly what a thrash supplies: a run that lived 800 ms and finished
-  // nothing. It says the first output takes AT LEAST that long, which is a fact
-  // and the only reading a thrash can give — every run in one is killed before
-  // it produces.
-  costs.note({ livedMs: 800, dyingMs: 40 });
-
-  const { firstByteWaitSec, killCostSec } = costs.seconds();
-  assert.ok(Math.abs(firstByteWaitSec - 0.8) < 0.001, `got ${firstByteWaitSec}`);
-  assert.ok(Math.abs(killCostSec - 0.04) < 0.001, `got ${killCostSec}`);
-});
-
-test("a run that produced something is measured by its first output, not its life", () => {
-  const costs = new RunCosts();
-
-  costs.note({ livedMs: 60_000, firstOutputMs: 1260, dyingMs: 100 });
-
-  const { firstByteWaitSec } = costs.seconds();
-  assert.ok(Math.abs(firstByteWaitSec - 1.26) < 0.001, `got ${firstByteWaitSec}`);
-});
-
-/**
- * The map's real shape: one segment at the viewer, doubling zones ahead down to
- * p91, and everything behind them at p1 with no deadline. Written out because a
- * fixture of two zones is not this, and the difference decides the answer: with
- * nothing stated past the viewer's own zone, a run one segment behind it is
- * compared on that zone alone and loses by a tenth of a second.
- *
- * @param {number} head - The segment the viewer is on.
- * @param {number} count
- * @returns {object[]}
- */
-function mapAt(head, count) {
-  const zones = [];
-  if (head > 0) {
-    zones.push({ from: 0, to: head - 1, priority: 1, withinSeconds: null, behind: true });
-  }
-  let from = head;
-  let width = 1;
-  let rank = 100;
-  while (from < count && rank > 90) {
-    const to = Math.min(count - 1, from + width - 1);
-    zones.push({ from, to, priority: rank, withinSeconds: (from - head) * 4.2, behind: false });
-    from = to + 1;
-    width *= 2;
-    rank -= 1;
-  }
-  if (from < count) {
-    zones.push({ from, to: count - 1, priority: 90, withinSeconds: (from - head) * 4.2, behind: false });
-  }
-  return zones;
-}
-
-test("an encoder is left alone while the viewer is still at or before it", () => {
-  // Every slide of the viewer's zone used to make standing one number behind it
-  // score worse than standing in it — by ten milliseconds, which is nothing but
-  // the double charge for a piece already being made. What holds now is the
-  // narrower and true statement: while the viewer's own zone still contains the
-  // encoder's position, it is left alone. A viewer BEFORE it is a different
-  // case entirely and correctly moves it back — encoders only go forward, so
-  // one standing past a viewer never reaches them.
-  //
-  // Once the viewer has PASSED it, moving forward is correct and happens once: a
-  // run that has produced nothing in 0.8 s of a 1.26 s warm-up owes 0.46 s
-  // before its piece exists, while a fresh one at the viewer's own number owes
-  // 0.32 s of spawn and then the piece — so the viewer is served sooner, and the
-  // number left behind is in nobody's zone.
-  const coverage = new CoverageMap();
-  coverage.setSegmentCount(482);
-  const run = { from: 58, to: -1, head: 58, speedX: 4.45, isAlive: true, startedAt: 1_000_000 };
-  coverage.claim(run, 58, -1);
-
-  for (const viewerAt of [58]) {
-    const actions = planEncoders({
-      coverage,
-      windows: mapAt(viewerAt, 482),
-      runs: [run],
-      maxRuns: 3,
-      segmentSeconds: 4.2,
-      speedX: 4.45,
-      killCostSec: 0.04,
-      // Measured on the addon host: a run started at 15:50:15.521 and its first
-      // piece existed at 15:50:16.785.
-      firstByteWaitSec: 1.26,
-      refetchSecPerFilmSecond: 0,
-      // 1.98 at 1920x1080, measured: a second encoder takes very nearly all of
-      // the first's speed.
-      contentionPenaltyFor: (others) => (others <= 0 ? 1 : 1.98 ** others),
-      now: 1_000_000 + 800
-    });
-
-    assert.deepEqual(
-      actions.filter((one) => one.type === "move"),
-      [],
-      `the viewer at #${viewerAt} does not cost the encoder its place`
-    );
-  }
-
-  // And once they are past it, exactly one move — not one per slide.
-  const past = [59, 60, 61].map((viewerAt) => planEncoders({
-    coverage,
-    windows: mapAt(viewerAt, 482),
-    runs: [run],
-    maxRuns: 3,
-    segmentSeconds: 4.2,
-    speedX: 4.45,
-    killCostSec: 0.04,
-    firstByteWaitSec: 1.26,
-    refetchSecPerFilmSecond: 0,
-    contentionPenaltyFor: (others) => (others <= 0 ? 1 : 1.98 ** others),
-    now: 1_000_000 + 800
-  }).filter((one) => one.type === "move"));
-
-  assert.deepEqual(
-    past.map((moves) => moves.length),
-    [1, 1, 1],
-    "one move to where the viewer now is, whichever number that is"
-  );
-  assert.deepEqual(
-    past.map((moves) => moves[0].from),
-    [59, 60, 61],
-    "and it goes to the viewer's own number, not one past it"
-  );
-});
-
-test("a move that genuinely saves the viewer time still happens", () => {
-  // The other half: the viewer jumped fourteen segments ahead, and driving there
-  // at 4.45x would take 13 s while a cold start takes 0.94 s. Refusing this
-  // would be the opposite fault.
-  const coverage = new CoverageMap();
-  coverage.setSegmentCount(482);
-  const run = { from: 0, to: 481, head: 44, speedX: 4.45, isAlive: true };
-  coverage.claim(run, 0, 481);
-
-  const actions = planEncoders({
-    coverage,
-    windows: [{ from: 58, to: 59, priority: 100, withinSeconds: 0, behind: false }],
-    runs: [run],
-    maxRuns: 3,
-    segmentSeconds: 4.2,
-    speedX: 4.45,
-    killCostSec: 0.04,
-    firstByteWaitSec: 1.26,
-    refetchSecPerFilmSecond: 0,
-    contentionPenaltyFor: () => 1
-  });
-
-  // WHERE the encoder ends up, not how it got there: the run at #44 reaches
-  // nothing anybody waits for, so the plan may either take it to #58 or stop it
-  // and start one there. Both are one process at #58, and which is cheaper is
-  // the measured difference between a kill and a cold start.
-  const placed = actions
-    .filter((one) => one.type === "move" || one.type === "start")
-    .map((one) => one.from);
-  assert.deepEqual(placed, [58], "fourteen segments of driving is worth a cold start");
-});

package/test/mp4-subtitles.test.js

@@ -1,173 +0,0 @@
-/**
- * @file Reading an MP4's text subtitle track out of its sample table.
- *
- * The file is built here, so every answer is known in advance: two cues at
- * stated times, in stated places, with an empty sample between them — the way
- * the format says "nothing on screen just now".
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { Mp4Container } from "../services/media/container/Mp4Container.js";
-
-function box(type, payload) {
-  const header = Buffer.alloc(8);
-  header.writeUInt32BE(payload.length + 8, 0);
-  header.write(type, 4, "latin1");
-  return Buffer.concat([header, payload]);
-}
-
-function fullBox(type, payload) {
-  return box(type, Buffer.concat([Buffer.from([0, 0, 0, 0]), payload]));
-}
-
-function u32(...values) {
-  const buffer = Buffer.alloc(values.length * 4);
-  values.forEach((value, index) => buffer.writeUInt32BE(value, index * 4));
-  return buffer;
-}
-
-/** A `tx3g` sample: a two-byte length, then the text. */
-function textSample(text) {
-  const bytes = Buffer.from(text, "utf8");
-  const length = Buffer.alloc(2);
-  length.writeUInt16BE(bytes.length, 0);
-  return Buffer.concat([length, bytes]);
-}
-
-/**
- * A file with one text track: three samples, the middle one empty.
- *
- * @param {number} [displayFlags] - The `tx3g` sample entry's display flags.
- * @param {boolean} [withFtyp] - Open the file with an `ftyp` box, which is what
- *   the container layer sniffs for before it will read anything.
- * @returns {{ file: Buffer, samples: Buffer[] }}
- */
-function buildFile(displayFlags = 0, withFtyp = false) {
-  const samples = [textSample("First line"), Buffer.alloc(2), textSample("Second line")];
-  const timescale = 1000;
-
-  const mdhd = fullBox("mdhd", Buffer.concat([
-    u32(0, 0, timescale, 60_000),
-    // Language "eng", five bits a letter offset from 0x60, then a spare word.
-    Buffer.from([0x15, 0xc7, 0, 0])
-  ]));
-  const hdlr = fullBox("hdlr", Buffer.concat([u32(0), Buffer.from("sbtl", "latin1"), u32(0, 0, 0)]));
-  const tkhd = fullBox("tkhd", u32(0, 0, 7, 0, 60_000));
-
-  // A sample entry opens with 6 reserved bytes and a 2-byte data reference
-  // index, and `displayFlags` is the 32 bits after them.
-  const tx3g = Buffer.alloc(24);
-  tx3g.writeUInt32BE(displayFlags >>> 0, 8);
-  const stsd = fullBox("stsd", Buffer.concat([u32(1), box("tx3g", tx3g)]));
-  // Two seconds a sample, so the cues sit at 0-2, 2-4 and 4-6 seconds.
-  const stts = fullBox("stts", Buffer.concat([u32(1), u32(3, 2000)]));
-  const stsz = fullBox("stsz", Buffer.concat([u32(0, 3), u32(...samples.map((s) => s.length))]));
-  const stsc = fullBox("stsc", Buffer.concat([u32(1), u32(1, 3, 1)]));
-
-  const stbl = box("stbl", Buffer.concat([stsd, stts, stsz, stsc, fullBox("stco", Buffer.concat([u32(1), u32(0)]))]));
-  const minf = box("minf", stbl);
-  const mdia = box("mdia", Buffer.concat([mdhd, hdlr, minf]));
-  const trak = box("trak", Buffer.concat([tkhd, mdia]));
-  const moovDraft = box("moov", trak);
-
-  // The samples sit after moov, so the chunk offset is known only now. Its
-  // length does not change when the placeholder becomes the real value.
-  const ftyp = withFtyp
-    ? box("ftyp", Buffer.concat([Buffer.from("isom", "latin1"), u32(512), Buffer.from("isom", "latin1")]))
-    : Buffer.alloc(0);
-  const mdatStart = ftyp.length + moovDraft.length + 8;
-  const stcoReal = fullBox("stco", Buffer.concat([u32(1), u32(mdatStart)]));
-  const stblReal = box("stbl", Buffer.concat([stsd, stts, stsz, stsc, stcoReal]));
-  const moov = box("moov", box("trak", Buffer.concat([
-    tkhd,
-    box("mdia", Buffer.concat([mdhd, hdlr, box("minf", stblReal)]))
-  ])));
-  const mdat = box("mdat", Buffer.concat(samples));
-  return { file: Buffer.concat([ftyp, moov, mdat]), samples };
-}
-
-function readerOver(file) {
-  return async (start, end) => {
-    const last = Math.min(end, file.length - 1);
-    return start > last ? null : file.subarray(start, last + 1);
-  };
-}
-
-test("a text track's cues are found with their times and their byte ranges", async () => {
-  const { file, samples } = buildFile();
-
-  const plan = await Mp4Container.readSubtitlePlan(readerOver(file), file.length);
-
-  assert.equal(plan.tracks.length, 1);
-  const track = plan.tracks[0];
-  assert.equal(track.format, "tx3g");
-  assert.equal(track.language, "eng");
-  assert.equal(track.samples.length, 2, "the empty sample is a gap, not a cue");
-  assert.deepEqual(
-    track.samples.map((sample) => [sample.startSeconds, sample.endSeconds]),
-    [[0, 2], [4, 6]],
-    "times come from the duration table, and the gap keeps its place in it"
-  );
-  // The bytes the plan points at are the ones that hold the text.
-  const first = file.subarray(track.samples[0].offset, track.samples[0].offset + track.samples[0].size);
-  assert.equal(Mp4Container.cueTextOf(first, "tx3g"), "First line");
-  const second = file.subarray(track.samples[1].offset, track.samples[1].offset + track.samples[1].size);
-  assert.equal(Mp4Container.cueTextOf(second, "tx3g"), "Second line");
-  assert.equal(second.length, samples[2].length);
-});
-
-test("a file with no text track offers nothing", async () => {
-  const moov = box("moov", box("trak", box("mdia", Buffer.concat([
-    fullBox("mdhd", Buffer.concat([u32(0, 0, 1000, 100), Buffer.from([0, 0, 0, 0])])),
-    fullBox("hdlr", Buffer.concat([u32(0), Buffer.from("vide", "latin1"), u32(0, 0, 0)]))
-  ]))));
-  const file = Buffer.concat([moov, box("mdat", Buffer.alloc(4))]);
-
-  const plan = await Mp4Container.readSubtitlePlan(readerOver(file), file.length);
-
-  assert.deepEqual(plan.tracks, []);
-});
-
-test("a WebVTT sample gives up the text inside its payload box", () => {
-  const payl = box("payl", Buffer.from("Hello there", "utf8"));
-  const sample = box("vttc", payl);
-
-  assert.equal(Mp4Container.cueTextOf(sample, "wvtt"), "Hello there");
-});
-
-test("the sample entry's display flags say whether the track is forced", async () => {
-  // Apple's QuickTime File Format, "Display flags" under Subtitle sample
-  // description: `0x40000000` "Some samples are forced", `0x80000000` "All
-  // samples are forced", and setting the second requires the first — together
-  // `0xC0000000`. `0x20000000` is vertical placement and says nothing about
-  // forcing.
-  const readFlags = async (displayFlags) => {
-    const { file } = buildFile(displayFlags);
-    const plan = await Mp4Container.readSubtitlePlan(readerOver(file), file.length);
-    const track = plan.tracks[0];
-    return [track.someSamplesForced, track.allSamplesForced];
-  };
-
-  assert.deepEqual(await readFlags(0), [false, false]);
-  assert.deepEqual(await readFlags(0x40000000), [true, false]);
-  assert.deepEqual(await readFlags(0xc0000000), [true, true]);
-  // A writer that set only the second bit still means the track is forced.
-  assert.deepEqual(await readFlags(0x80000000), [false, true]);
-  // Vertical placement is a different field's business.
-  assert.deepEqual(await readFlags(0x20000000), [false, false]);
-});
-
-test("a forced sample entry reaches the track the viewer is offered", async () => {
-  const forced = buildFile(0xc0000000, true).file;
-  const plain = buildFile(0, true).file;
-
-  const trackOf = async (file) => {
-    const container = new Mp4Container({ readRange: readerOver(file), fileSize: file.length });
-    const tracks = await container.readTracks();
-    return tracks.find((track) => track.type === "subtitle");
-  };
-
-  assert.equal((await trackOf(forced))?.isForced, true);
-  assert.equal((await trackOf(plain))?.isForced, false);
-});

package/test/one-authority.test.js

@@ -1,285 +0,0 @@
-/**
- * @file One place decides which encoders exist.
- *
- * Not a check of behaviour but of shape, and it is here because the shape is
- * what failed. Three separate places used to decide where an encoder should
- * work and whether it should go on living, and they disagreed on every pass:
- * measured in the field on 2026-09-05, 684 starts and 660 stops in 482 seconds,
- * of which 294 were one place killing what another had just decided to keep,
- * while the viewer's own segment went unmade for 32.3 seconds.
- *
- * Every rule below is one that was broken then. A reader who needs to add a
- * fourth place should read this file first and then not.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync, readdirSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { EventEmitter } from "node:events";
-import { EncodeRun } from "../services/encode/EncodeRun.js";
-
-const HERE = path.dirname(fileURLToPath(import.meta.url));
-
-/**
- * @param {string} relative
- * @returns {string}
- */
-function source(relative) {
-  return readFileSync(path.join(HERE, "..", relative), "utf8");
-}
-
-/**
- * Every source file of the proxy's services, read together.
- *
- * A rule that something must not come back is asked of all of them: asked of
- * one file, it passes as soon as the code moves to another.
- *
- * @returns {string}
- */
-function everything() {
-  return readdirSync(path.join(HERE, "..", "services"), { recursive: true })
-    .filter((name) => String(name).endsWith(".js"))
-    .map((name) => source(path.join("services", String(name))))
-    .join("\n");
-}
-
-/**
- * Lines of code, without comments or blanks: a rule about what the code does
- * must not be answered by what a comment says about it.
- *
- * @param {string} text
- * @returns {string[]}
- */
-function statements(text) {
-  return text
-    .split("\n")
-    .map((line) => line.trim())
-    .filter((line) => line.length > 0 && !line.startsWith("//") && !line.startsWith("*") && !line.startsWith("/*"));
-}
-
-test("an encoder is stopped for scheduling reasons in exactly one place", () => {
-  // The orchestrator decides; nobody else may. What is left in the session
-  // manager is teardown — the session is going away and its encoders with it —
-  // which is not a decision about which encoders should exist.
-  const orchestrator = statements(source("services/encode/EncodeOrchestrator.js"));
-  const stopsInOrchestrator = orchestrator.filter((line) => line.includes("run.stop("));
-  assert.equal(stopsInOrchestrator.length, 1, "the orchestrator stops runs in one place");
-
-  const wiring = statements(source("services/server/wire-outputs.js"));
-  assert.deepEqual(wiring.filter((line) => line.includes(".stop(")), [], "the wiring stops nothing");
-  const lifecycle = statements(source("services/server/OutputLifecycle.js"));
-  const stopsAtTeardown = lifecycle.filter((line) => line.includes(".stop("));
-  assert.equal(
-    stopsAtTeardown.length,
-    1,
-    "an output's end stops its runs, and nothing else there does: " + stopsAtTeardown.join(" / ")
-  );
-  // And the runs themselves stop one for a stated reason in one place, which is
-  // what a corrected cut table asks through.
-  const runs = statements(source("services/encode/EncodeRuns.js"));
-  assert.equal(runs.filter((line) => line.includes(".stop(")).length, 1);
-});
-
-test("nothing outside the encoding layer starts an encoder", () => {
-  // A run is built in one place. Two places building them is how a start came
-  // to kill what the plan had decided to keep — the killing lived in the
-  // building.
-  const builds = statements(everything()).filter((line) => line.includes("new EncodeRun("));
-  assert.equal(builds.length, 1, "one place builds an encoder");
-});
-
-test("a run exists means its process is running, so nothing can start one twice", () => {
-  // WHAT THIS IS FOR, and why the test above did not catch it. That one counts
-  // where a run is BUILT and asks nothing about where it is STARTED, and until
-  // 2026-09-10 those were two acts: the session manager built a run and started
-  // it, handed it back, and the orchestrator started it again. Every run of
-  // every session therefore had two ffmpeg processes on one output writing one
-  // set of names — 207 runs against 414 spawns in the field logs of 08-10
-  // September, without a single exception — and only the second was reachable,
-  // so a stop killed one and the other ran on, measured 105 seconds past its
-  // own run's death.
-  //
-  // Asserted over the source because the guarantee IS a property of the source:
-  // there is no second act for a second owner to perform.
-  const files = [
-    "services/encode/EncodeRun.js",
-    "services/encode/EncodeOrchestrator.js",
-    "services/encode/EncodeRuns.js",
-    "services/server/wire-outputs.js"
-  ];
-  for (const file of files) {
-    const starts = statements(source(file)).filter(
-      (line) =>
-        /(?:^|[^a-zA-Z#])start\(/.test(line) &&
-        !/startsWith|startPosition|startIndex|startSeconds|startAt|startNumber/.test(line)
-    );
-    assert.deepEqual(starts, [], "an encoder is started by hand in " + file + ": " + starts.join(" / "));
-  }
-});
-
-test("starting an encoder stops nothing", () => {
-  // The rule that broke it: the start path looked for a live run whose own
-  // start was not below the new one's and killed it. It is not enough that the
-  // line is gone — the words it was written with must not come back.
-  const manager = everything();
-  assert.equal(
-    manager.includes("previousRun"),
-    false,
-    "there is no such thing as the previous run: a session holds several"
-  );
-  assert.equal(manager.includes("a new run is taking its place"), false);
-});
-
-test("a seek moves the viewer and nothing else", () => {
-  // It used to do eleven things and write the position into five places. What
-  // follows from a viewer moving is the map's business, and the orchestrators
-  // read the map.
-  const manager = source("services/server/ViewerRequests.js");
-  const at = manager.indexOf("requestSeek(sessionId, positionSeconds");
-  assert.notEqual(at, -1, "the seek is where this reads it");
-  const seek = manager.slice(at, at + 2000);
-  const body = seek.slice(0, seek.indexOf("\n  }\n"));
-  assert.equal(body.includes("#startEncodeRun"), false, "a seek starts no encoder");
-  assert.equal(body.includes("setTimeout"), false, "and waits for nothing");
-});
-
-test("how far an encoder may work is answered once", () => {
-  // The plan computes the stretch and it reaches ffmpeg. A second computation
-  // somewhere else is what made the first one pointless: it was passed and then
-  // dropped by a parameter list that did not name it.
-  const orchestrator = source("services/encode/EncodeOrchestrator.js");
-  assert.match(
-    orchestrator,
-    /makeRun\(\{ address, from, to, because \}\)/,
-    "the stretch is handed over, and so are the plan's own words for why"
-  );
-});
-
-test("only the plan places an encoder", () => {
-  // The count is the whole of this item. There were eight other places: the
-  // first run of a session, a viewer joining it further in, a rung or a
-  // soundtrack being warmed, one being switched to, a hardware encoder falling
-  // back to software, an input coming back, a cut table correcting itself, and
-  // a settled seek. Each of them chose a position by a rule of its own, and the
-  // plan — which is arithmetic over what is made, what is being made and what is
-  // wanted — was left to compare its answer against theirs.
-  const manager = source("services/encode/EncodeRuns.js");
-  const starts = [...manager.matchAll(/this\.#startEncodeRun\(/g)].length;
-  assert.equal(starts, 1, "one caller, and it is the one the plan asks through");
-  assert.match(
-    manager,
-    /makeRunAt\(address, from, to, because\)[\s\S]{0,3000}this\.#startEncodeRun\(base, from, because, \{ to \}\)/,
-    "and that caller is what the plan is given to build runs with"
-  );
-});
-
-test("nobody stops an encoder for being unwatched", () => {
-  // Whether an encoder is still wanted is the same question as where one should
-  // be, and the plan answers it: an output with nobody on it has a priority map
-  // with nothing in it. Answered here as well, it was answered twice by two
-  // rules — and since a viewer moving between steps announces itself, the plan
-  // started again what this class had just killed, several times a second.
-  const manager = everything();
-  assert.equal(
-    manager.includes("no viewer is watching"),
-    false,
-    "a rung nobody is on is a fact, not an act"
-  );
-  assert.equal(manager.includes("no viewer is listening to audio track"), false);
-  assert.equal(
-    manager.includes("warmed for a switch the viewer did not make"),
-    false,
-    "an abandoned warm-up is a viewer leaving an output"
-  );
-  assert.equal(manager.includes("prepared for a track change the viewer did not make"), false);
-});
-
-test("the seek settle machinery is gone, whole", () => {
-  // A viewer's position is applied the moment they state it. The settle was a
-  // second debounce on a signal the browser had already debounced, and every
-  // millisecond of it was dead time in front of the viewer; the cooldown behind
-  // it existed because segment REQUESTS once steered the encoder.
-  const manager = everything();
-  for (const gone of [
-    "seekSettleTimer",
-    "seekTarget",
-    "seekFirstFarAt",
-    "SEEK_SETTLE_MS",
-    "SEEK_SETTLE_MAX_MS",
-    "RESTART_COOLDOWN_MS",
-    "SEEK_BACKOFF_SEGMENTS",
-    "#fireSettledSeek",
-    "#seekSession"
-  ]) {
-    assert.equal(manager.includes(gone), false, `${gone} is gone`);
-  }
-});
-
-test("where a soundtrack begins is read off the table, not handed in", () => {
-  // The instant a number really begins is a fact of the FILE's cutting, held in
-  // the live table every session of the file shares. Passed as an argument by
-  // the one caller that had measured it, only a run started by that caller ever
-  // had it, and a run the plan placed at the same number landed apart again.
-  const manager = source("services/encode/EncodeRuns.js");
-  assert.match(
-    manager,
-    /const positionSecondsOverride = session\.spec\.carries === "audio-only"\s*\n?\s*\? trueStartOf\(session\.timeline, startIndex\)/,
-    "derived where the run is built"
-  );
-  assert.equal(
-    manager.includes("this.#startEncodeRun(member, index, trueStart)"),
-    false,
-    "and not carried in from the correction that measured it"
-  );
-});
-
-test("each output is handed its own priority map, and the plan is what reads it", () => {
-  // The map is one fact asked at two scopes, and both are right for what asks
-  // them: the swarm is asked for bytes of a FILE, which every output of it
-  // reads, and encoders are placed per OUTPUT, which a person watching 480p
-  // wants nothing of at 1080p.
-  const manager = source("services/encode/EncodeRuns.js");
-  assert.match(
-    manager,
-    /notePriorityMap\([\s\S]{0,200}mapForOutput\(address\)/,
-    "the encoding reads the output's own map"
-  );
-  assert.equal(
-    manager.includes("this.priority.mapFor("),
-    false,
-    "and never the whole film's, which wanted an encoder on every output of it"
-  );
-});
-
-test("one process per run, and no way to ask for a second", () => {
-  const spawned = [];
-  const run = new EncodeRun({
-    address: "torrent:abc:video-only:v=0/copy",
-    encoder: { name: "libx264", kind: "software" },
-    from: 0,
-    to: 4,
-    buildArgs: () => [],
-    spawn: () => {
-      const child = new EventEmitter();
-      child.stdout = new EventEmitter();
-      child.stderr = new EventEmitter();
-      child.stdio = [null, child.stdout, child.stderr, new EventEmitter()];
-      child.kill = () => undefined;
-      child.pid = 1 + spawned.length;
-      spawned.push(child);
-      return child;
-    },
-    logger: { info: () => undefined, warn: () => undefined },
-    now: () => 1000,
-    because: "a test asked for it"
-  });
-
-  assert.equal(spawned.length, 1, "building a run did not put a process on the machine");
-  assert.equal(
-    Reflect.get(run, "start"),
-    undefined,
-    "a run still offers a way to start it a second time"
-  );
-});