@torrent-tv/proxy 2.89.6 → 2.89.7

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

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