@torrent-tv/proxy 2.31.0 → 2.32.0

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 2.32.0
+
+- **New**: The decode cost is fitted from a clip set that can be checked, and a term the measurements do not determine is refused instead of published as a zero. The set that shipped until now was three clips for three unknowns — an EXACT system, with two of the clips at the same pixel rate — and such a system cannot fail visibly: it returns whatever satisfies its equations. On 2026-08-17 it returned `0.007542 × Mpx/s + 0.000000 × Mbit/s + 0.0000 s/s`, so a film's own bitrate never entered its price, and the prediction built on it was 1.8-2.2x optimistic against the same file measured while playing. The new set is six clips — three sizes × two bitrates, the axes varied INDEPENDENTLY — cut from the same Netflix Open Content "Meridian" footage (CC BY 4.0, `assets/calibration/NOTICE.md`), 7.7 MB against 8.8 MB before. Three spare measurements give the fit a residual, and with it two questions it could not ask before: whether a term's whole effect across the measured range exceeds the scatter, and whether the coefficient exceeds its own standard error. A term that fails either is dropped, the rest are fitted again, and the log names it — a zero now means "not measured" only when it says so. A NEGATIVE coefficient is dropped too rather than clamped to zero: more pixels cannot cost less work, so a negative fit is noise beating an effect, not a discovery about the host. Measured on the developer's machine, the new set determines all three terms (`0.000520 × Mpx/s + 0.002086 × Mbit/s + 0.0033 s/s`, typical disagreement 0.0012 s/s), and the bitrate term it recovers matches the difference between the two 1080p clips to 15 %. The arithmetic is a pure module with the degenerate case as a test (`services/decode-cost-fit.js`).
+- **Chore**: What the calibration costs at startup, measured rather than assumed: six clips take 14.8 s on the developer's Windows box, of which the decoding is about 50 ms per clip — an empty ffmpeg spawn there costs 774 ms, and opening each file most of the rest. Shortening the clips would therefore save nothing; the cost is spawning ffmpeg once per clip, and it is paid before any viewer exists.
+
 ## 2.31.0
 
 - **Chore**: The encoder run's two status strings are gone; both are now outputs of the state table shipped in 2.23.0. `session.progress.state` was maintained by hand at seven sites and `session.state` at nine, and neither could answer on its own — the warm-up test had to read both under an `||`, because one said "starting" from the first spawn until something overwrote it while the other said it again on its own schedule. What the browser is told is computed where it is sent (`wireState(runState)`), and `session.state` is reduced to the session's own lifetime: it exists, or it has been disposed. That deletes the line in the spawn path that read `state === "disposed" ? "disposed" : "starting"` — two lifetimes in one variable, which is what it was there to paper over. Verified before the change that nothing in the browser reads the wire string, so the value set is unchanged and unobserved either way; the four values it can take are the same four as before.

package/assets/calibration/NOTICE.md

@@ -1,30 +1,63 @@
 # Calibration clips — attribution
 
-The three clips in this folder are excerpts from **"Meridian"**, part of
+The clips in this folder are excerpts from **"Meridian"**, part of
 [Netflix Open Content](https://opencontent.netflix.com/), licensed under the
 **Creative Commons Attribution 4.0 International (CC BY 4.0)** licence:
 <https://creativecommons.org/licenses/by/4.0/>.
 
 They were cut from `Meridian/Meridian_UHD4k5994_HDR_P3PQ.mp4` and re-encoded to
-H.264 High, 24 fps, 5.04 s (121 frames), no audio:
+H.264 High, 24 fps, 2 s each, no audio:
 
 | file | resolution | bitrate |
 |---|---|---|
-| `cal-1080-hi.mp4` | 1920×1080 | 11.38 Mbit/s |
-| `cal-1080-lo.mp4` | 1920×1080 | 0.97 Mbit/s |
-| `cal-720.mp4` | 1280×720 | 2.25 Mbit/s |
+| `cal-h264-1080-hi.mp4` | 1920×1080 | 9.36 Mbit/s |
+| `cal-h264-1080-lo.mp4` | 1920×1080 | 1.00 Mbit/s |
+| `cal-h264-720-hi.mp4` | 1280×720 | 9.95 Mbit/s |
+| `cal-h264-720-lo.mp4` | 1280×720 | 1.04 Mbit/s |
+| `cal-h264-480-hi.mp4` | 854×480 | 9.48 Mbit/s |
+| `cal-h264-480-lo.mp4` | 854×480 | 1.25 Mbit/s |
 
-## Why these three, and why real footage
+## Why six, and why this grid
 
-`services/hwaccel.js` decodes them at startup and solves the host's decode cost,
-`a × Mpixel/s + b × Mbit/s + c`, from the three measurements. The first two
-clips share a pixel count and differ 11.7× in bitrate; the third changes the
-pixel count. Three points, three unknowns.
+`services/hwaccel.js` decodes them at startup and fits the host's decode cost,
+`a × Mpixel/s + b × Mbit/s + c`, from the measurements
+(`services/decode-cost-fit.js`).
 
-Real, grainy live action rather than a generated pattern: measured 2026-08-14 on
-the addon host, this material decodes 11 % away from the film being served,
-where a generated `testsrc2` clip is 158 % away.
+The set before this one was three clips for three unknowns — an EXACT system,
+with two of the clips sharing a pixel count. Such a system cannot fail visibly:
+it returns whatever satisfies its three equations, and on 2026-08-17 it returned
+`0.007542 × Mpx/s + 0.000000 × Mbit/s + 0.0000 s/s` — the bitrate term and the
+constant exactly zero, so a film's own bitrate never entered its price, and the
+prediction built on it was 1.8-2.2x optimistic against the same file measured
+while playing.
 
-Replacing a clip is allowed — the benchmark reads each clip's dimensions, frame
-rate and bitrate from ffmpeg's own output rather than from this table — but the
-three must keep spanning the two axes, or the fit has nothing to separate.
+Six clips are three sizes × two bitrates, with the two axes varied
+**independently**. That gives three spare measurements, so the fit has a
+residual — something to notice a degeneracy WITH — and lets a term be refused
+when the data does not determine it, instead of being published as a zero that
+looks measured.
+
+A 480p clip at 9.5 Mbit/s is not content anyone ships; that is the point. The
+bitrate has to vary at every size, or it cannot be told apart from the size.
+
+## Why real footage
+
+Grainy live action rather than a generated pattern: measured 2026-08-14 on the
+addon host, this material decodes 11 % away from the film being served, where a
+generated `testsrc2` clip is 158 % away. It also matches most of what the
+product actually plays — a survey of 133 releases (2026-07-10) found ~67 %
+H.264 live action, the rest HEVC, XviD and animation.
+
+## Replacing or extending the set
+
+Allowed: the benchmark reads each clip's dimensions, frame rate and bitrate from
+ffmpeg's own output rather than from this table. Two rules hold, though:
+
+- **more measurements than terms**, or there is no residual and no way to see a
+  degenerate fit;
+- **the axes stay independent** — every size at both bitrates. Dropping one cell
+  reintroduces the collinearity that produced the zeros above.
+
+Codecs other than H.264 (HEVC, AV1, 10-bit) decode dearer per pixel, and the
+model fitted here does not describe them. Covering them means a set per codec
+family and constants chosen by the source's own codec — roadmap item 3(b).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.31.0",
+  "version": "2.32.0",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

package/services/decode-cost-fit.js

@@ -0,0 +1,331 @@
+/**
+ * @file Fit the cost of decoding from measured clips — and say which terms the
+ * measurements actually determine.
+ *
+ * The model is `cost = pixelTerm × Mpixel/s + bitrateTerm × Mbit/s +
+ * constantTerm`, in seconds of work per second of content.
+ *
+ * What went wrong with the fit this replaces, measured 2026-08-17: three clips
+ * for three unknowns is an EXACT system, and two of those clips shared a pixel
+ * rate and differed only in bitrate. A system that near-singular does not fail
+ * loudly — it returns whatever satisfies the three equations, and on that boot
+ * it returned `0.007542 × Mpx/s + 0.000000 × Mbit/s + 0.0000 s/s`. The bitrate
+ * term and the constant were zero, so a film's own bitrate never entered its
+ * price, and the whole prediction was 1.8-2.2x optimistic against what the same
+ * file measured while playing.
+ *
+ * Two things are different here, and both are about honesty rather than
+ * accuracy:
+ *
+ *   - the system is OVER-determined (six clips, three unknowns) and solved by
+ *     least squares, so no single noisy reading decides a term;
+ *   - a term is published only if the measurements determine it. The test is
+ *     the coefficient against its OWN standard error: a term smaller than the
+ *     uncertainty in it has not been measured, and stating it as a number —
+ *     zero or otherwise — claims knowledge that is not there. It is dropped,
+ *     the remaining terms are fitted again, and the caller is told which shape
+ *     survived.
+ *
+ * There is no threshold to tune in that rule and no coefficient anywhere in
+ * this file. "Smaller than its own uncertainty" is a statement about the data,
+ * not a setting.
+ */
+
+/**
+ * One measured clip.
+ *
+ * @typedef {object} DecodeSample
+ * @property {number} megapixelsPerSecond - Width × height × frame rate ÷ 1e6.
+ * @property {number} megabitsPerSecond - The clip's own measured bitrate.
+ * @property {number} costSecondsPerSecond - Seconds of work per second of
+ *   content, from ffmpeg's own progress.
+ */
+
+/**
+ * The fitted model, with the shape the data supported.
+ *
+ * @typedef {object} DecodeCostModel
+ * @property {number} pixelTerm
+ * @property {number} bitrateTerm
+ * @property {number} constantTerm
+ * @property {string} shape - Which terms were determined.
+ * @property {string[]} dropped - Terms the measurements could not determine.
+ * @property {number} samples
+ * @property {number} residualRms - Typical disagreement between the fit and a
+ *   measurement, in the same units as the cost.
+ */
+
+/** Every term the model can carry, in column order. */
+const TERMS = ["pixels", "bitrate", "constant"];
+
+/**
+ * Fit the model, dropping any term the measurements do not determine.
+ *
+ * @param {DecodeSample[]} samples
+ * @returns {DecodeCostModel | null} Null when nothing at all can be said: fewer
+ *   measurements than terms, or no measurable dependence on the source.
+ */
+export function fitDecodeCost(samples) {
+  const usable = (Array.isArray(samples) ? samples : []).filter(
+    (sample) =>
+      Number.isFinite(sample?.megapixelsPerSecond) &&
+      sample.megapixelsPerSecond > 0 &&
+      Number.isFinite(sample?.megabitsPerSecond) &&
+      sample.megabitsPerSecond >= 0 &&
+      Number.isFinite(sample?.costSecondsPerSecond) &&
+      sample.costSecondsPerSecond > 0
+  );
+  // Fitting three terms to three points is what produced the degenerate answer
+  // this file exists to prevent: it has no residual and therefore no way to
+  // notice that two of the points said the same thing.
+  if (usable.length < TERMS.length + 1) {
+    return null;
+  }
+
+  let columns = [...TERMS];
+  let dropped = [];
+  for (let attempt = 0; attempt < TERMS.length; attempt += 1) {
+    const fit = leastSquares(usable, columns);
+    if (!fit) {
+      return null;
+    }
+    // Which terms the data did not determine: a coefficient no larger than the
+    // uncertainty in it. Only one is dropped per pass — removing a column
+    // changes the uncertainty in the others, so the question has to be asked
+    // again of the smaller model.
+    const undetermined = columns
+      .map((name, index) => ({
+        name,
+        coefficient: fit.coefficients[index],
+        ratio: determination(usable, columns, name, fit.coefficients[index], fit.standardErrors[index], fit.residualRms)
+      }))
+      // The pixel term is the one relationship every measurement agrees on, and
+      // a model without it says nothing at all. If IT is undetermined the
+      // answer is no model, which the caller handles by pricing the encoder
+      // alone and refusing nothing.
+      // A NEGATIVE coefficient is undetermined whatever its ratio says. Every
+      // term here is physically non-negative — more pixels cannot cost less
+      // work, and neither can more bits — so a negative fit is noise winning
+      // over an effect, not a discovery about the host. Clamping it to zero
+      // instead, which the first version of this file did, publishes a zero
+      // that looks measured: exactly the dishonesty the module exists to
+      // remove.
+      .filter((term) => term.ratio < 1 || term.coefficient < 0)
+      .sort((left, right) => {
+        const negative = (term) => (term.coefficient < 0 ? 0 : 1);
+        return negative(left) - negative(right) || left.ratio - right.ratio;
+      });
+
+    if (undetermined.length === 0) {
+      return published(columns, fit, dropped, usable.length);
+    }
+    const weakest = undetermined[0].name;
+    if (weakest === "pixels") {
+      return null;
+    }
+    columns = columns.filter((name) => name !== weakest);
+    dropped = [...dropped, weakest];
+    if (columns.length === 0) {
+      return null;
+    }
+  }
+  return null;
+}
+
+
+/**
+ * How well one term is determined, as a ratio against 1.
+ *
+ * Two ways a term can fail to be measured, and both have to be asked, because
+ * each is blind where the other sees:
+ *
+ *   - **against the noise.** The term's effect across the range the clips
+ *     actually cover — its coefficient times the spread of its own column — has
+ *     to be larger than the typical disagreement between the fit and the
+ *     measurements. A term whose whole contribution is smaller than the scatter
+ *     was not measured; it was fitted to the scatter.
+ *   - **against the arithmetic.** When a fit happens to be exact the scatter is
+ *     zero, every standard error vanishes, and a coefficient of 7e-18 — which
+ *     is how double-precision writes "nothing" — passes any test framed as a
+ *     ratio. So the effect must also be larger than what the arithmetic itself
+ *     can represent at this scale. That floor is a property of the numbers, not
+ *     a setting: it moves with the size of the measurements.
+ *
+ * @param {DecodeSample[]} samples
+ * @param {string[]} columns
+ * @param {string} name
+ * @param {number} coefficient
+ * @param {number} standardError
+ * @param {number} residualRms
+ * @returns {number} Below 1 means the measurements do not determine this term.
+ */
+function determination(samples, columns, name, coefficient, standardError, residualRms) {
+  const values = samples.map((sample) => {
+    if (name === "pixels") {
+      return sample.megapixelsPerSecond;
+    }
+    if (name === "bitrate") {
+      return sample.megabitsPerSecond;
+    }
+    return 1;
+  });
+  const spread = name === "constant" ? 1 : Math.max(...values) - Math.min(...values);
+  const effect = Math.abs(coefficient) * spread;
+  const meanCost = samples.reduce((sum, sample) => sum + sample.costSecondsPerSecond, 0) / samples.length;
+  const arithmeticFloor = Math.abs(meanCost) * Number.EPSILON * samples.length * columns.length;
+  const noiseFloor = Math.max(residualRms, arithmeticFloor);
+  const againstNoise = noiseFloor > 0 ? effect / noiseFloor : Number.POSITIVE_INFINITY;
+  const againstError = standardError > 0 ? Math.abs(coefficient) / standardError : Number.POSITIVE_INFINITY;
+  return Math.min(againstNoise, againstError);
+}
+
+/**
+ * Assemble the answer, with absent terms as zero — and `dropped` saying that
+ * the zero means "not measured" rather than "measured to be nothing".
+ *
+ * @param {string[]} columns
+ * @param {{ coefficients: number[], residualRms: number }} fit
+ * @param {string[]} dropped
+ * @param {number} samples
+ * @returns {DecodeCostModel | null}
+ */
+function published(columns, fit, dropped, samples) {
+  const value = (name) => {
+    const index = columns.indexOf(name);
+    return index < 0 ? 0 : fit.coefficients[index];
+  };
+  const pixelTerm = value("pixels");
+  // A negative price for pixels is not a host being unusual — it is noise
+  // larger than the effect, and carrying it would price a bigger picture as
+  // cheaper than a smaller one.
+  if (!(pixelTerm > 0)) {
+    return null;
+  }
+  const constantTerm = value("constant");
+  return {
+    pixelTerm,
+    bitrateTerm: Math.max(0, value("bitrate")),
+    // A negative constant would make a small enough source free, which no
+    // measurement here supports: it is the fitted line crossing below zero
+    // outside the range that was measured.
+    constantTerm: Math.max(0, constantTerm),
+    shape: columns.join("+"),
+    dropped,
+    samples,
+    residualRms: fit.residualRms
+  };
+}
+
+/**
+ * Least squares over the named columns, with the standard error of each
+ * coefficient.
+ *
+ * Solved through the normal equations. The matrix is at most 3×3 and the
+ * columns are of similar magnitude once a clip set varies them deliberately,
+ * which is exactly what the set is designed for.
+ *
+ * @param {DecodeSample[]} samples
+ * @param {string[]} columns
+ * @returns {{ coefficients: number[], standardErrors: number[], residualRms: number } | null}
+ */
+function leastSquares(samples, columns) {
+  const rowOf = (sample) =>
+    columns.map((name) => {
+      if (name === "pixels") {
+        return sample.megapixelsPerSecond;
+      }
+      if (name === "bitrate") {
+        return sample.megabitsPerSecond;
+      }
+      return 1;
+    });
+  const width = columns.length;
+  const normal = Array.from({ length: width }, () => new Array(width).fill(0));
+  const right = new Array(width).fill(0);
+  for (const sample of samples) {
+    const row = rowOf(sample);
+    for (let i = 0; i < width; i += 1) {
+      right[i] += row[i] * sample.costSecondsPerSecond;
+      for (let j = 0; j < width; j += 1) {
+        normal[i][j] += row[i] * row[j];
+      }
+    }
+  }
+  const inverse = invert(normal);
+  if (!inverse) {
+    return null;
+  }
+  const coefficients = inverse.map((row) => row.reduce((sum, value, index) => sum + value * right[index], 0));
+
+  let residualSquares = 0;
+  for (const sample of samples) {
+    const row = rowOf(sample);
+    const predicted = row.reduce((sum, value, index) => sum + value * coefficients[index], 0);
+    residualSquares += (sample.costSecondsPerSecond - predicted) ** 2;
+  }
+  const degreesOfFreedom = samples.length - width;
+  const variance = degreesOfFreedom > 0 ? residualSquares / degreesOfFreedom : 0;
+  const standardErrors = inverse.map((row, index) => Math.sqrt(Math.max(0, variance * row[index])));
+  return {
+    coefficients,
+    standardErrors,
+    residualRms: Math.sqrt(residualSquares / samples.length)
+  };
+}
+
+/**
+ * Invert a small symmetric matrix by Gauss-Jordan, or null when it is singular.
+ *
+ * @param {number[][]} matrix
+ * @returns {number[][] | null}
+ */
+function invert(matrix) {
+  const size = matrix.length;
+  const work = matrix.map((row, index) => [
+    ...row,
+    ...Array.from({ length: size }, (_unused, column) => (column === index ? 1 : 0))
+  ]);
+  for (let column = 0; column < size; column += 1) {
+    let pivot = column;
+    for (let row = column + 1; row < size; row += 1) {
+      if (Math.abs(work[row][column]) > Math.abs(work[pivot][column])) {
+        pivot = row;
+      }
+    }
+    // Singular to the precision of the arithmetic: the columns are not
+    // independent, which is a statement about the clip set, not about the host.
+    if (Math.abs(work[pivot][column]) < 1e-12) {
+      return null;
+    }
+    [work[column], work[pivot]] = [work[pivot], work[column]];
+    const scale = work[column][column];
+    for (let k = 0; k < 2 * size; k += 1) {
+      work[column][k] /= scale;
+    }
+    for (let row = 0; row < size; row += 1) {
+      if (row === column) {
+        continue;
+      }
+      const factor = work[row][column];
+      for (let k = 0; k < 2 * size; k += 1) {
+        work[row][k] -= factor * work[column][k];
+      }
+    }
+  }
+  return work.map((row) => row.slice(size));
+}
+
+/**
+ * What a model prices one source at.
+ *
+ * @param {DecodeCostModel} model
+ * @param {{ megapixelsPerSecond: number, megabitsPerSecond: number }} source
+ * @returns {number} Seconds of work per second of content.
+ */
+export function decodeCostOf(model, source) {
+  return (
+    model.pixelTerm * source.megapixelsPerSecond +
+    model.bitrateTerm * source.megabitsPerSecond +
+    model.constantTerm
+  );
+}

package/services/hwaccel.js

@@ -24,6 +24,7 @@ import { spawn } from "node:child_process";
 import { mkdtempSync, readdirSync, rmSync, statSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { fitDecodeCost } from "./decode-cost-fit.js";
 import { fileURLToPath } from "node:url";
 import {
   parseFfmpegBitrateKbps,
@@ -670,45 +671,28 @@ export async function detectTonemapSupport({ ffmpegBin, logger }) {
   return supported;
 }
 
-/**
- * Solve a 3×3 linear system by Gaussian elimination with partial pivoting.
- *
- * @param {number[][]} rows - Three rows of [c0, c1, c2, rhs].
- * @returns {number[] | null} The three unknowns, or null when singular.
- */
-function solveLinear3(rows) {
-  const m = rows.map((row) => [...row]);
-  for (let col = 0; col < 3; col += 1) {
-    let pivot = col;
-    for (let row = col + 1; row < 3; row += 1) {
-      if (Math.abs(m[row][col]) > Math.abs(m[pivot][col])) {
-        pivot = row;
-      }
-    }
-    if (Math.abs(m[pivot][col]) < 1e-12) {
-      return null;
-    }
-    [m[col], m[pivot]] = [m[pivot], m[col]];
-    for (let row = 0; row < 3; row += 1) {
-      if (row === col) {
-        continue;
-      }
-      const factor = m[row][col] / m[col][col];
-      for (let k = col; k < 4; k += 1) {
-        m[row][k] -= factor * m[col][k];
-      }
-    }
-  }
-  return [m[0][3] / m[0][0], m[1][3] / m[1][1], m[2][3] / m[2][2]];
-}
 
-// The clips the decode cost is solved from. They ship with the package
+// The clips the decode cost is fitted from. They ship with the package
 // (`assets/calibration/`), cut from Netflix Open Content "Meridian" (CC-BY 4.0)
 // — real, grainy live action, because a generated `testsrc2` clip decodes 158 %
-// away from a real film where these are 11 % away (measured 2026-08-14). Two
-// share a pixel count and differ 11.7× in bitrate, the third has the same
-// bitrate class at fewer pixels: three points, three unknowns.
-const CALIBRATION_CLIPS = ["cal-1080-hi.mp4", "cal-1080-lo.mp4", "cal-720.mp4"];
+// away from a real film where these are 11 % away (measured 2026-08-14).
+//
+// Three sizes at two bitrates each, with the axes varied INDEPENDENTLY. The set
+// this replaced was three clips for three unknowns, two of them at the same
+// size: an exact system, which cannot fail visibly. On 2026-08-17 it returned
+// `0.007542 × Mpx/s + 0.000000 × Mbit/s + 0.0000 s/s` — the bitrate term and
+// the constant exactly zero — and the prediction on top of it was 1.8-2.2x
+// optimistic. Six points leave three spare, so the fit has a residual, and a
+// term the data does not determine can be refused instead of published as a
+// zero that looks measured. See `assets/calibration/NOTICE.md`.
+const CALIBRATION_CLIPS = [
+  "cal-h264-1080-hi.mp4",
+  "cal-h264-1080-lo.mp4",
+  "cal-h264-720-hi.mp4",
+  "cal-h264-720-lo.mp4",
+  "cal-h264-480-hi.mp4",
+  "cal-h264-480-lo.mp4"
+];
 const CALIBRATION_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "assets", "calibration");
 // How wide the measured window must be before the slope is trusted, and how
 // long to wait for it at most. A second of decoding is thousands of frames on a
@@ -770,8 +754,8 @@ function parseClipCharacteristics(stderr) {
 export async function benchmarkDecodeCost({ ffmpegBin, logger, clipsDir = CALIBRATION_DIR }) {
   const log = logger ?? { info: () => {}, warn: () => {} };
   const startedAllAt = Date.now();
-  /** @type {number[][]} */
-  const equations = [];
+  /** @type {Array<{ megapixelsPerSecond: number, megabitsPerSecond: number, costSecondsPerSecond: number }>} */
+  const samples = [];
   for (const clip of CALIBRATION_CLIPS) {
     const measured = await measureDecodeSlope(ffmpegBin, path.join(clipsDir, clip));
     if (!measured) {
@@ -779,21 +763,31 @@ export async function benchmarkDecodeCost({ ffmpegBin, logger, clipsDir = CALIBR
       return null;
     }
     const cost = 1 / measured.speed;
-    equations.push([measured.megapixelsPerSecond, measured.megabitsPerSecond, 1, cost]);
+    samples.push({
+      megapixelsPerSecond: measured.megapixelsPerSecond,
+      megabitsPerSecond: measured.megabitsPerSecond,
+      costSecondsPerSecond: cost
+    });
     log.info(
       `hwaccel: decode "${clip}" ${measured.megapixelsPerSecond.toFixed(1)} Mpx/s ` +
         `${measured.megabitsPerSecond.toFixed(2)} Mbit/s -> ${measured.speed.toFixed(1)}x ` +
         `(cost ${cost.toFixed(4)} s/s, over ${measured.windowSec.toFixed(1)}s of decoding)`
     );
   }
-  const fitted = fitDecodeCost(equations);
+  const fitted = fitDecodeCost(samples);
   if (!fitted) {
     log.warn("hwaccel: decode cost could not be fitted to these measurements; decode cost unknown");
     return null;
   }
   log.info(
     `hwaccel: decode cost = ${fitted.pixelTerm.toFixed(6)} × Mpx/s + ${fitted.bitrateTerm.toFixed(6)} × Mbit/s ` +
-      `+ ${fitted.constantTerm.toFixed(4)} s/s (${fitted.shape}, measured in ${((Date.now() - startedAllAt) / 1000).toFixed(1)}s)`
+      `+ ${fitted.constantTerm.toFixed(4)} s/s (${fitted.shape} from ${fitted.samples} clips, ` +
+      `typical disagreement ${fitted.residualRms.toFixed(4)} s/s` +
+      // Named rather than implied: a zero in the line above means "not
+      // measured" for a dropped term and "measured to be nothing" otherwise,
+      // and those are different claims.
+      (fitted.dropped.length > 0 ? `, ${fitted.dropped.join(" and ")} not determined by these clips` : "") +
+      `, measured in ${((Date.now() - startedAllAt) / 1000).toFixed(1)}s)`
   );
   return { pixelTerm: fitted.pixelTerm, bitrateTerm: fitted.bitrateTerm, constantTerm: fitted.constantTerm };
 }
@@ -911,65 +905,6 @@ function measureDecodeSlope(ffmpegBin, clipPath) {
   });
 }
 
-/**
- * Fit the three measurements, and say which shape the data supported.
- *
- * The three-term fit is exact — three points, three unknowns — and is used
- * whenever every term comes out non-negative. A negative term is not a host
- * being odd; it says the difference it was solved from is smaller than the
- * noise between runs, which is what a fast machine produces: measured on a
- * desktop, the 720p clip took LONGER per second than the low-bitrate 1080p one,
- * because process startup is a large share of a decode that takes a second.
- *
- * When that happens the bitrate term — the weak one, and the one solved from a
- * single difference — is dropped and the remaining two are fitted by least
- * squares over all three points. If even the pixel slope comes out non-positive
- * there is no measurable dependence on the source at all, and inventing one is
- * worse than having none: the caller then prices the encoder alone and refuses
- * nothing.
- *
- * @param {number[][]} equations - Rows of [Mpixel/s, Mbit/s, 1, cost].
- * @returns {{ pixelTerm: number, bitrateTerm: number, constantTerm: number, shape: string } | null}
- */
-function fitDecodeCost(equations) {
-  const exact = solveLinear3(equations);
-  if (exact && exact[0] > 0 && exact[1] >= 0 && exact[2] >= 0) {
-    return { pixelTerm: exact[0], bitrateTerm: exact[1], constantTerm: exact[2], shape: "pixels+bitrate+constant" };
-  }
-  const count = equations.length;
-  const meanPixels = equations.reduce((sum, row) => sum + row[0], 0) / count;
-  const meanCost = equations.reduce((sum, row) => sum + row[3], 0) / count;
-  let covariance = 0;
-  let variance = 0;
-  for (const row of equations) {
-    covariance += (row[0] - meanPixels) * (row[3] - meanCost);
-    variance += (row[0] - meanPixels) ** 2;
-  }
-  if (!(variance > 0)) {
-    return null;
-  }
-  const pixelTerm = covariance / variance;
-  const constantTerm = meanCost - pixelTerm * meanPixels;
-  if (pixelTerm > 0 && constantTerm >= 0) {
-    return { pixelTerm, bitrateTerm: 0, constantTerm, shape: "pixels+constant" };
-  }
-  // A negative constant is the line crossing below zero where no clip was
-  // measured — every clip is 22 Mpixel/s or more, and nothing here says what a
-  // tiny picture costs. Rather than carry a term that would price a small
-  // source as free work, fit through the origin: cost proportional to pixels,
-  // which is the relationship the measurements do support.
-  let weighted = 0;
-  let squares = 0;
-  for (const row of equations) {
-    weighted += row[0] * row[3];
-    squares += row[0] ** 2;
-  }
-  const throughOrigin = squares > 0 ? weighted / squares : 0;
-  if (!(throughOrigin > 0)) {
-    return null;
-  }
-  return { pixelTerm: throughOrigin, bitrateTerm: 0, constantTerm: 0, shape: "pixels only" };
-}
 
 /**
  * How many times realtime this host can DECODE a source of these