@torrent-tv/proxy 2.89.17 → 2.89.19

package/test/priority-map.test.js

@@ -1,163 +0,0 @@
-/**
- * @file The priority map: one number per second of film.
- *
- * The map is literally a map — an array as long as the film, saying how urgently
- * each second is wanted, and beside it how long until somebody plays it. What is
- * checked here is what the numbers MEAN, since only their order is meaningful:
- * in front of a viewer beats behind them, nearer beats further, and two viewers
- * merge to the more urgent of them.
- *
- * Nothing here spawns anything, reads a disk or looks at a clock: this layer is
- * exercised with plain values alone, which is the layer check made executable.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import {
-  emptyMap,
-  inWorkingOrder,
-  isBehindEverybody,
-  mapForViewer,
-  mergeMaps,
-  runsOf
-} from "../services/viewer/PriorityMap.js";
-
-const FILM = 3600;
-const ALLOWANCE = 8;
-
-/**
- * @param {number} atSeconds
- * @param {boolean} [playing]
- */
-function viewer(atSeconds, playing = true) {
-  return mapForViewer({
-    atSeconds,
-    durationSeconds: FILM,
-    allowanceSeconds: ALLOWANCE,
-    playing
-  });
-}
-
-test("the map is one entry per second of film", () => {
-  const map = viewer(600);
-  assert.equal(map.durationSeconds, FILM);
-  assert.equal(map.priority.length, FILM);
-  assert.equal(map.secondsUntilPlayed.length, FILM);
-  assert.equal(map.behind.length, FILM);
-});
-
-test("the nearer a viewer is to a second, the higher its number", () => {
-  // The whole of what a priority means: which of two seconds is wanted first.
-  const map = viewer(600);
-  assert.ok(map.priority[600] > map.priority[700], "their own second beats one a hundred on");
-  assert.ok(map.priority[700] > map.priority[3000], "and that beats one forty minutes on");
-});
-
-test("the time is the distance, because a viewer covers a second of film in a second", () => {
-  const map = viewer(600);
-  assert.equal(map.secondsUntilPlayed[600], 0, "they are there now");
-  assert.equal(map.secondsUntilPlayed[660], 60, "a minute of film away is a minute away");
-});
-
-test("what is behind a viewer is wanted, and wanted last", () => {
-  // Still wanted — a seek back must be cheap — but it yields to everything
-  // anybody is walking towards, however far off that is.
-  const map = viewer(600);
-  assert.equal(map.behind[599], 1);
-  assert.equal(map.behind[600], 0);
-  assert.ok(isBehindEverybody(map.priority[599]));
-  assert.ok(map.priority[599] < map.priority[3599],
-    "the last second of the film outranks the second they just watched");
-  assert.equal(map.secondsUntilPlayed[599], Number.POSITIVE_INFINITY,
-    "nobody is on their way there, so there is no time by which it must exist");
-});
-
-test("a viewer who has stopped the picture keeps their position, and loses their times", () => {
-  // A pause removes the time, not the direction. Collapsed to one flat value
-  // over the whole film, as it was, their position disappeared entirely — and
-  // with it the rule that what is in front of them is made first.
-  const map = viewer(600, false);
-  assert.equal(map.behind[599], 1, "what they have watched is still behind them");
-  assert.equal(map.behind[600], 0, "and what they have not is still in front");
-  assert.ok(map.priority[600] > map.priority[599], "in front still outranks behind");
-  assert.ok(map.priority[600] > map.priority[3000], "and nearer still outranks further");
-  for (const second of [599, 600, 3000]) {
-    assert.equal(map.secondsUntilPlayed[second], Number.POSITIVE_INFINITY,
-      "but nothing has a time, because they are on their way nowhere");
-  }
-});
-
-test("anybody who is watching outranks anybody who has stopped", () => {
-  // An ordering fact rather than a chosen number: somebody watching needs their
-  // next second almost at once, while somebody stopped needs theirs at a time
-  // nothing here knows.
-  const watching = viewer(600);
-  const stopped = viewer(3000, false);
-  assert.ok(watching.priority[3599] > stopped.priority[3000],
-    "the far tail of a watching viewer beats the very next second of a stopped one");
-});
-
-test("two viewers merge to the more urgent of them, second by second", () => {
-  const merged = mergeMaps([viewer(600), viewer(1800)]);
-  assert.equal(merged.priority[1800], merged.priority[600],
-    "each of them is at the top of the scale where they stand");
-  assert.equal(merged.secondsUntilPlayed[1800], 0, "the nearer time wins");
-  assert.equal(merged.behind[599], 1, "behind both of them is behind");
-  assert.equal(merged.behind[700], 0, "and in front of ANYBODY is in front");
-});
-
-test("the second viewer's position is not buried under the first viewer's distance", () => {
-  // The failure this guards: one viewer's far film outranking another viewer's
-  // own second, so the second of them is served by nobody.
-  const merged = mergeMaps([viewer(600), viewer(1800)]);
-  assert.ok(merged.priority[1800] > merged.priority[1799],
-    "where the second viewer stands beats the film just before them");
-});
-
-test("a film nobody is watching wants nothing", () => {
-  const merged = mergeMaps([]);
-  assert.equal(merged.durationSeconds, 0);
-  assert.deepEqual(runsOf(merged), []);
-});
-
-test("the map as stretches says the same thing in fewer numbers", () => {
-  const runs = runsOf(viewer(600));
-  assert.ok(runs.length > 1 && runs.length < 40, "a handful of stretches, not thousands");
-  assert.equal(runs[0].from, 0, "starting at the beginning of the film");
-  assert.equal(runs[0].behind, true, "which is behind them");
-  assert.equal(runs[runs.length - 1].to, FILM, "and ending at its end");
-  for (let index = 0; index < runs.length - 1; index += 1) {
-    assert.equal(runs[index].to, runs[index + 1].from, "with no gaps");
-  }
-});
-
-test("the stretches widen with distance, so any film is a handful of them", () => {
-  // Near the viewer the difference between now and ten seconds away decides what
-  // is made first; twenty minutes out, one more division changes no decision.
-  const ahead = runsOf(viewer(0)).filter((run) => run.behind === false);
-  for (let index = 1; index < ahead.length; index += 1) {
-    assert.ok(ahead[index].to - ahead[index].from >= ahead[index - 1].to - ahead[index - 1].from,
-      "each stretch is at least as wide as the one before it");
-  }
-  assert.ok(ahead[0].to - ahead[0].from <= ALLOWANCE + 1,
-    "and the first is as wide as the measured allowance");
-});
-
-test("the working order is most urgent first, earliest film within one priority", () => {
-  const ordered = inWorkingOrder(runsOf(viewer(600)));
-  for (let index = 0; index < ordered.length - 1; index += 1) {
-    const left = ordered[index];
-    const right = ordered[index + 1];
-    assert.ok(
-      left.priority > right.priority || (left.priority === right.priority && left.from < right.from),
-      "sorted by priority, then by position"
-    );
-  }
-  assert.equal(ordered[0].from, 600, "and the first of all is where the viewer is stopped");
-});
-
-test("a map of no length is a statement, and it says nothing is wanted", () => {
-  const map = emptyMap(0);
-  assert.equal(map.durationSeconds, 0);
-  assert.deepEqual(runsOf(map), []);
-});

package/test/probe-wedge-certainty.test.js

@@ -1,60 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { probeWedgeIsCertain, readProbeState, PROBE_INTERVAL_MS } from "../services/transport/delivery-probe.js";
-
-test("a seen-counter bounded lag is not a wedge, however long it lasts", () => {
-  // Session 4dcac61b, field log 2026-08-28: gap held at 6-7 probes for 95+
-  // seconds on a backgrounded tab, but `seen` kept climbing right along with
-  // `sent` — this connection's own history says gaps up to ~3.5 s (7 probes
-  // at 500 ms) are ordinary, so the same 3.5 s stuck must not read as certain.
-  const verdict = probeWedgeIsCertain({
-    stuckForMs: 3400,
-    longestHealthySeenGapMs: 3500
-  });
-  assert.equal(verdict.isCertain, false);
-});
-
-test("a seen-counter frozen past this connection's own worst legitimate gap is a wedge", () => {
-  // Session d85ae4f5, the same field log: `seen` frozen at one value for over
-  // a minute while `sent` climbed unbounded — this is the shape the detector
-  // exists to catch.
-  const verdict = probeWedgeIsCertain({
-    stuckForMs: 90_000,
-    longestHealthySeenGapMs: 3500
-  });
-  assert.equal(verdict.isCertain, true);
-});
-
-test("with no healthy history yet, one probe interval is still required", () => {
-  const verdict = probeWedgeIsCertain({
-    stuckForMs: PROBE_INTERVAL_MS - 1,
-    longestHealthySeenGapMs: 0
-  });
-  assert.equal(verdict.isCertain, false);
-  assert.equal(verdict.needMs, PROBE_INTERVAL_MS);
-});
-
-test("readProbeState calls association-stopped only when the unreliable channel agrees", () => {
-  // Ordered channels behind, but the unordered/no-retransmit one current:
-  // head-of-line blocking in one stream, not the association.
-  const streamStuck = readProbeState({
-    seq: 100,
-    seen: { proxy: 90, "proxy-control": 90, "proxy-fast": 99 },
-    labels: ["proxy", "proxy-control", "proxy-fast"],
-    echoes: 5,
-    echoAgeMs: 100,
-    allowed: { proxy: 2, "proxy-control": 2, "proxy-fast": 2 }
-  });
-  assert.equal(streamStuck.verdict, "stream-stuck");
-
-  const associationStopped = readProbeState({
-    seq: 100,
-    seen: { proxy: 90, "proxy-control": 90, "proxy-fast": 90 },
-    labels: ["proxy", "proxy-control", "proxy-fast"],
-    echoes: 5,
-    echoAgeMs: 100,
-    allowed: { proxy: 2, "proxy-control": 2, "proxy-fast": 2 }
-  });
-  assert.equal(associationStopped.verdict, "association-stopped");
-});

package/test/produced-copy-choice.test.js

@@ -1,213 +0,0 @@
-/**
- * @file A piece that cannot be played: waited for, or removed and made again.
- *
- * Field 2026-09-03. A run was suspended 548 ms after it started with
- * `segment-00025.mp4` newly opened, so the file stayed at zero bytes. From then
- * on the two halves of the proxy disagreed about it and neither could see the
- * other's reason: the look-ahead counted the NAME, found the numbering unbroken
- * through #83, called it `420s ahead of the viewer` and kept the encoder
- * stopped; the serving path read the FILE, found it short of a track, and
- * waited for a run that had produced nothing to finish it.
- *
- * The viewer's picture stood still for ten minutes on a transport measuring
- * 3-9 ms round trip.
- *
- * The question of WHICH copy answers is gone with the directory-per-run scheme:
- * there is one directory per output, runs are kept apart by their stretches,
- * and one name is one file. What is left is the question that remains real —
- * whether a file that cannot be played is being written now or was left by a
- * run that has ended.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { SourceFile } from "../services/media/SourceFile.js";
-import { Timeline } from "../services/encode/output/Timeline.js";
-import { mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { managerWithOwnStore } from "./helpers/manager.js";
-import { startRunOn } from "./helpers/encode-run.js";
-import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-import { outputSpec } from "./helpers/output-spec.js";
-
-const MOVIE_TIMESCALE = 1000;
-const VIDEO_TIMESCALE = 90_000;
-const AUDIO_TIMESCALE = 48_000;
-const SEGMENT_SECONDS = 12.5;
-const SESSION_ID = "aef21c88a8d64a9a";
-
-/**
- * @param {string} type
- * @param {Buffer} body
- * @returns {Buffer}
- */
-function box(type, body) {
-  const head = Buffer.alloc(8);
-  head.writeUInt32BE(8 + body.length, 0);
-  head.write(type, 4, "latin1");
-  return Buffer.concat([head, body]);
-}
-
-/**
- * @param {number} offsetSeconds
- * @returns {Buffer}
- */
-function emptyEdit(offsetSeconds) {
-  const body = Buffer.alloc(16);
-  body.writeUInt32BE(1, 4);
-  body.writeUInt32BE(Math.round(offsetSeconds * MOVIE_TIMESCALE), 8);
-  body.writeInt32BE(-1, 12);
-  return box("elst", body);
-}
-
-/**
- * @param {number} trackId
- * @param {number} timescale
- * @param {number} offsetSeconds
- * @returns {Buffer}
- */
-function trak(trackId, timescale, offsetSeconds) {
-  const tkhdBody = Buffer.alloc(84);
-  tkhdBody.writeUInt32BE(trackId, 12);
-  const mdhdBody = Buffer.alloc(20);
-  mdhdBody.writeUInt32BE(timescale, 12);
-  return box("trak", Buffer.concat([
-    box("tkhd", tkhdBody),
-    box("edts", emptyEdit(offsetSeconds)),
-    box("mdia", box("mdhd", mdhdBody))
-  ]));
-}
-
-/**
- * @param {number} trackId
- * @returns {Buffer}
- */
-function traf(trackId) {
-  const tfhdBody = Buffer.alloc(8);
-  tfhdBody.writeUInt32BE(trackId, 4);
-  const tfdtBody = Buffer.alloc(12);
-  tfdtBody.writeUInt8(1, 0);
-  tfdtBody.writeBigUInt64BE(0n, 4);
-  return box("traf", Buffer.concat([box("tfhd", tfhdBody), box("tfdt", tfdtBody)]));
-}
-
-/**
- * A piece shaped like the `segment` muxer's output, carrying both tracks.
- *
- * @param {number} offsetSeconds
- * @returns {Buffer}
- */
-function wholePiece(offsetSeconds) {
-  const mvhdBody = Buffer.alloc(100);
-  mvhdBody.writeUInt32BE(MOVIE_TIMESCALE, 12);
-  const moov = box("moov", Buffer.concat([
-    box("mvhd", mvhdBody),
-    trak(1, VIDEO_TIMESCALE, offsetSeconds),
-    trak(2, AUDIO_TIMESCALE, offsetSeconds)
-  ]));
-  const moof = box("moof", Buffer.concat([traf(1), traf(2)]));
-  return Buffer.concat([
-    box("ftyp", Buffer.alloc(16, 0)),
-    moov,
-    moof,
-    box("mdat", Buffer.alloc(64, 0x5a)),
-    box("mfra", Buffer.alloc(24, 0))
-  ]);
-}
-
-
-/**
- * A session with the output directory every run writes into.
- *
- * @returns {Promise<{ manager: object, session: object, dirPath: string }>}
- */
-async function sessionOnOneDirectory() {
-  const dirPath = await mkdtemp(path.join(os.tmpdir(), "produced-copy-"));
-  // Its own store root — see `helpers/manager.js` for what sharing one cost.
-  const { manager } = managerWithOwnStore();
-  const session = {
-    id: SESSION_ID,
-    spec: outputSpec({ transcodeVideo: false }),
-    dirPath,
-    // Where this file is cut, held by the file. A fixture that stated it
-    // on the session was describing what production no longer does.
-    timeline: new Timeline({
-      boundaries: [0, SEGMENT_SECONDS, 25, 37.5, 50],
-      cutGrid: "uniform"
-    }),
-    state: "ready",
-    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "Drifters - 04.mkv" }),
-    // An ordinary session reads its own file, and its sound is inside it. The
-    // three differ only for a soundtrack shipped as a file of its own.
-    get inputFile() { return this.file; },
-    get audioFile() { return this.file; },
-    startedAt: Date.now(),
-    lastAccessedAt: Date.now(),
-    runs: new Set(),
-    lastError: "",
-    segmentFormat: fmp4Format,
-    useSyntheticPlaylist: true,
-    playlistText: "#EXTM3U\n",
-    initBytes: fmp4Format.extractInit(wholePiece(0)),
-    waitEpoch: 0
-  };
-  manager.outputs.set(SESSION_ID, session);
-  // A run exists and is alive — the state the field case was in, and the one in
-  // which the old test called every leftover "still being written".
-  startRunOn(session, { from: 0, usesExplicitCuts: true });
-  return { manager, session, dirPath };
-}
-
-
-
-test("a leftover of a run that has ended is not served, and answering does not delete it", async (t) => {
-  const { manager, session, dirPath } = await sessionOnOneDirectory();
-  t.after(async () => {
-    await manager.lifecycle.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  // Opened by a run that is gone. It has a name and no bytes, so there is
-  // nothing to serve.
-  session.runs = new Set();
-  await writeFile(path.join(dirPath, "segment-00001.mp4"), Buffer.alloc(0));
-
-  const result = await manager.serving.getFileStream(SESSION_ID, "segment-00001.mp4");
-
-  assert.equal(result.kind, "warming-up", "nothing servable exists yet, so the viewer waits");
-  // AND ANSWERING A REQUEST DELETES NOTHING. It used to: this test was written
-  // when the serving path cleared up after ended runs, and several runs of an
-  // output share one directory — so what a request removed could be the piece a
-  // LIVE run had just finished. Clearing up belongs to the ending of a run,
-  // which is the only thing that knows what it left open and what it named
-  // and it knows because the piece is under that run's own working name
-  // (`SegmentStore.clearUpAfter`, checked in `segment-store.test.js`). A file
-  // with no bytes is
-  // ignored by everything that reads the directory, so leaving it costs nothing
-  // and deleting it from here costs a segment.
-  const left = (await readdir(dirPath)).filter((name) => name === "segment-00001.mp4");
-  assert.deepEqual(left, ["segment-00001.mp4"]);
-});
-
-test("the current run's own unfinished piece is waited for, never deleted", async (t) => {
-  const { manager, session, dirPath } = await sessionOnOneDirectory();
-  t.after(async () => {
-    await manager.lifecycle.disposeAll();
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  // The same file, in the directory of the run that is alive. It is being
-  // written right now. Deleting it is the 2026-08-06 incident: #225 was removed
-  // 14 s into the run producing it, which then wrote on into a file nobody
-  // could open, and the segment never appeared.
-  //
-  // The live run begins at #1, so #1 is its own first piece.
-  startRunOn(session, { from: 1, producing: false, usesExplicitCuts: true });
-  await writeFile(path.join(dirPath, "segment-00001.mp4"), Buffer.alloc(0));
-
-  const result = await manager.serving.getFileStream(SESSION_ID, "segment-00001.mp4");
-
-  assert.equal(result.kind, "warming-up");
-  const left = (await readdir(dirPath)).filter((name) => name === "segment-00001.mp4");
-  assert.deepEqual(left, ["segment-00001.mp4"], "the live run's own output must be left alone");
-});
-

package/test/published-timeline.test.js

@@ -1,83 +0,0 @@
-/**
- * @file A segment must be stamped where the playlist the player holds says.
- *
- * The field case this pins, 2026-08-17: a seek to 1590.4 s restarted the audio
- * rendition at #291; the produced segments #292 and #293 carried their own
- * positions, 1587.892 s and 1592.692 s, while the playlist the browser was
- * holding said 1585.376 s and 1590.585 s. The browser fetched those two
- * segments **1908 times each** over ten minutes, every one served in 4 ms, and
- * the film never moved: a fragment appended more than `maxBufferHole` away from
- * where the playlist put it is not recognised as buffered, so the player asks
- * for it again.
- *
- * The rule, and the reason it is not simply "always use the file's own time":
- * the boundary table keeps being corrected from produced segments, and the
- * playlist does not. Whichever is right about the FILE, only one of them was
- * sent to the player.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-/**
- * hls.js's own default. A gap smaller than this is skipped; a larger one is a
- * hole, and the fragment across it counts as not loaded.
- */
-const PLAYER_BUFFER_HOLE_SEC = 0.5;
-
-/**
- * The decision under test, in the shape the session manager applies it.
- *
- * @param {{ trueStart: number | null, publishedStart: number }} reading
- * @returns {{ stamp: number, followedPlaylist: boolean }}
- */
-function stampFor({ trueStart, publishedStart }) {
-  if (trueStart === null) {
-    return { stamp: publishedStart, followedPlaylist: true };
-  }
-  if (Math.abs(trueStart - publishedStart) > PLAYER_BUFFER_HOLE_SEC) {
-    return { stamp: publishedStart, followedPlaylist: true };
-  }
-  return { stamp: trueStart, followedPlaylist: false };
-}
-
-test("the field case: a segment far from its playlist position is stamped where the playlist says", () => {
-  const segment292 = stampFor({ trueStart: 1587.892, publishedStart: 1585.376 });
-  assert.equal(segment292.stamp, 1585.376);
-  assert.equal(segment292.followedPlaylist, true);
-
-  const segment293 = stampFor({ trueStart: 1592.692, publishedStart: 1590.585 });
-  assert.equal(segment293.stamp, 1590.585);
-});
-
-test("a file whose index is honest keeps its own position", () => {
-  // Within what a player bridges, the file's own figure is the truthful one and
-  // it is what keeps speech and subtitles together (2026-08-06, 4.17 s of drift
-  // when the picture was stamped from a lying index).
-  const reading = stampFor({ trueStart: 120.13, publishedStart: 120.0 });
-  assert.equal(reading.stamp, 120.13);
-  assert.equal(reading.followedPlaylist, false);
-});
-
-test("the boundary is exactly the player's own tolerance", () => {
-  assert.equal(stampFor({ trueStart: 10.5, publishedStart: 10.0 }).stamp, 10.5);
-  assert.equal(stampFor({ trueStart: 10.51, publishedStart: 10.0 }).stamp, 10.0);
-});
-
-test("a segment that does not say where it begins is stamped from the playlist", () => {
-  assert.equal(stampFor({ trueStart: null, publishedStart: 42.0 }).stamp, 42.0);
-});
-
-test("a corrected boundary does not move the stamp of a session already playing", () => {
-  // The correction writes into the live table; the published one is frozen. If
-  // the stamp followed the live table, every correction would move segments
-  // under a player holding the original playlist — which is the same failure
-  // seen from the other side.
-  const published = [0, 4, 8, 12];
-  const live = [...published];
-  live[2] = 9.7; // corrected from a produced segment
-  const publishedStart = published[2];
-  const reading = stampFor({ trueStart: live[2], publishedStart });
-  assert.equal(publishedStart, 8);
-  assert.equal(reading.stamp, 8, "the player was told 8 s and must be given 8 s");
-});

package/test/quality-offer.test.js

@@ -1,160 +0,0 @@
-/**
- * @file Which heights are on the menu, and when that answer may be reused.
- *
- * The arithmetic is `EncodeCost` and is checked next door. What is checked here
- * is the part that is not arithmetic: whose answer it is, what may never be
- * withdrawn, and the cache — which is the whole reason this is an object, and
- * which had no check of any kind while it lived in the session manager.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { EncodeCost } from "../services/encode/quality/EncodeCost.js";
-import { QualityOffer } from "../services/encode/quality/QualityOffer.js";
-import { startRunOn } from "./helpers/encode-run.js";
-import { outputSpec } from "./helpers/output-spec.js";
-import { runStateOf } from "../services/encode/encode-run-state.js";
-import { qualityStateOf } from "../services/encode/quality/OutputQualityState.js";
-
-/**
- * A session with one run going.
- *
- * @returns {object}
- */
-function sessionProducing() {
-  const session = {
-    id: "1111111122223333",
-    state: "ready",
-    spec: outputSpec(),
-    file: { key: "torrent:abc:0", name: "film.mkv", width: 1920, height: 1080 },
-    output: { encodeWidth: 0, encodeHeight: 0, outputFps: 25, softwarePreset: null },
-    progress: { processedSeconds: 0 },
-    runs: new Set()
-  };
-  startRunOn(session, { from: 0, speedX: 1 });
-  return session;
-}
-
-/**
- * A picture, and the offer's cache in play.
- *
- * @param {object} [supply]
- * @returns {{ offer: QualityOffer, picture: object, computed: () => number, supply: object }}
- */
-function offerOver(
-  supply = { requiredSpeed: null, megabytesPerSecond: null, costPerMegabyte: null },
-  occupancyKnownFor = () => true
-) {
-  const picture = sessionProducing();
-  const outputs = {
-    familyOf: () => [picture],
-    pictureOf: () => picture,
-    variantHeightOf: () => 0,
-    sessionsOn: () => []
-  };
-  const cost = new EncodeCost({
-    outputs,
-    host: () => ({ benchmark: null, decodeModel: null, contentionPenalties: null, availability: null }),
-    runningEncoders: () => 0,
-    encodersRunningNow: () => 0,
-    torrentCostSecFor: () => 0,
-    runsFor: (session) => [...(session.runs ?? [])],
-    stateFor: (session) => runStateOf(session.runs)
-  });
-  let computed = 0;
-  const real = cost.sustainableHeights.bind(cost);
-  cost.sustainableHeights = (params) => {
-    computed += 1;
-    return real(params);
-  };
-  const offer = new QualityOffer({
-    encodeCost: cost,
-    outputs,
-    stateFor: (session) => runStateOf(session.runs),
-    heightsOnScreen: () => [],
-    supplyFor: () => supply,
-    occupancyKnownFor
-  });
-  return { offer, picture, computed: () => computed, supply };
-}
-
-test("the pool gets no positive answer while another occupied output has no measured cost", () => {
-  const { offer } = offerOver(undefined, () => false);
-
-  assert.equal(
-    offer.predictOfferedHeights({ width: 1920, height: 1080, fps: 25, bitrateKbps: 5000 }),
-    null
-  );
-});
-
-test("the offer is computed once and then answered from the cache", () => {
-  // It is asked on the path that serves every playlist, every init and every
-  // segment. Recomputing it each time is the arithmetic of the whole ladder per
-  // request, and its refusal line written for the life of the film.
-  const { offer, picture, computed } = offerOver();
-
-  offer.offeredHeightsFor(picture);
-  offer.offeredHeightsFor(picture);
-
-  assert.equal(computed(), 1);
-});
-
-test("what the swarm is doing is part of what identifies that cached answer", () => {
-  // The bar rises when the reader meets interruptions and the torrent's price
-  // moves every few seconds. Left out of the key, a menu computed while nothing
-  // was known about the swarm would stand for the whole film — offering steps
-  // supply cannot support, and passing every route guard on the way.
-  const supply = { requiredSpeed: null, megabytesPerSecond: null, costPerMegabyte: null };
-  const { offer, picture, computed } = offerOver(supply);
-  offer.offeredHeightsFor(picture);
-
-  supply.requiredSpeed = 6.12;
-  offer.offeredHeightsFor(picture);
-  assert.equal(computed(), 2, "the bar this file's own interruptions demand moved");
-
-  supply.megabytesPerSecond = 1.4;
-  offer.offeredHeightsFor(picture);
-  assert.equal(computed(), 3, "and so did what a viewer draws through it");
-
-  supply.costPerMegabyte = 0.05;
-  offer.offeredHeightsFor(picture);
-  assert.equal(computed(), 4, "and what a megabyte costs this process");
-});
-
-test("and so is what each running encode was last seen doing", () => {
-  // It is an input twice over — it withdraws a step measured below realtime,
-  // and it prices every running picture in the committed total. On a COPIED
-  // picture nothing else in the key ever moves, so without this the menu would
-  // be pinned to what was computed before anything had been measured.
-  const { offer, picture, computed } = offerOver();
-  offer.offeredHeightsFor(picture);
-
-  qualityStateOf(picture).lastAloneSpeed = 0.4;
-  offer.offeredHeightsFor(picture);
-
-  assert.equal(computed(), 2);
-});
-
-test("a step asking for the family's answer does not keep it as its own", () => {
-  // A step is a session of its own and knows only its own encode: asked while
-  // the viewer watches 240p, the 240p session priced the 1080p step as a
-  // re-encode — because ITS video is re-encoded — and refused it on a host that
-  // had been serving that very height by COPY minutes earlier. Only the picture
-  // knows what the family can do with the source, so the picture answers; and
-  // the answer must not then be filed on the asker, whose own flags are what
-  // made the wrong answer possible in the first place.
-  const { offer, picture } = offerOver();
-  const step = sessionProducing();
-  step.id = "9999999988887777";
-  step.spec = outputSpec({ transcodeVideo: true });
-
-  const answer = offer.offeredHeightsFor(step);
-
-  assert.ok(Array.isArray(answer), "the step is still answered — its viewer is watching it");
-  assert.equal(qualityStateOf(step).offeredHeightsCache, undefined, "and nothing is filed on the asker");
-  assert.equal(
-    qualityStateOf(picture).offeredHeightsCache,
-    undefined,
-    "nor on the picture, whose own key was never the one this answer was computed against"
-  );
-});