@torrent-tv/proxy 2.89.16 → 2.89.18

package/test/data-channel-frame.test.js

@@ -1,63 +0,0 @@
-/**
- * @file The wire format of a body frame.
- *
- * The browser parses these bytes, so the layout is a contract:
- * `[flags(1)][idLen(1)][requestId][payload]`. The framing was rewritten to stop
- * copying every chunk twice (75.9 ms per 13 MB segment against 40.0 on the
- * field host), and a rewrite of something a client parses needs the format
- * pinned down, not just the timing.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { encodeFrame } from "../services/transport/data-channel-handler.js";
-
-const requestId = Buffer.from("abc123", "ascii");
-
-test("a body frame carries the id and the payload unchanged", () => {
-  const payload = Buffer.from([1, 2, 3, 4, 250, 255]);
-  const frame = encodeFrame(requestId, payload, false);
-
-  assert.equal(frame[0], 0, "flagged as done");
-  assert.equal(frame[1], requestId.length);
-  assert.deepEqual(frame.subarray(2, 2 + requestId.length), requestId);
-  assert.deepEqual(frame.subarray(2 + requestId.length), payload);
-  assert.equal(frame.length, 2 + requestId.length + payload.length);
-});
-
-test("the done frame carries no payload", () => {
-  const frame = encodeFrame(requestId, null, true);
-
-  assert.equal(frame[0], 1);
-  assert.equal(frame.length, 2 + requestId.length);
-});
-
-test("an empty payload is treated as no payload", () => {
-  const frame = encodeFrame(requestId, new Uint8Array(0), false);
-  assert.equal(frame.length, 2 + requestId.length);
-});
-
-test("a payload that is a view into a larger buffer is copied correctly", () => {
-  // Chunks arrive as views into a bigger allocation, so copying the whole
-  // underlying buffer instead of the view would send the wrong bytes at the
-  // wrong length — silently.
-  const backing = Buffer.alloc(64, 9);
-  backing.fill(42, 16, 32);
-  const view = new Uint8Array(backing.buffer, backing.byteOffset + 16, 16);
-
-  const frame = encodeFrame(requestId, view, false);
-
-  assert.equal(frame.length, 2 + requestId.length + 16);
-  assert.deepEqual(frame.subarray(2 + requestId.length), Buffer.alloc(16, 42));
-});
-
-test("a large payload survives framing byte for byte", () => {
-  const payload = Buffer.allocUnsafeSlow(64 * 1024);
-  for (let at = 0; at < payload.length; at += 1) {
-    payload[at] = at % 251;
-  }
-
-  const frame = encodeFrame(requestId, payload, false);
-
-  assert.deepEqual(frame.subarray(2 + requestId.length), payload);
-});

package/test/data-channel-viewer-lifecycle.test.js

@@ -1,193 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createDataChannelHandler } from "../services/transport/data-channel-handler.js";
-
-class FakeDataChannel {
-  constructor(label) {
-    this.label = label;
-    this.messages = [];
-    this.closed = null;
-  }
-
-  getLabel() {
-    return this.label;
-  }
-
-  onMessage(callback) {
-    this.message = callback;
-  }
-
-  onClosed(callback) {
-    this.closed = callback;
-  }
-
-  onError() {}
-
-  sendMessage(message) {
-    this.messages.push(message);
-  }
-
-  close() {
-    this.closed?.();
-  }
-}
-
-test("a viewer remains present until every data channel on the connection closes", () => {
-  const gone = [];
-  const handler = createDataChannelHandler({
-    proxyPort: 9090,
-    getTransportSnapshot: () => ({ bytesSent: 0, bytesReceived: 0 }),
-    onViewerGone: (consumerId, reason) => gone.push({ consumerId, reason })
-  });
-  const media = new FakeDataChannel("proxy");
-  const control = new FakeDataChannel("proxy-control");
-  const probe = new FakeDataChannel("proxy-fast");
-
-  handler.handleChannel("peer-session", media);
-  handler.handleChannel("peer-session", control);
-  handler.handleChannel("peer-session", probe);
-  control.message(JSON.stringify({ type: "viewer", consumerId: "viewer-1" }));
-
-  control.close();
-  assert.deepEqual(gone, [], "closing the control channel alone does not release the viewer");
-
-  media.close();
-  assert.deepEqual(gone, [], "the viewer remains while the probe channel is still open");
-
-  probe.close();
-  assert.deepEqual(gone, [
-    { consumerId: "viewer-1", reason: "the connection closed" }
-  ]);
-});
-
-test("a closing connection does not release a viewer already named on its replacement", () => {
-  const gone = [];
-  const handler = createDataChannelHandler({
-    proxyPort: 9090,
-    getTransportSnapshot: () => ({ bytesSent: 0, bytesReceived: 0 }),
-    onViewerGone: (consumerId, reason) => gone.push({ consumerId, reason })
-  });
-  const oldControl = new FakeDataChannel("proxy-control");
-  const oldMedia = new FakeDataChannel("proxy");
-  const newControl = new FakeDataChannel("proxy-control");
-  const newMedia = new FakeDataChannel("proxy");
-
-  handler.handleChannel("old-peer", oldControl);
-  handler.handleChannel("old-peer", oldMedia);
-  oldControl.message(JSON.stringify({ type: "viewer", consumerId: "viewer-1" }));
-  handler.handleChannel("new-peer", newControl);
-  handler.handleChannel("new-peer", newMedia);
-  newControl.message(JSON.stringify({ type: "viewer", consumerId: "viewer-1" }));
-
-  oldControl.close();
-  oldMedia.close();
-  assert.deepEqual(gone, [], "the old connection no longer owns the viewer");
-
-  newControl.close();
-  assert.deepEqual(gone, [], "the replacement still has its media channel");
-  newMedia.close();
-  assert.deepEqual(gone, [
-    { consumerId: "viewer-1", reason: "the connection closed" }
-  ]);
-});
-
-/**
- * A page on an old connection that raises a trial connection beside it, the
- * way it does when the old one stops delivering.
- */
-function trialBeside(gone) {
-  const handler = createDataChannelHandler({
-    proxyPort: 9090,
-    getTransportSnapshot: () => ({ bytesSent: 0, bytesReceived: 0 }),
-    viewersWantingCues: () => ["viewer-1"],
-    onViewerGone: (consumerId, reason) => gone.push({ consumerId, reason })
-  });
-  const old = { control: new FakeDataChannel("proxy-control"), media: new FakeDataChannel("proxy") };
-  const trial = { control: new FakeDataChannel("proxy-control"), media: new FakeDataChannel("proxy") };
-  handler.handleChannel("old-peer", old.control);
-  handler.handleChannel("old-peer", old.media);
-  old.control.message(JSON.stringify({ type: "viewer", consumerId: "viewer-1" }));
-  handler.handleChannel("trial-peer", trial.control);
-  handler.handleChannel("trial-peer", trial.media);
-  trial.control.message(JSON.stringify({ type: "viewer", consumerId: "viewer-1" }));
-  const cuesOn = (channel) => channel.messages.filter((message) => message.includes("subtitle-cues")).length;
-  const push = () =>
-    handler.publishSubtitleCues({
-      sourceKey: "torrent:abc",
-      fileIndex: 0,
-      trackIndex: 0,
-      cues: [{ start: 1, end: 2, text: "line" }],
-      language: "en",
-      detectedLanguage: null,
-      cursor: 1
-    });
-  return { old, trial, cuesOn, push };
-}
-
-test("closing a trial connection keeps the viewer and their cues on the old one", () => {
-  // The old connection delivered again before the trial was adopted, so the
-  // page closes the trial. The viewer never left.
-  const gone = [];
-  const { old, trial, cuesOn, push } = trialBeside(gone);
-  trial.control.close();
-  trial.media.close();
-  assert.deepEqual(gone, [], "the viewer is still on the old connection");
-  push();
-  assert.equal(cuesOn(old.control), 1, "cues reach the channel the viewer named themselves on");
-  old.control.close();
-  old.media.close();
-  assert.deepEqual(gone, [{ consumerId: "viewer-1", reason: "the connection closed" }]);
-});
-
-test("after a trial connection is adopted, cues go to it and the old one's close releases nobody", () => {
-  const gone = [];
-  const { old, trial, cuesOn, push } = trialBeside(gone);
-  push();
-  assert.equal(cuesOn(trial.control), 1, "the newest connection carrying the viewer is used");
-  assert.equal(cuesOn(old.control), 0);
-  old.control.close();
-  old.media.close();
-  assert.deepEqual(gone, []);
-  push();
-  assert.equal(cuesOn(trial.control), 2);
-});
-
-test("a viewer whose newest channel closed is reached on the older connection", () => {
-  const gone = [];
-  const { old, trial, cuesOn, push } = trialBeside(gone);
-  trial.control.close();
-  push();
-  assert.equal(cuesOn(old.control), 1);
-  assert.deepEqual(gone, [], "the trial connection still has its media channel");
-});
-
-test("a connection the transport no longer knows is not probed any more, though no channel said it closed", (t) => {
-  t.mock.timers.enable({ apis: ["setInterval", "setTimeout", "Date"] });
-  let alive = true;
-  const handler = createDataChannelHandler({
-    proxyPort: 9090,
-    getTransportSnapshot: () => (alive ? { bytesSent: 0, bytesReceived: 0 } : null),
-    onViewerGone: () => {}
-  });
-  const channels = ["proxy", "proxy-control", "proxy-fast"].map((label) => new FakeDataChannel(label));
-  for (const channel of channels) {
-    handler.handleChannel("trial-peer", channel);
-  }
-  const probes = () =>
-    channels.reduce((sum, channel) => sum + channel.messages.filter((message) => message.includes('"probe"')).length, 0);
-  t.mock.timers.tick(2_000);
-  assert.ok(probes() > 0, "an open connection is probed");
-
-  // Field 2026-10-04: the peer connection closed 70 ms after its channels
-  // opened, and none of them reported `onClosed`.
-  alive = false;
-  const advance = (ms) => {
-    // Second by second: the watcher compares the clock between its own ticks,
-    // and one long jump lands every tick on the same instant.
-    for (let elapsed = 0; elapsed < ms; elapsed += 1_000) t.mock.timers.tick(1_000);
-  };
-  advance(30_000);
-  const afterGone = probes();
-  advance(30_000);
-  assert.equal(probes(), afterGone, "nothing is sent on a connection that is gone");
-});

package/test/dead-torrent-handle.test.js

@@ -1,52 +0,0 @@
-/**
- * @file A torrent that was destroyed must not be handed to a reader.
- *
- * The worker remembers each source as a promise, and only ever forgot one when
- * the ADD failed. But the pool destroys a torrent that has gone unread for a
- * quarter of an hour, and under disk pressure — clearing its own map, not this
- * one. The promise then went on resolving to a corpse: a destroyed torrent
- * keeps its object and loses its files.
- *
- * What that did to a viewer, measured 2026-08-06 on two sessions in a row: the
- * plan answered from cache in 23 ms, the session was created from cache in
- * 2 ms, nothing waited for metadata because everything believed the torrent was
- * known, and ffmpeg's first read died 130 ms in with `File 0 not found`. Every
- * request for the playlist then answered 500 until the viewer gave up.
- *
- * The rule under test is the whole fix: a handle that cannot be read from is
- * not returned, it is replaced.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { isUsableTorrentHandle } from "../services/torrent/worker/handle-state.js";
-
-test("a live torrent is usable", () => {
-  assert.equal(isUsableTorrentHandle({ destroyed: false, files: [{ name: "a.mkv" }] }), true);
-});
-
-test("a destroyed torrent is not, even while it still lists files", () => {
-  assert.equal(
-    isUsableTorrentHandle({ destroyed: true, files: [{ name: "a.mkv" }] }),
-    false,
-    "WebTorrent's own flag is the earliest signal that a handle is finished"
-  );
-});
-
-test("a torrent with no files is not — that is what the reader actually hits", () => {
-  assert.equal(
-    isUsableTorrentHandle({ destroyed: false, files: [] }),
-    false,
-    "an empty file list is what produced `File 0 not found` in the field"
-  );
-  assert.equal(
-    isUsableTorrentHandle({ destroyed: false }),
-    false,
-    "and a handle with no file list at all is the same case"
-  );
-});
-
-test("nothing at all is not usable", () => {
-  assert.equal(isUsableTorrentHandle(null), false);
-  assert.equal(isUsableTorrentHandle(undefined), false);
-});

package/test/declared-rates.test.js

@@ -1,116 +0,0 @@
-/**
- * @file What the master playlist declares a variant carries.
- *
- * Measured, and the measurement was available all along: it used to be
- * `height * height * 3.2`, justified by a comment saying no measurement existed
- * before encoding starts. Field 2026-09-08: 3.73 Mbit/s declared for a file
- * carrying 18.4, and the browser sizes its cushion in BYTES from that figure —
- * 120 s asked bought 26 s of film, and the deepest it ever held was 17.1 s.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { declaredRates } from "../services/encode/output/rates.js";
-import { bitrateFor } from "../services/encode/output/playlists.js";
-
-// The field file: 2 806 246 976 bytes over 20:18, cut into 291 pieces.
-const FIELD = { fileLength: 2_806_246_976, durationSeconds: 1218.73 };
-
-test("the average is the file's own length over its duration", () => {
-  const { averageBitsPerSecond } = declaredRates(FIELD);
-
-  // 18.4 Mbit/s, against the 3.73 that was declared.
-  assert.ok(
-    Math.abs(averageBitsPerSecond / 1_000_000 - 18.42) < 0.01,
-    `got ${averageBitsPerSecond}`
-  );
-});
-
-test("nothing measured is stated as nothing, not as a guess", () => {
-  assert.deepEqual(
-    declaredRates({ fileLength: 0, durationSeconds: 0 }),
-    { averageBitsPerSecond: 0, peakOverAverage: 1 }
-  );
-  assert.deepEqual(
-    declaredRates({ fileLength: 100, durationSeconds: 0 }),
-    { averageBitsPerSecond: 0, peakOverAverage: 1 }
-  );
-});
-
-test("the peak comes from the biggest piece made and the span it covers", () => {
-  // The field peak: 38.4 MB over 4.2 s is 73 Mbit/s, four times the average.
-  const boundaries = Array.from({ length: 292 }, (_, index) => index * 4.2);
-  const { averageBitsPerSecond, peakOverAverage } = declaredRates({
-    ...FIELD,
-    largest: { index: 2, size: 40_288_299 },
-    boundaries
-  });
-
-  const peak = averageBitsPerSecond * peakOverAverage;
-  assert.ok(Math.abs(peak / 1_000_000 - 76.7) < 0.5, `got ${peak / 1_000_000}Mbit/s`);
-});
-
-test("no piece made yet means the peak is not yet measured, so it equals the average", () => {
-  // A ratio invented meanwhile is exactly the fabrication this replaced.
-  assert.equal(declaredRates(FIELD).peakOverAverage, 1);
-  assert.equal(
-    declaredRates({ ...FIELD, largest: { index: -1, size: 0 }, boundaries: [0, 4] }).peakOverAverage,
-    1
-  );
-});
-
-test("the peak is never below the average", () => {
-  // A short session whose only piece happens to be a small one must not lower
-  // the figure the player sizes its cushion from.
-  const boundaries = Array.from({ length: 292 }, (_, index) => index * 4.2);
-  assert.equal(
-    declaredRates({ ...FIELD, largest: { index: 5, size: 1000 }, boundaries }).peakOverAverage,
-    1
-  );
-});
-
-test("a smaller picture is declared at the pixel share of the source's rate", () => {
-  const measured = 18_420_000;
-
-  assert.equal(
-    bitrateFor({ averageBitsPerSecond: measured, height: 1080, sourceHeight: 1080 }),
-    Math.round(measured),
-    "the source's own height carries the source's bits"
-  );
-  assert.equal(
-    bitrateFor({ averageBitsPerSecond: measured, height: 2160, sourceHeight: 1080 }),
-    Math.round(measured),
-    "and a height above it carries no more — there is nothing to upscale from"
-  );
-  assert.equal(
-    bitrateFor({ averageBitsPerSecond: measured, height: 540, sourceHeight: 1080 }),
-    Math.round(measured / 4),
-    "half the height is a quarter of the pixels"
-  );
-});
-
-test("a capped height is declared at its cap, which is exact", () => {
-  assert.equal(
-    bitrateFor({ averageBitsPerSecond: 18_420_000, height: 720, sourceHeight: 1080, capKbps: 2500 }),
-    2_500_000,
-    "what we impose is known, not estimated"
-  );
-  assert.equal(
-    bitrateFor({ averageBitsPerSecond: 1_000_000, height: 1080, sourceHeight: 1080, capKbps: 99_000 }),
-    1_000_000,
-    "and a cap above what the source carries takes nothing away from it"
-  );
-});
-
-test("the floor is a floor on what may be declared, not a belief about content", () => {
-  assert.equal(
-    bitrateFor({ averageBitsPerSecond: 0, height: 1080, sourceHeight: 1080 }),
-    400_000,
-    "a file whose rate is not known yet"
-  );
-  assert.equal(
-    bitrateFor({ averageBitsPerSecond: 18_420_000, height: 4, sourceHeight: 1080 }),
-    400_000,
-    "and a variant so small the arithmetic would go under it"
-  );
-});

package/test/declared-tracks.test.js

@@ -1,43 +0,0 @@
-/**
- * @file What the proxy promises the browser must be answerable.
- *
- * The session manager asks the planner's media-info cache which tracks the
- * output will carry. That cache never held the codecs — it holds dimensions,
- * duration, fps, start time and an HDR flag — so the read produced `undefined`
- * for both and the declaration came out `{video: false, audio: false}` for
- * EVERY session since the check existed. Measured 2026-08-11 in the field.
- *
- * Nothing caught it: the writer and the reader each looked correct alone, and
- * no test ever compared the shape of what is stored with the shape of what is
- * read. That comparison is this file's whole job.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-
-const planner = readFileSync(new URL("../services/media/playback-planner.js", import.meta.url), "utf8");
-const sessions = readFileSync(new URL("../services/encode/Renditions.js", import.meta.url), "utf8");
-
-test("every field the declaration reads is a field the cache stores", () => {
-  // What `declaredTracks` reads off the cached media info.
-  const read = [...sessions.matchAll(/probed\?\.([A-Za-z]+)/g)].map((match) => match[1]);
-  assert.ok(read.length > 0, "the declaration must read something, or it declares nothing");
-
-  const stored = planner.slice(planner.indexOf("mediaInfoCache.set("));
-  for (const field of new Set(read)) {
-    assert.ok(
-      stored.includes(`${field}:`),
-      `the declaration reads "${field}" and the media-info cache never stores it — ` +
-      "the read yields undefined and the promise silently becomes false"
-    );
-  }
-});
-
-test("an empty container track list remains pending for late sidecar metadata", () => {
-  assert.match(
-    planner,
-    /complete: Array\.isArray\(tracks\) && tracks\.length > 0/,
-    "ContainerOrchestrator leaves empty track reads uncached while the header is unavailable"
-  );
-});

package/test/decode-cost-fit.test.js

@@ -1,202 +0,0 @@
-/**
- * @file The decode-cost fit, and the case it exists to prevent.
- *
- * The failure being pinned is real and dated: on 2026-08-17 three clips for
- * three unknowns returned `0.007542 × Mpx/s + 0.000000 × Mbit/s + 0.0000 s/s`,
- * with the bitrate term and the constant exactly zero, and the prediction built
- * on it was 1.8-2.2x optimistic. An exact system cannot notice that two of its
- * points said the same thing; these tests hold the replacement to noticing.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { decodeCostOf, fitDecodeCost } from "../services/encode/decode-cost-fit.js";
-
-const FPS = 24;
-
-/**
- * A clip's measurement, priced by a known truth so a fit can be checked against
- * the answer it should recover.
- *
- * @param {number} width
- * @param {number} height
- * @param {number} megabitsPerSecond
- * @param {{ pixel: number, bitrate: number, constant: number, noise?: number }} truth
- * @returns {{ megapixelsPerSecond: number, megabitsPerSecond: number, costSecondsPerSecond: number }}
- */
-function clip(width, height, megabitsPerSecond, truth) {
-  const megapixelsPerSecond = (width * height * FPS) / 1e6;
-  const cost =
-    truth.pixel * megapixelsPerSecond + truth.bitrate * megabitsPerSecond + truth.constant + (truth.noise ?? 0);
-  return { megapixelsPerSecond, megabitsPerSecond, costSecondsPerSecond: cost };
-}
-
-/** The set the clips were cut to: three sizes, two bitrates, varied independently. */
-const SIZES = [
-  [1920, 1080],
-  [1280, 720],
-  [854, 480]
-];
-const BITRATES = [9.5, 1.1];
-
-/**
- * @param {{ pixel: number, bitrate: number, constant: number }} truth
- * @param {number[]} [noise] - Per-clip disturbance, in order.
- * @returns {ReturnType<typeof clip>[]}
- */
-function wellConditionedSet(truth, noise = []) {
-  const samples = [];
-  let index = 0;
-  for (const [width, height] of SIZES) {
-    for (const bitrate of BITRATES) {
-      samples.push(clip(width, height, bitrate, { ...truth, noise: noise[index] ?? 0 }));
-      index += 1;
-    }
-  }
-  return samples;
-}
-
-test("a well-conditioned set recovers every term", () => {
-  const truth = { pixel: 0.0055, bitrate: 0.0099, constant: 0.057 };
-  const model = fitDecodeCost(wellConditionedSet(truth));
-
-  assert.ok(model, "six clips over three unknowns must produce a model");
-  assert.equal(model.shape, "pixels+bitrate+constant");
-  assert.deepEqual(model.dropped, []);
-  assert.ok(Math.abs(model.pixelTerm - truth.pixel) < 1e-6, `pixel term ${model.pixelTerm}`);
-  assert.ok(Math.abs(model.bitrateTerm - truth.bitrate) < 1e-6, `bitrate term ${model.bitrateTerm}`);
-  assert.ok(Math.abs(model.constantTerm - truth.constant) < 1e-6, `constant ${model.constantTerm}`);
-});
-
-test("three clips are refused outright — an exact system cannot see its own degeneracy", () => {
-  // Exactly the shape that shipped: two clips at the same pixel rate differing
-  // only in bitrate, and a third at another size.
-  const truth = { pixel: 0.0055, bitrate: 0.0099, constant: 0.057 };
-  const three = [clip(1920, 1080, 11.4, truth), clip(1920, 1080, 0.97, truth), clip(1280, 720, 2.25, truth)];
-
-  assert.equal(
-    fitDecodeCost(three),
-    null,
-    "with no residual there is nothing to notice a degeneracy with, so no model may be published"
-  );
-});
-
-test("a term the measurements do not determine is dropped, and said so", () => {
-  // A host whose decoding does not depend on bitrate at all: the term is not
-  // small, it is absent. What must NOT happen is publishing a zero as though it
-  // had been measured.
-  const truth = { pixel: 0.0055, bitrate: 0, constant: 0.057 };
-  // Deliberately NOT alternating with the bitrate column: an earlier version
-  // of this test put positive noise on every high-bitrate clip and negative on
-  // every low one, which IS a bitrate signal — the fit found it, correctly, and
-  // the test was wrong.
-  const noise = [0.004, 0.003, -0.004, 0.002, -0.003, -0.002];
-  const model = fitDecodeCost(wellConditionedSet(truth, noise));
-
-  assert.ok(model);
-  assert.ok(model.dropped.includes("bitrate"), `dropped: ${model.dropped.join(",") || "nothing"}`);
-  assert.equal(model.bitrateTerm, 0);
-  assert.ok(model.shape.includes("pixels"));
-});
-
-test("noise in the readings does not become a term", () => {
-  // Pure noise around a pixels-only truth, larger than any bitrate effect.
-  const truth = { pixel: 0.0055, bitrate: 0, constant: 0 };
-  const noise = [0.01, 0.009, -0.012, 0.011, -0.008, -0.01];
-  const model = fitDecodeCost(wellConditionedSet(truth, noise));
-
-  assert.ok(model);
-  assert.ok(model.pixelTerm > 0, "the one relationship every reading agrees on survives");
-  assert.ok(
-    model.dropped.length > 0,
-    "and the terms the noise could have supplied are reported as undetermined"
-  );
-});
-
-test("without a measurable dependence on the source there is no model", () => {
-  // Every clip costs the same regardless of size or bitrate: nothing here says
-  // what a bigger picture costs, and inventing it is worse than having none.
-  const flat = wellConditionedSet({ pixel: 0, bitrate: 0, constant: 0.3 });
-  assert.equal(fitDecodeCost(flat), null);
-  assert.equal(fitDecodeCost([]), null);
-  assert.equal(fitDecodeCost(null), null);
-});
-
-test("readings that are not measurements are left out", () => {
-  const truth = { pixel: 0.0055, bitrate: 0.0099, constant: 0.057 };
-  const samples = [
-    ...wellConditionedSet(truth),
-    { megapixelsPerSecond: Number.NaN, megabitsPerSecond: 5, costSecondsPerSecond: 1 },
-    { megapixelsPerSecond: 20, megabitsPerSecond: 5, costSecondsPerSecond: 0 }
-  ];
-  const model = fitDecodeCost(samples);
-  assert.ok(model);
-  assert.equal(model.samples, 6);
-});
-
-test("what a model prices a film at", () => {
-  const model = fitDecodeCost(wellConditionedSet({ pixel: 0.0055, bitrate: 0.0099, constant: 0.057 }));
-  // The field film: 1080p24 at about 8 Mbit/s.
-  const cost = decodeCostOf(model, { megapixelsPerSecond: 49.77, megabitsPerSecond: 8 });
-  assert.ok(cost > 0);
-  // Which is a decode speed of 1/cost — the figure the quality offer rests on.
-  assert.ok(1 / cost > 1 && 1 / cost < 10, `decodes at ${(1 / cost).toFixed(2)}x`);
-});
-
-/**
- * THE ORDERINGS, STATED WHERE THEY ARE DETERMINISTIC.
- *
- * What the quality offer needs of this model is not precision but ORDER: a
- * bigger, richer, dearer-to-decode source must never be priced cheaper, because
- * the model is asked about rungs nobody has decoded. That is a property of the
- * fit, and it is a property of the fit whatever machine runs the test.
- *
- * These three used to be asserted over LIVE readings — decode two clips through
- * real ffmpeg and require the smaller to come back faster. That measures the
- * scheduler, not the code: four failures in one day, and the worst of them read
- * 480p at 8.4x against 1080p at 20.8x, an inversion of two and a half times
- * with nothing wrong. The readings themselves are unavailable to a test at all,
- * since a clip that "said nothing" under load makes the whole benchmark answer
- * with nothing.
- */
-
-test("a bigger picture is priced dearer than a smaller one of the same bitrate", () => {
-  const model = fitDecodeCost(wellConditionedSet({ pixel: 0.0055, bitrate: 0.0099, constant: 0.057 }));
-  const big = decodeCostOf(model, { megapixelsPerSecond: (1920 * 1080 * FPS) / 1e6, megabitsPerSecond: 4 });
-  const small = decodeCostOf(model, { megapixelsPerSecond: (854 * 480 * FPS) / 1e6, megabitsPerSecond: 4 });
-
-  assert.ok(big > small, `1080p at ${big.toFixed(4)} s/s against 480p at ${small.toFixed(4)}`);
-});
-
-test("a thicker stream is priced dearer than a thin one of the same size", () => {
-  const model = fitDecodeCost(wellConditionedSet({ pixel: 0.0055, bitrate: 0.0099, constant: 0.057 }));
-  const pixels = (854 * 480 * FPS) / 1e6;
-  const thick = decodeCostOf(model, { megapixelsPerSecond: pixels, megabitsPerSecond: 9.5 });
-  const thin = decodeCostOf(model, { megapixelsPerSecond: pixels, megabitsPerSecond: 1.1 });
-
-  assert.ok(thick > thin, `9.5 Mbit/s at ${thick.toFixed(4)} s/s against 1.1 at ${thin.toFixed(4)}`);
-});
-
-test("a family measured to be dearer prices its own sources dearer", () => {
-  // Why the model is fitted per codec family at all: HEVC costs more than H.264
-  // for the same picture on the same machine, so a source that has to be
-  // re-encoded — which is usually one the browser could not decode — must be
-  // priced by its own family and not by H.264's.
-  const cheap = { pixel: 0.0055, bitrate: 0.0099, constant: 0.057 };
-  const dear = { pixel: 0.011, bitrate: 0.0198, constant: 0.114 };
-  const model = {
-    ...fitDecodeCost(wellConditionedSet(cheap)),
-    families: {
-      h264: fitDecodeCost(wellConditionedSet(cheap)),
-      hevc: fitDecodeCost(wellConditionedSet(dear))
-    }
-  };
-  const source = { megapixelsPerSecond: (854 * 480 * FPS) / 1e6, megabitsPerSecond: 1.1 };
-
-  assert.ok(
-    decodeCostOf(model, { ...source, codec: "hevc" }) >
-      decodeCostOf(model, { ...source, codec: "h264" }),
-    "the family chooses the terms, and the dearer family answers dearer"
-  );
-});