@torrent-tv/proxy 2.80.10 → 2.80.11

package/services/output/LiveOutputs.js

@@ -125,6 +125,55 @@ export class LiveOutputs {
     return session;
   }
 
+  /**
+   * Whether this output is the one that person is CONSUMING.
+   *
+   * A person holds a record on more outputs than they are watching, and the two
+   * are different facts. The picture is where their record lives — the browser
+   * addresses it, their chosen soundtrack is written on it, their position is
+   * read from it — so they never stop being known to it; but the moment they
+   * step down to 480p, the 1080p output is producing for nobody.
+   *
+   * Which is why this exists and why it is here. It is asked when the priority
+   * map of one output is built, and it decides whether an encoder on that output
+   * is wanted at all. Without it every output of a film was handed the film's
+   * whole map: the plan wanted an encoder on each, the session manager killed
+   * the ones it judged unwatched, and the viewer's own move announced itself and
+   * started them again — the two authorities of 2026-09-08.
+   *
+   * The viewer arrives as PLAIN FIELDS. This layer knows the shape of a film — a
+   * picture, its steps, its soundtracks — and the viewer layer knows where a
+   * person stands; neither holds the other.
+   *
+   * STATED AS A REFUSAL, and deliberately only where the refusal is certain.
+   * Being known to an output is watching it everywhere except one case, because
+   * everywhere else a person who stops watching is let go of: a soundtrack
+   * nobody chose, a step nobody is on. The exception is the picture itself,
+   * which they are never let go of — and which therefore had no way at all of
+   * knowing it was producing for nobody.
+   *
+   * So a step, a soundtrack, a step being warmed, a step whose init has just
+   * been asked for: all watched, as before. The picture: watched unless this
+   * person is on a step of it.
+   *
+   * @param {object} session
+   * @param {{ activeVariantId?: string | null, warmingVariantId?: string | null }} viewer
+   * @returns {boolean}
+   */
+  watchedBy(session, viewer) {
+    if (!session || !viewer) {
+      return false;
+    }
+    if (session.isStep === true || session.audioOnly === true) {
+      return true;
+    }
+    // The picture. A step of it on their screen is a statement that they are
+    // not looking at this; a step merely being made ready for them is not, and
+    // during a warm-up both are genuinely being produced.
+    const step = viewer.activeVariantId ?? null;
+    return step === null || step === session.id;
+  }
+
   /**
    * Which variant a session IS, as a height. Zero encode height means "keep the
    * source", so the source's own height is the answer.

package/services/priority/PriorityOrchestrator.js

@@ -1,174 +1,278 @@
-/**
- * @file The priority map, built once and handed to everybody who acts on it.
- *
- * One map per film, in seconds of film against a number. It is built from where
- * the viewers are and nothing else, and both of the things that do work — the
- * encoding and the downloading — read it and decide for themselves. They do not
- * talk to each other, and neither of them tells this class anything.
- *
- * **Why it has to be published rather than asked for.** The downloading lives
- * in another thread. Until now it took its orders from the reads themselves:
- * every read declared a window around its own head, so fifteen reads declared
- * fifteen windows on a piece store that holds sixteen pieces. Half of all
- * evictions then took a piece a reader had said it wanted, two thirds of reads
- * came back from disk, and what `/stream` handed out stopped being the file's
- * bytes — twenty-two source-parse errors, a segment the player could not
- * append, and an empty picture for six minutes (field 2026-09-05).
- */
-
-import { emptyMap, mapForViewer, mergeMaps, runsOf } from "./PriorityMap.js";
-
-export class PriorityOrchestrator {
-  /** Where the map goes once it is built. @type {(published: object) => void} */
-  #publish;
-
-  /** The last map published per film and file, so an unchanged one is not resent. */
-  #last = new Map();
-
-  /** The last map BUILT per film and file, for whoever reads instead of being
-   * handed it. @type {Map<string, import("./PriorityMap.js").PriorityMap>} */
-  #maps = new Map();
-
-  /** Who is watching one session. @type {(session: object) => Map<string, object>} */
-  #viewersOf;
-
-  /** How wide the first band of one session's file is. @type {(session: object) => number} */
-  #allowanceFor;
-
-  /**
-   * This layer states facts and imports nothing above itself, so what it needs
-   * of a session — who is watching it, and how wide an interruption this file
-   * has shown on this swarm — is passed in.
-   *
-   * @param {object} params
-   * @param {(published: { sourceKey: string, fileIndex: number, durationSeconds: number,
-   *   zones: { from: number, to: number, priority: number }[] }) => void} params.publish
-   * @param {(session: object) => Map<string, object>} [params.viewersOf]
-   * @param {(session: object) => number} [params.allowanceFor]
-   */
-  constructor({ publish, viewersOf, allowanceFor }) {
-    this.#publish = typeof publish === "function" ? publish : () => {};
-    this.#viewersOf = typeof viewersOf === "function" ? viewersOf : () => new Map();
-    this.#allowanceFor = typeof allowanceFor === "function" ? allowanceFor : () => 0;
-  }
-
-  /**
-   * The map for one film, from everyone watching it.
-   *
-   * @param {object} params
-   * @param {string} params.sourceKey
-   * @param {number} params.fileIndex
-   * @param {number} params.durationSeconds
-   * @param {number} params.allowanceSeconds - The measured depth below which an
-   *   interruption reaches a viewer of this file.
-   * @param {{ atSeconds: number, playing: boolean }[]} params.viewers
-   * @returns {import("./PriorityMap.js").PriorityMap} One number per second of
-   *   film, merged over everyone watching it.
-   */
-  build({ sourceKey, fileIndex, durationSeconds, allowanceSeconds, viewers }) {
-    const map = mergeMaps(
-      (viewers ?? []).map((viewer) =>
-        mapForViewer({
-          atSeconds: viewer.atSeconds,
-          durationSeconds,
-          allowanceSeconds,
-          playing: viewer.playing !== false
-        })
-      )
-    );
-    const key = `${sourceKey}:${fileIndex}`;
-    this.#maps.set(key, map);
-    // Unchanged maps are not republished: the downloading rebuilds what it asks
-    // the swarm for on every one, and a viewer sitting still would otherwise
-    // make it do that several times a second. Compared as stretches rather than
-    // second by second, which is the same comparison over far fewer values.
-    const zones = runsOf(map);
-    const shape = JSON.stringify(zones);
-    if (this.#last.get(key) !== shape) {
-      this.#last.set(key, shape);
-      this.#publish({ sourceKey, fileIndex, durationSeconds, zones });
-    }
-    return map;
-  }
-
-  /**
-   * Build and publish the map for every file anybody is watching.
-   *
-   * One map per FILE, not per output: the picture, a quality step and a
-   * soundtrack of one film are three outputs reading the same bytes, and the
-   * swarm is asked for bytes. Viewers of all of them merge into one map.
-   *
-   * @param {object} params
-   * @param {Iterable<object[]>} params.sessionGroups - The live sessions, in
-   *   whatever grouping the caller holds them; they are regrouped by file here.
-   * @param {number} params.staleAfterMs - How long a viewer may be silent and
-   *   still count as watching.
-   * @param {number} [params.now]
-   * @returns {void}
-   */
-  publishFor({ sessionGroups, staleAfterMs, now = Date.now() }) {
-    /** @type {Map<string, { sourceKey: string, fileIndex: number, durationSeconds: number, allowanceSeconds: number, viewers: object[] }>} */
-    const byFile = new Map();
-    for (const sessions of sessionGroups) {
-      for (const session of sessions) {
-        const key = `${session.sourceKey}:${session.fileIndex}`;
-        let held = byFile.get(key);
-        if (!held) {
-          held = {
-            sourceKey: session.sourceKey,
-            fileIndex: session.fileIndex,
-            durationSeconds: Number(session.file?.durationSeconds) || 0,
-            // The first band is as wide as an interruption this file has
-            // actually shown on this swarm, never a chosen number.
-            allowanceSeconds: this.#allowanceFor(session),
-            viewers: []
-          };
-          byFile.set(key, held);
-        }
-        for (const viewer of this.#viewersOf(session).values()) {
-          if (viewer.isPresent(now, staleAfterMs)) {
-            held.viewers.push({
-              atSeconds: viewer.positionSeconds() ?? 0,
-              playing: viewer.playing !== false
-            });
-          }
-        }
-      }
-    }
-    for (const one of byFile.values()) {
-      // A file of unknown length cannot be divided into zones, and a file
-      // nobody is watching has nothing to be urgent about.
-      if (one.durationSeconds > 0 && one.viewers.length > 0) {
-        this.build(one);
-      }
-    }
-  }
-
-  /**
-   * Nobody is watching this file any more.
-   *
-   * @param {string} sourceKey
-   * @param {number} fileIndex
-   */
-  /**
-   * The map this class last built for one file.
-   *
-   * Read by whoever acts on it and cannot be handed it at the moment it is
-   * made — the encoding decides per output, and one file has several. It is the
-   * SAME map: built once here, from where the viewers are, and neither read
-   * changes it.
-   *
-   * @param {string} sourceKey
-   * @param {number} fileIndex
-   * @returns {import("./PriorityMap.js").PriorityMap} A map of no length where
-   *   none was built, which says the same as a map with nothing in it.
-   */
-  mapFor(sourceKey, fileIndex) {
-    return this.#maps.get(`${sourceKey}:${fileIndex}`) ?? emptyMap(0);
-  }
-
-  forget(sourceKey, fileIndex) {
-    this.#last.delete(`${sourceKey}:${fileIndex}`);
-    this.#maps.delete(`${sourceKey}:${fileIndex}`);
-  }
-}
+/**
+ * @file The priority map, built once and handed to everybody who acts on it.
+ *
+ * One map per film, in seconds of film against a number. It is built from where
+ * the viewers are and nothing else, and both of the things that do work — the
+ * encoding and the downloading — read it and decide for themselves. They do not
+ * talk to each other, and neither of them tells this class anything.
+ *
+ * **Why it has to be published rather than asked for.** The downloading lives
+ * in another thread. Until now it took its orders from the reads themselves:
+ * every read declared a window around its own head, so fifteen reads declared
+ * fifteen windows on a piece store that holds sixteen pieces. Half of all
+ * evictions then took a piece a reader had said it wanted, two thirds of reads
+ * came back from disk, and what `/stream` handed out stopped being the file's
+ * bytes — twenty-two source-parse errors, a segment the player could not
+ * append, and an empty picture for six minutes (field 2026-09-05).
+ */
+
+import { emptyMap, mapForViewer, mergeMaps, runsOf } from "./PriorityMap.js";
+
+export class PriorityOrchestrator {
+  /** Where the map goes once it is built. @type {(published: object) => void} */
+  #publish;
+
+  /** The last map published per film and file, so an unchanged one is not resent. */
+  #last = new Map();
+
+  /** The last map BUILT per film and file, for whoever reads instead of being
+   * handed it. @type {Map<string, import("./PriorityMap.js").PriorityMap>} */
+  #maps = new Map();
+
+  /**
+   * The last map built per OUTPUT, from the viewers of that output alone.
+   *
+   * The same fact answered at two scopes, because the two things that act on it
+   * ask at two scopes and both are right. The swarm is asked for bytes of a
+   * FILE, and the picture, a quality step and a soundtrack of one film read the
+   * same bytes — so every viewer of any of them wants that file's bytes.
+   * Encoders are placed per OUTPUT, and a person watching 480p wants nothing of
+   * the 1080p output at all.
+   *
+   * One map for both was the second authority over encoders. Every output of a
+   * film was handed the whole film's map, so the plan wanted an encoder on every
+   * one of them; what actually stopped the ones nobody was watching was the
+   * session manager killing them by its own judgement — and since a viewer
+   * moving between steps also announces itself, the plan started them again on
+   * the next pass. Two parties answering "should this encoder exist" by different
+   * rules, several times a second.
+   *
+   * @type {Map<string, import("./PriorityMap.js").PriorityMap>}
+   */
+  #byOutput = new Map();
+
+  /** Who is watching one session. @type {(session: object) => Map<string, object>} */
+  #viewersOf;
+
+  /** How wide the first band of one session's file is. @type {(session: object) => number} */
+  #allowanceFor;
+
+  /** Whether this output is what that person is consuming, as opposed to one
+   * they merely hold a record on. @type {(session: object, viewer: object) => boolean} */
+  #watchedBy;
+
+  /**
+   * This layer states facts and imports nothing above itself, so what it needs
+   * of a session — who is watching it, and how wide an interruption this file
+   * has shown on this swarm — is passed in.
+   *
+   * @param {object} params
+   * @param {(published: { sourceKey: string, fileIndex: number, durationSeconds: number,
+   *   zones: { from: number, to: number, priority: number }[] }) => void} params.publish
+   * @param {(session: object) => Map<string, object>} [params.viewersOf]
+   * @param {(session: object) => number} [params.allowanceFor]
+   * @param {(session: object, viewer: object) => boolean} [params.watchedBy] -
+   *   Whether this output is the one that person is consuming. Which of a film's
+   *   outputs a person has on screen is a fact about the film's shape, which
+   *   this layer does not know; absent, every registered viewer counts, and then
+   *   the per-output map says the same as the per-file one.
+   */
+  constructor({ publish, viewersOf, allowanceFor, watchedBy }) {
+    this.#publish = typeof publish === "function" ? publish : () => {};
+    this.#viewersOf = typeof viewersOf === "function" ? viewersOf : () => new Map();
+    this.#allowanceFor = typeof allowanceFor === "function" ? allowanceFor : () => 0;
+    this.#watchedBy = typeof watchedBy === "function" ? watchedBy : () => true;
+  }
+
+  /**
+   * A map from a set of viewers, and the ONE statement of how one is built.
+   *
+   * Asked at both scopes — once per film for the swarm, once per output for the
+   * encoders — and written once, because two copies of how a viewer's map is
+   * built is the same two-owners fault this class was split for.
+   *
+   * @param {object} params
+   * @param {number} params.durationSeconds
+   * @param {number} params.allowanceSeconds
+   * @param {{ atSeconds: number, playing: boolean }[]} params.viewers
+   * @returns {import("./PriorityMap.js").PriorityMap} A map of no length where
+   *   nobody is watching or the film's length is unknown, which says the same as
+   *   a map with nothing in it.
+   */
+  #mapFrom({ durationSeconds, allowanceSeconds, viewers }) {
+    if (!(durationSeconds > 0) || !(viewers?.length > 0)) {
+      return emptyMap(0);
+    }
+    return mergeMaps(
+      viewers.map((viewer) =>
+        mapForViewer({
+          atSeconds: viewer.atSeconds,
+          durationSeconds,
+          allowanceSeconds,
+          playing: viewer.playing !== false
+        })
+      )
+    );
+  }
+
+  /**
+   * The map for one film, from everyone watching it.
+   *
+   * @param {object} params
+   * @param {string} params.sourceKey
+   * @param {number} params.fileIndex
+   * @param {number} params.durationSeconds
+   * @param {number} params.allowanceSeconds - The measured depth below which an
+   *   interruption reaches a viewer of this file.
+   * @param {{ atSeconds: number, playing: boolean }[]} params.viewers
+   * @returns {import("./PriorityMap.js").PriorityMap} One number per second of
+   *   film, merged over everyone watching it.
+   */
+  build({ sourceKey, fileIndex, durationSeconds, allowanceSeconds, viewers }) {
+    const map = this.#mapFrom({ durationSeconds, allowanceSeconds, viewers });
+    const key = `${sourceKey}:${fileIndex}`;
+    this.#maps.set(key, map);
+    // Unchanged maps are not republished: the downloading rebuilds what it asks
+    // the swarm for on every one, and a viewer sitting still would otherwise
+    // make it do that several times a second. Compared as stretches rather than
+    // second by second, which is the same comparison over far fewer values.
+    const zones = runsOf(map);
+    const shape = JSON.stringify(zones);
+    if (this.#last.get(key) !== shape) {
+      this.#last.set(key, shape);
+      this.#publish({ sourceKey, fileIndex, durationSeconds, zones });
+    }
+    return map;
+  }
+
+  /**
+   * Build and publish the map for every file anybody is watching.
+   *
+   * One map per FILE, not per output: the picture, a quality step and a
+   * soundtrack of one film are three outputs reading the same bytes, and the
+   * swarm is asked for bytes. Viewers of all of them merge into one map.
+   *
+   * @param {object} params
+   * @param {Iterable<object[]>} params.sessionGroups - The live sessions, in
+   *   whatever grouping the caller holds them; they are regrouped by file here.
+   * @param {number} params.staleAfterMs - How long a viewer may be silent and
+   *   still count as watching.
+   * @param {number} [params.now]
+   * @returns {void}
+   */
+  publishFor({ sessionGroups, staleAfterMs, now = Date.now() }) {
+    /** @type {Map<string, { sourceKey: string, fileIndex: number, durationSeconds: number, allowanceSeconds: number, viewers: object[] }>} */
+    const byFile = new Map();
+    /** @type {Map<string, { durationSeconds: number, allowanceSeconds: number, viewers: object[] }>} */
+    const byOutput = new Map();
+    for (const sessions of sessionGroups) {
+      for (const session of sessions) {
+        const key = `${session.sourceKey}:${session.fileIndex}`;
+        const durationSeconds = Number(session.file?.durationSeconds) || 0;
+        // The first band is as wide as an interruption this file has actually
+        // shown on this swarm, never a chosen number.
+        const allowanceSeconds = this.#allowanceFor(session);
+        let held = byFile.get(key);
+        if (!held) {
+          held = {
+            sourceKey: session.sourceKey,
+            fileIndex: session.fileIndex,
+            durationSeconds,
+            allowanceSeconds,
+            viewers: []
+          };
+          byFile.set(key, held);
+        }
+        // Every output anybody holds a session for, whether or not a viewer is
+        // consuming it — an output with nobody on it must get a map with
+        // nothing in it, which is how the plan is told to stop its encoders.
+        // Left out, it would keep the map it had when somebody was watching.
+        const address = session.outputKey ?? "";
+        let mine = byOutput.get(address);
+        if (!mine) {
+          mine = { durationSeconds, allowanceSeconds, viewers: [] };
+          byOutput.set(address, mine);
+        }
+        for (const viewer of this.#viewersOf(session).values()) {
+          if (!viewer.isPresent(now, staleAfterMs)) {
+            continue;
+          }
+          const stated = {
+            atSeconds: viewer.positionSeconds() ?? 0,
+            playing: viewer.playing !== false
+          };
+          held.viewers.push(stated);
+          if (this.#watchedBy(session, viewer)) {
+            mine.viewers.push(stated);
+          }
+        }
+      }
+    }
+    // WHAT THIS PASS SAW IS ALL THERE IS. Everything below is derived from the
+    // live sessions, so a file or an output that is not among them is gone —
+    // and these maps are the projection of that, never a memory of it. Left to
+    // accumulate they were three maps that only grew, which is the shape of half
+    // the memory faults recorded in this repository, and `forget` was written
+    // for it and called from nowhere.
+    for (const key of [...this.#maps.keys()]) {
+      if (!byFile.has(key)) {
+        this.#maps.delete(key);
+        this.#last.delete(key);
+      }
+    }
+    for (const address of [...this.#byOutput.keys()]) {
+      if (!byOutput.has(address)) {
+        this.#byOutput.delete(address);
+      }
+    }
+    for (const one of byFile.values()) {
+      // A file of unknown length cannot be divided into zones, and a file
+      // nobody is watching has nothing to be urgent about.
+      if (one.durationSeconds > 0 && one.viewers.length > 0) {
+        this.build(one);
+      }
+    }
+    for (const [address, one] of byOutput) {
+      this.#byOutput.set(address, this.#mapFrom(one));
+    }
+  }
+
+  /**
+   * Nobody is watching this file any more.
+   *
+   * @param {string} sourceKey
+   * @param {number} fileIndex
+   */
+  /**
+   * The map this class last built for one file.
+   *
+   * Read by whoever acts on it and cannot be handed it at the moment it is
+   * made — the encoding decides per output, and one file has several. It is the
+   * SAME map: built once here, from where the viewers are, and neither read
+   * changes it.
+   *
+   * @param {string} sourceKey
+   * @param {number} fileIndex
+   * @returns {import("./PriorityMap.js").PriorityMap} A map of no length where
+   *   none was built, which says the same as a map with nothing in it.
+   */
+  mapFor(sourceKey, fileIndex) {
+    return this.#maps.get(`${sourceKey}:${fileIndex}`) ?? emptyMap(0);
+  }
+
+  /**
+   * The map for ONE output, from the viewers consuming that output.
+   *
+   * What the encoding reads. A map of no length says nobody is on this output,
+   * which is what makes an encoder on it unwanted — and it is a statement, not
+   * an absence: the walk above writes one for every output a session exists
+   * for, including the ones everybody has left.
+   *
+   * @param {string} address
+   * @returns {import("./PriorityMap.js").PriorityMap}
+   */
+  mapForOutput(address) {
+    return this.#byOutput.get(address) ?? emptyMap(0);
+  }
+
+}

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

@@ -143,3 +143,60 @@ test("what a model prices a film at", () => {
   // 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"
+  );
+});

package/{test-measured/decode-cost.measured.js → test/decode-cost.test.js}

@@ -6,10 +6,19 @@
  * claiming the host cleared the bar 2.5 times over — the error on that rung was
  * 209 %. The decode term brings a controlled measurement to within 5 %.
  *
- * The first test runs the real benchmark against the shipped clips with the
- * real ffmpeg, because a fit that only ever runs against invented numbers can
- * be wrong in every way that matters (2.9.124: a module tested only through its
- * own exports missed the caller that never called it).
+ * WHAT IS ASSERTED HERE IS ARITHMETIC, over constants that were measured once
+ * on the addon host and written down. The live benchmark used to run here too —
+ * on the reasoning that a fit which only ever meets invented numbers can be
+ * wrong in every way that matters — and it could not be asserted about: a clip
+ * that "said nothing" under load makes the whole benchmark answer with nothing,
+ * so the very first line of that test failed by luck. The orderings it was for
+ * are held over the fit itself, deterministically, in `decode-cost-fit.test.js`.
+ *
+ * What no test covers as a result is the live path — lifting a clip out of its
+ * container, feeding it through the pipe, reading the slope. That is integration
+ * over real ffmpeg, and it belongs to a stand run before a release rather than
+ * to a check that measures whatever else the machine was doing (roadmap item
+ * 52).
  */
 
 import test from "node:test";
@@ -23,7 +32,6 @@ import { Output } from "../services/output/Output.js";
 import os from "node:os";
 import path from "node:path";
 import {
-  benchmarkDecodeCost,
   canSustainOutput,
   decodeSpeedFor,
   predictedRealtimeSpeed,
@@ -45,37 +53,6 @@ const ADDON_HOST_MODEL = { pixelTerm: 0.005555, bitrateTerm: 0.00990, constantTe
 // The film measured that day: 1920x1080 at 24 fps, about 8 Mbit/s.
 const MEASURED_FILM = { megapixelsPerSecond: (1920 * 1080 * 24) / 1e6, megabitsPerSecond: 8 };
 
-test("the fit comes out of the real clips, and predicts one of them back", async () => {
-  const model = await benchmarkDecodeCost({ ffmpegBin });
-
-  assert.ok(model, "the clips ship with the package and this host has ffmpeg");
-  assert.ok(model.pixelTerm > 0, "more pixels cannot decode faster");
-  assert.ok(Number.isFinite(model.bitrateTerm) && Number.isFinite(model.constantTerm));
-
-  // What the model must get right is how cost SCALES from one source to
-  // another — that is the whole of its job, since it is asked about rungs
-  // nobody has decoded. So: a bigger, richer source is never cheaper.
-  //
-  // Deliberately not a numeric bound. This suite runs its files in parallel and
-  // the benchmark is a live measurement, so the fit it produces depends on what
-  // else the machine was doing: on this desktop the same clips have solved to
-  // pixels+bitrate+constant, to pixels alone, and — under load — to a
-  // constant-dominated shape whose 720p/1080p ratio was 1.32 rather than the
-  // ~2.4 of a quiet run. That instability is real and is recorded against
-  // roadmap item 1; pinning a number here would only pin how busy the machine
-  // happened to be. What the FIGURES are worth is checked where it is quiet:
-  // against the addon host's recorded constants below, and against the real
-  // film in the field.
-  const clip720 = { megapixelsPerSecond: (1280 * 720 * 24) / 1e6, megabitsPerSecond: 2.248 };
-  const clip1080 = { megapixelsPerSecond: (1920 * 1080 * 24) / 1e6, megabitsPerSecond: 11.375 };
-  const ratio = decodeSpeedFor(model, clip720) / decodeSpeedFor(model, clip1080);
-
-  assert.ok(
-    ratio >= 1,
-    `720p at a fifth of the bitrate cannot decode slower than 1080p; the fit says ${ratio.toFixed(2)}x`
-  );
-});
-
 test("decode cost prices the film it was checked against", () => {
   const speed = decodeSpeedFor(ADDON_HOST_MODEL, MEASURED_FILM);