@torrent-tv/proxy 2.85.1 → 2.87.0

package/test/keyframes-belong-to-the-file.test.js

@@ -6,127 +6,244 @@
  * used to read it twice — which is what two viewers opening one film do,
  * measured 13 ms apart on 2026-09-03 — and the answer decides whether the
  * picture can be copied at all, so it has to be one answer.
+ *
+ * And it has to be one OBJECT, not one value: a session created while the read
+ * is still running must see the answer when it lands. Held as a value it could
+ * not, and the read that outran its budget was lost to every session already
+ * made.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { HlsSessionManager } from "../services/hls-session-manager.js";
-import { Container } from "../services/container/Container.js";
+import { KeyframeTables } from "../services/media/KeyframeTables.js";
+import { KeyframeTable } from "../services/media/container/KeyframeTable.js";
+import { Container } from "../services/media/container/Container.js";
+
+const QUIET = { info: () => {}, warn: () => {} };
 
 /**
- * @returns {HlsSessionManager}
+ * @param {(params: object) => Promise<object | null>} readTable
+ * @param {number} [budgetMs]
+ * @returns {KeyframeTables}
  */
-function manager() {
-  return new HlsSessionManager({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
+function tables(readTable, budgetMs = 1_000) {
+  return new KeyframeTables({ readTable, budgetMs, logger: QUIET });
 }
 
-test("two sessions asking at once make one read and join one wait", async () => {
-  const session = manager();
+const FILE = { sourceKey: "torrent:abc", fileIndex: 0, logName: "a.mkv" };
+
+test("two askers at once make one read and join one wait", async () => {
   let reads = 0;
   let answer = null;
-  session.getContainerKeyframes = () => {
+  const keyframes = tables(() => {
     reads += 1;
     return new Promise((resolve) => {
       answer = resolve;
     });
-  };
+  });
 
-  const first = session.warmKeyframeIndex({ sourceKey: "torrent:abc", fileIndex: 0, logName: "a.mkv" });
-  const second = session.warmKeyframeIndex({ sourceKey: "torrent:abc", fileIndex: 0, logName: "a.mkv" });
+  const first = keyframes.warm(FILE);
+  const second = keyframes.warm(FILE);
   assert.equal(reads, 1, "the second asker joined the read already running");
 
-  answer({ times: [0, 4, 8], tolerance: 0 });
+  answer({ times: [0, 4, 8], tolerance: 0, format: "matroska" });
   await Promise.all([first, second]);
   assert.equal(reads, 1);
 });
 
-test("the answer is remembered for the file, so a later session reads nothing", async () => {
-  const session = manager();
+test("the answer is remembered for the file, so a later asker reads nothing", async () => {
   let reads = 0;
-  session.getContainerKeyframes = async () => {
+  const keyframes = tables(async () => {
     reads += 1;
-    return { times: [0, 4, 8], tolerance: 0 };
-  };
+    return { times: [0, 4, 8], tolerance: 0, format: "matroska" };
+  });
 
-  await session.warmKeyframeIndex({ sourceKey: "torrent:abc", fileIndex: 0, logName: "a.mkv" });
-  await session.warmKeyframeIndex({ sourceKey: "torrent:abc", fileIndex: 0, logName: "a.mkv" });
+  await keyframes.warm(FILE);
+  await keyframes.warm(FILE);
 
   assert.equal(reads, 1);
 });
 
 test("two files of one torrent are two answers", async () => {
-  const session = manager();
   const asked = [];
-  session.getContainerKeyframes = async ({ fileIndex }) => {
+  const keyframes = tables(async ({ fileIndex }) => {
     asked.push(fileIndex);
-    return { times: [0, 4], tolerance: 0 };
-  };
+    return { times: [0, 4], tolerance: 0, format: "matroska" };
+  });
 
-  await session.warmKeyframeIndex({ sourceKey: "torrent:abc", fileIndex: 0, logName: "a.mkv" });
-  await session.warmKeyframeIndex({ sourceKey: "torrent:abc", fileIndex: 1, logName: "b.mkv" });
+  await keyframes.warm({ sourceKey: "torrent:abc", fileIndex: 0, logName: "a.mkv" });
+  await keyframes.warm({ sourceKey: "torrent:abc", fileIndex: 1, logName: "b.mkv" });
 
   assert.deepEqual(asked, [0, 1]);
 });
 
 test("a file with no readable index says so once, and keeps saying it", async () => {
-  const session = manager();
   let reads = 0;
-  session.getContainerKeyframes = async () => {
+  const keyframes = tables(async () => {
     reads += 1;
     return null;
-  };
+  });
 
-  await session.warmKeyframeIndex({ sourceKey: "torrent:abc", fileIndex: 0, logName: "a.ts" });
-  await session.warmKeyframeIndex({ sourceKey: "torrent:abc", fileIndex: 0, logName: "a.ts" });
+  await keyframes.warm({ sourceKey: "torrent:abc", fileIndex: 0, logName: "a.ts" });
+  await keyframes.warm({ sourceKey: "torrent:abc", fileIndex: 0, logName: "a.ts" });
 
   // "No index" is an answer about the file — it is what makes a copy of it
   // re-encode instead — and it must be the same answer for every viewer.
   assert.equal(reads, 1);
+  const table = keyframes.of(FILE);
+  assert.equal(table.answered, true, "something came back");
+  assert.equal(table.readable, false, "and what came back was nothing");
+});
+
+test("a table read after a session was made still reaches it", async () => {
+  let answer = null;
+  const keyframes = tables(() => new Promise((resolve) => { answer = resolve; }), 30);
+
+  // What a session does: ask for the file's table, wait as long as it may, and
+  // carry whatever it was handed.
+  const { table, arrived } = await keyframes.within(FILE);
+  assert.equal(arrived, false, "the read outran the budget");
+  assert.equal(table.answered, false, "and nothing has answered yet, which is not the same as no keyframes");
+
+  answer({ times: [0, 4, 8], tolerance: 0, format: "matroska" });
+  await new Promise((resolve) => { setImmediate(resolve); });
+
+  // The session is holding THIS object, so the late answer is in its hands
+  // without anybody having gone round telling it.
+  assert.equal(table.answered, true);
+  assert.deepEqual(table.times, [0, 4, 8]);
+  assert.equal(keyframes.of(FILE), table, "and the file still has one table, not two");
 });
 
-test("a container reads its own table once", async () => {
+test("a read that threw is not an answer, and the next asker reads again", async () => {
+  let reads = 0;
+  const keyframes = tables(async () => {
+    reads += 1;
+    if (reads === 1) {
+      // The bytes it needed had not arrived. That says nothing about the file,
+      // and recording it as "no keyframes" would re-encode every picture of
+      // this file for as long as the process lives.
+      throw new Error("the head is not downloaded");
+    }
+    return { times: [0, 6], tolerance: 0, format: "matroska" };
+  });
+
+  await assert.rejects(() => keyframes.read(FILE), /the head is not downloaded/);
+  assert.equal(keyframes.of(FILE).answered, false);
+
+  const table = await keyframes.read(FILE);
+
+  assert.equal(reads, 2, "it was read again rather than refused from a cached failure");
+  assert.deepEqual(table.times, [0, 6]);
+});
+
+test("the packet probe never displaces a fuller table", () => {
+  const keyframes = tables(async () => ({ times: [0, 2, 4, 6, 8], tolerance: 0, format: "matroska" }));
+  keyframes.learn(FILE, { times: [0, 2, 4, 6, 8], format: "matroska" });
+
+  // Measured 2026-08-02: a packet scan found 77 keyframes in 45 s without
+  // finishing, against all 570 in 0.8 s from the container's own index.
+  keyframes.learn(FILE, { times: [0, 8], format: "packet probe" });
+
+  const table = keyframes.of(FILE);
+  assert.deepEqual(table.times, [0, 2, 4, 6, 8]);
+  assert.equal(table.format, "matroska");
+});
+
+test("the packet probe IS the answer where no container index exists", () => {
+  const keyframes = tables(async () => null);
+  keyframes.learn(FILE, { times: null, format: "mpegts" });
+  assert.equal(keyframes.of(FILE).readable, false);
+
+  keyframes.learn(FILE, { times: [0, 3, 6], format: "packet probe" });
+
+  assert.deepEqual(keyframes.of(FILE).times, [0, 3, 6]);
+});
+
+test("a registry with no reader says nothing about the file rather than lying about it", async () => {
+  const keyframes = new KeyframeTables({ logger: QUIET });
+
+  const table = await keyframes.read(FILE);
+
+  assert.equal(table.readable, false, "there is no table, so a picture of this file is re-encoded");
+  assert.equal(
+    table.answered,
+    false,
+    "and nothing has ANSWERED — a proxy wired without a reader is not a statement about anybody's bytes"
+  );
+});
+
+test("a table nobody holds is dropped, and one still being read is not", async () => {
+  let answer = null;
+  const keyframes = tables(() => new Promise((resolve) => { answer = resolve; }));
+  const held = keyframes.of({ sourceKey: "torrent:abc", fileIndex: 0 });
+  const dropped = keyframes.of({ sourceKey: "torrent:abc", fileIndex: 1 });
+  void keyframes.warm({ sourceKey: "torrent:abc", fileIndex: 2, logName: "c.mkv" });
+  const reading = keyframes.of({ sourceKey: "torrent:abc", fileIndex: 2 });
+
+  keyframes.forgetUnused(new Set([held]));
+
+  assert.equal(keyframes.of({ sourceKey: "torrent:abc", fileIndex: 0 }), held);
+  assert.notEqual(keyframes.of({ sourceKey: "torrent:abc", fileIndex: 1 }), dropped);
+  assert.equal(
+    keyframes.of({ sourceKey: "torrent:abc", fileIndex: 2 }),
+    reading,
+    "dropping a file whose read is in flight loses the answer and pays the whole wait again"
+  );
+  answer(null);
+});
+
+test("the container reads and does not remember — one fact, one store", async () => {
+  // It used to keep the answer, which made this table the one fact in the proxy
+  // stored twice: here, and in the file's own `KeyframeTable`. Traced
+  // 2026-09-15, this copy had no reader: nothing in the torrent thread asks
+  // where a file's keyframes are, and the one path to it ends at
+  // `KeyframeTables` on the other side of the channel.
   let parses = 0;
-  class OneTable extends Container {
+  class Counting extends Container {
     async parseKeyframeIndex() {
       parses += 1;
       return { times: [0, 2, 4], tolerance: 0 };
     }
   }
-  const container = new OneTable({ readRange: async () => null, fileSize: 10 });
+  const container = new Counting({ readRange: async () => null, fileSize: 10 });
 
-  const [first, second] = await Promise.all([
-    container.readKeyframeIndex(),
-    container.readKeyframeIndex()
-  ]);
+  await container.readKeyframeIndex();
   await container.readKeyframeIndex();
 
-  assert.equal(parses, 1);
-  assert.deepEqual(first, second);
+  assert.equal(parses, 2, "a container that keeps the answer is a second owner of it");
 });
 
-test("a read that threw is not remembered as an answer", async () => {
+test("reading once per file is the table registry's job, and it also bounds the wait", async () => {
+  // Where the guarantee went. It is not merely moved: this is the only place
+  // that can ALSO stop a viewer waiting for ever while letting the read finish,
+  // which a container cannot — it does not know there is a viewer.
   let parses = 0;
-  class Late extends Container {
+  class Counting extends Container {
     async parseKeyframeIndex() {
       parses += 1;
-      if (parses === 1) {
-        // The bytes it needed had not arrived yet, which is not a statement
-        // about the file.
-        throw new Error("nothing to read there yet");
-      }
-      return { times: [0, 2], tolerance: 0 };
+      return { times: [0, 2, 4], tolerance: 0 };
     }
   }
-  const container = new Late({ readRange: async () => null, fileSize: 10 });
+  const container = new Counting({ readRange: async () => null, fileSize: 10 });
+  const keyframes = tables(() => container.readKeyframeIndex());
+
+  await Promise.all([keyframes.read(FILE), keyframes.read(FILE)]);
+  await keyframes.read(FILE);
+
+  assert.equal(parses, 1);
+  assert.deepEqual(keyframes.of(FILE).times, [0, 2, 4]);
+});
+
+test("answered and readable are two questions, and a bag of fields cannot tell them apart", () => {
+  const table = new KeyframeTable();
+  assert.equal(table.answered, false);
+  assert.equal(table.readable, false);
+  assert.equal(table.format, "not yet read");
 
-  await assert.rejects(() => container.readKeyframeIndex());
-  const second = await container.readKeyframeIndex();
+  table.learn({ times: null, format: "mpegts" });
 
-  assert.equal(parses, 2);
-  assert.deepEqual(second.times, [0, 2]);
+  assert.equal(table.answered, true, "the container came back");
+  assert.equal(table.readable, false, "with no keyframes, which is permanent for this file");
+  assert.equal(table.format, "mpegts", "and the refusal can name what it is refusing");
 });

package/test/learned-median.test.js

@@ -4,7 +4,7 @@
  */
 import assert from "node:assert/strict";
 import { test } from "node:test";
-import { medianOf, movedBeyondScatter, scatterOf } from "../services/learned-median.js";
+import { medianOf, movedBeyondScatter, scatterOf } from "../services/encode/learned-median.js";
 
 test("the median is the middle reading, and the mean of the two middle ones", () => {
   assert.equal(medianOf([3, 1, 2]), 2);

package/test/letting-go-asks-who-is-watching.test.js

@@ -0,0 +1,191 @@
+/**
+ * @file Letting go of a step must ask who is on it, at the moment of letting go.
+ *
+ * Two disposals in the step path reasoned "nobody is on it yet", and neither
+ * could know it. An output is addressed by what it PRODUCES, so opening one
+ * hands back the output that already makes that picture whenever there is one —
+ * which may be a step another viewer has been watching all along. And a
+ * genuinely new one is only nobody's until something else reaches it: making a
+ * step takes a probe and a keyframe index, seconds in which a second viewer can
+ * ask for the same height and be registered onto it.
+ *
+ * Both are the same fault, so both are one question asked of the registry now.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Renditions } from "../services/encode/Renditions.js";
+import { Viewers } from "../services/viewer/Viewers.js";
+import {
+  chooseOutput,
+  chosenOutputOf,
+  noteServingVerdict,
+  audioBeingWarmedOf,
+  audioChoiceOf,
+  chooseAudioTrack,
+  consumersOn,
+  linkMbpsOf,
+  noteAudioBeingWarmed,
+  noteStepBeingWarmed,
+  noteStepOnScreen,
+  placeOn,
+  presentOn,
+  qualityModeOf,
+  stepBeingWarmedOf,
+  stepOnScreenOf,
+  watches
+} from "../services/viewer/choices.js";
+import { SourceFile } from "../services/media/SourceFile.js";
+
+const BASE_ID = "4444444455556666";
+const STEP_ID = "5555555566667777";
+
+/**
+ * A picture with one step of 720p, and whatever `createOrGetSession` is told to
+ * hand back for the next request.
+ *
+ * @param {{ handBack: (() => object) | null, baseIsLive?: boolean, stepProducedHeight?: number }} how
+ */
+function renditionsOver(how) {
+  const file = new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" });
+  // THE SAME MATERIAL, stated in full, because that is what the rule compares:
+  // the source, the container, the cut grid, what the output carries and which
+  // tracks. Two outputs of one picture differ in SIZE and in nothing else, and
+  // a stub that leaves those fields out is not a picture with two rungs — it is
+  // two outputs the rule cannot recognise as related.
+  const material = () => ({
+    transcodesAudio: false,
+    sourceKey: "source-1",
+    segmentFormatId: "fmp4",
+    grid: { toKey: () => "kf@0:100" },
+    carries: "video-only",
+    video: { fileIndex: 0 },
+    audio: null
+  });
+  const base = { id: BASE_ID, outputKey: "letting-go:base", file, spec: material(), timeline: { cutGrid: "uniform" }, segmentFormat: { id: "fmp4" } };
+  const step = { id: STEP_ID, outputKey: "letting-go:step", file, spec: material(), timeline: { cutGrid: "uniform" }, segmentFormat: { id: "fmp4" } };
+  const viewers = new Viewers();
+  const disposed = [];
+  const lines = [];
+  const outputs = {
+    get: (id) => (id === BASE_ID ? base : id === STEP_ID ? step : null),
+    touch: () => {},
+    markStep: () => {},
+    stepsOf: () => [step],
+    splicableHeights: () => [1080, 720],
+    // The step is NAMED 540 and may PRODUCE something else: an output answers
+    // for the picture it makes, not for the number in its name.
+    variantHeightOf: (output) => (output === base ? 1080 : 540),
+    // What each actually makes. The picture itself is a rung like any other,
+    // and when it is a re-encode a step can land on exactly its size — which is
+    // the case the adoption below exists for.
+    producedHeightOf: (output) => (output === base ? (how.baseProducedHeight ?? 1080) : (how.stepProducedHeight ?? 540)),
+    values: () => [base, step]
+  };
+  const renditions = new Renditions({
+    outputs,
+    viewerCountOn: (output) => viewers.forOutput(output).size,
+    outputStillNeeded: (output) => viewers.stillNeeded(output),
+    consumersOn: (output) => consumersOn(viewers, output),
+    presentOn: (output) => presentOn(viewers, output),
+    qualityModeOf: (output, consumerId) => qualityModeOf(viewers, output, consumerId),
+    linkMbpsOf: (output, consumerId) => linkMbpsOf(viewers, output, consumerId),
+    audioChoiceOf: (output, consumerId) => audioChoiceOf(viewers, output, consumerId),
+    chooseAudioTrack: (output, consumerId, trackIndex) => chooseAudioTrack(viewers, output, consumerId, trackIndex),
+    stepOnScreenOf: (output, consumerId) => stepOnScreenOf(viewers, output, consumerId),
+    noteStepOnScreen: (output, consumerId, stepId) => noteStepOnScreen(viewers, output, consumerId, stepId),
+    stepBeingWarmedOf: (output, consumerId) => stepBeingWarmedOf(viewers, output, consumerId),
+    noteStepBeingWarmed: (output, consumerId, stepId) => noteStepBeingWarmed(viewers, output, consumerId, stepId),
+    audioBeingWarmedOf: (output, consumerId) => audioBeingWarmedOf(viewers, output, consumerId),
+    noteAudioBeingWarmed: (output, consumerId, id) => noteAudioBeingWarmed(viewers, output, consumerId, id),
+    watches: (output, consumerId) => watches(viewers, output, consumerId),
+    placeOn: (output, consumerId, seconds) => placeOn(viewers, output, consumerId, seconds),
+    // Which output answers a height for a viewer is the viewer's own record.
+    chosenOutputOf: (consumerId, height) => chosenOutputOf(viewers, consumerId, height),
+    chooseOutput: (consumerId, height, key) => chooseOutput(viewers, consumerId, height, key),
+    noteServingVerdict: (consumerId, verdict) => noteServingVerdict(viewers, consumerId, verdict),
+    placeViewerOn: () => {},
+    viewerSecondsOn: () => 0,
+    activeOutputFor: () => base,
+    viewerPositionOf: () => 0,
+    outputTimes: { segmentStartTime: () => 0 },
+    encodeRuns: { isLive: () => how.baseIsLive !== false },
+    quality: { variantsOnScreen: () => new Set() },
+    createOrGetSession: async () => how.handBack(),
+    disposeSession: async (id) => { disposed.push(id); },
+    planEncodersSoon: () => {},
+    viewerLeaves: () => {},
+    logger: { info: (line) => lines.push(line), warn: (line) => lines.push(line), error: (line) => lines.push(line) }
+  });
+  return { renditions, base, step, viewers, disposed, lines };
+}
+
+test("an output handed back because it already makes this picture is not taken from its viewers", async () => {
+  // What `createOrGetSession` returns for a 720p request: the step that is
+  // already producing it, which somebody has been watching all along.
+  // The picture is itself re-encoded at 720 on this machine, so the step asked
+  // for produces the same picture it does: the case adoption is written for,
+  // and the one where what is let go of may be somebody's.
+  const { renditions, step, viewers, disposed } = renditionsOver({
+    handBack: () => step,
+    baseProducedHeight: 720,
+    stepProducedHeight: 720
+  });
+  viewers.of(step, "viewer-b");
+
+  const resolved = await renditions.resolveVariantSession(BASE_ID, 720, -1, "viewer-a");
+
+  assert.equal(resolved?.id, BASE_ID, "the incumbent making this picture answers for the height");
+  assert.deepEqual(disposed, [], "and the step handed back is not taken from the viewer on it");
+});
+
+test("a step a second viewer reached while it was being made is not disposed under them", async () => {
+  // The picture dies while the step is being prepared — the case the disposal
+  // was written for — but a second viewer has reached the step meanwhile.
+  const made = { id: STEP_ID };
+  const { renditions, viewers, disposed, lines } = renditionsOver({
+    baseIsLive: false,
+    handBack: () => {
+      // Registered onto it inside the window the disposal assumes is empty.
+      viewers.of(made, "viewer-b");
+      return made;
+    }
+  });
+
+  const resolved = await renditions.resolveVariantSession(BASE_ID, 720, -1, "viewer-a");
+
+  assert.equal(resolved, null, "the viewer who asked has lost the picture it was a step of");
+  assert.deepEqual(disposed, [], "but the step itself is somebody's now");
+  assert.ok(lines.some((line) => line.includes("kept although")), "and the reason is in the log");
+});
+
+test("a step nobody reached is still let go of when its picture dies", async () => {
+  const made = { id: STEP_ID };
+  const { renditions, disposed } = renditionsOver({ baseIsLive: false, handBack: () => made });
+
+  const resolved = await renditions.resolveVariantSession(BASE_ID, 720, -1, "viewer-a");
+
+  assert.equal(resolved, null);
+  assert.deepEqual(disposed, [STEP_ID], "nothing holds it, and it would hold an encoder until its idle timer");
+});
+
+test("a step nobody is watching is kept while a response from it is still being sent", async () => {
+  // The case the assignment exists for: the last viewer has stopped being
+  // registered on the output, and its bytes are still going out. Asked at the
+  // moment of letting go, which is the only moment at which the answer is
+  // about now.
+  const made = { id: STEP_ID, outputKey: "letting-go:made" };
+  const { renditions, viewers, disposed, lines } = renditionsOver({ baseIsLive: false, handBack: () => made });
+  const elsewhere = viewers.of({ id: "some-other-output" }, "viewer-c");
+  const token = elsewhere.assignments.accept(made.outputKey);
+
+  const resolved = await renditions.resolveVariantSession(BASE_ID, 720, -1, "viewer-a");
+
+  assert.equal(resolved, null, "the viewer who asked has lost the picture it was a step of");
+  assert.deepEqual(disposed, [], "but the output a response is being sent from is not taken away");
+  assert.ok(lines.some((line) => line.includes("kept although")), "and the reason is in the log");
+
+  // And once the response is done, nothing stands on it any more.
+  elsewhere.assignments.release(token);
+  assert.equal(viewers.stillNeeded(made), false);
+});

package/test/limit-row-by-area.test.js

@@ -0,0 +1,60 @@
+/**
+ * @file The row of bitrate limits is chosen by the AREA of the frame, not by
+ * its height (roadmap item 97, step 14; decided with the user 2026-09-24).
+ *
+ * The rows are the frames of the ladder at 16:9, as the encode itself sizes
+ * them. A frame takes the row nearest by the ratio of areas; on the exact
+ * border the larger row wins; a row with no nominal of its own takes the
+ * nominal of the nearest row that has one.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { h264LevelFor, limitRowFor, nominalKbpsFor, softwareRateControlFor } from "../services/encode/args.js";
+
+test("a 2.4:1 film in a 1080 box is priced as 1080, not as 720", () => {
+  // 1920x800 is 1.54 million points: 1.35 times below the 1080 row, 1.67
+  // times above the 720 row. A height alone put it in the 720 row.
+  assert.equal(limitRowFor({ width: 1920, height: 800 }), 1080);
+  assert.equal(nominalKbpsFor({ width: 1920, height: 800 }), nominalKbpsFor({ width: 1920, height: 1080 }));
+});
+
+test("the 16:9 frames of the ladder each land in their own row", () => {
+  for (const [width, height] of [[3840, 2160], [2560, 1440], [1920, 1080], [1280, 720], [960, 540], [852, 480], [640, 360], [426, 240]]) {
+    assert.equal(limitRowFor({ width, height }), height, `${width}x${height}`);
+  }
+});
+
+test("a wide 720 frame falls in the 540 row and takes the nominal the 540 row borrows", () => {
+  // 1280x534 is 0.68 million points: 1.32 times above the 540 row and 1.35
+  // times below the 720 row. The 540 row has no nominal of its own yet, and the
+  // nearest row by area that has one is 480.
+  assert.equal(limitRowFor({ width: 1280, height: 534 }), 540);
+  assert.equal(nominalKbpsFor({ width: 1280, height: 534 }), nominalKbpsFor({ width: 852, height: 480 }));
+});
+
+test("on the exact border between two rows the larger row wins", () => {
+  // The border between 1280x720 (921600) and 1920x1080 (2073600) is their
+  // geometric mean, 1382400 = 1440x960, 1.5 times from each.
+  assert.equal(limitRowFor({ width: 1440, height: 960 }), 1080);
+});
+
+test("rows with no nominal of their own borrow the nearest row that has one", () => {
+  assert.equal(nominalKbpsFor({ width: 2560, height: 1440 }), nominalKbpsFor({ width: 1920, height: 1080 }));
+  assert.equal(nominalKbpsFor({ width: 3840, height: 2160 }), nominalKbpsFor({ width: 1920, height: 1080 }));
+  assert.equal(nominalKbpsFor({ width: 960, height: 540 }), nominalKbpsFor({ width: 852, height: 480 }));
+});
+
+test("the level of a wide frame is declared from the nominal of its row", () => {
+  const control = softwareRateControlFor({ width: 1920, height: 800, fps: 24 });
+  const nominal = nominalKbpsFor({ width: 1920, height: 1080 });
+  assert.equal(
+    control.level,
+    h264LevelFor({ width: 1920, height: 800, fps: 24, maxrateKbps: control.maxrateKbps, bufsizeKbps: control.bufsizeKbps })
+  );
+  assert.equal(control.maxrateKbps, Math.round(nominal * 1.3));
+});
+
+test("a frame with no area is refused rather than priced", () => {
+  assert.throws(() => limitRowFor({ width: 0, height: 720 }), RangeError);
+});