@torrent-tv/proxy 2.89.6 → 2.89.7

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

@@ -1,191 +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);
-});
+/**
+ * @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

@@ -1,60 +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);
-});
+/**
+ * @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);
+});