@torrent-tv/proxy 2.89.2 → 2.89.4

package/services/encode/quality/link-budget.js

@@ -24,21 +24,6 @@
 
 import { AUDIO_TRANSCODE_KBPS, maxrateKbpsFor, nominalKbpsFor } from "../args.js";
 
-/**
- * How much of a measured link may be spent on the stream.
- *
- * The rest is what the link does when it is not being perfect: transport
- * framing, retransmission, the other tabs, the moment somebody else in the
- * house starts something. A load sized to the whole reading stalls on the
- * first of those.
- *
- * Chosen, not measured, and written as a constant rather than dressed up as a
- * measurement. What would replace it is a reading of the transport's own
- * overhead and of how far a link's throughput varies over a session, which
- * nothing takes.
- */
-export const LINK_SAFETY = 0.8;
-
 /** How far a figure in a load can be trusted. */
 export const PEAK_CLASS = Object.freeze({
   KNOWN: "known",
@@ -279,7 +264,11 @@ export function linkCouldCarry(linkMbps, load) {
   if (load.peakClass === PEAK_CLASS.UNKNOWN) {
     return answer(LINK_VERDICT.NO_SAFE_BOUND, false, false);
   }
-  if (linkMbps * LINK_SAFETY < load.totalMbps) {
+  // The measured link against the whole load, with no share held back. The
+  // reading is what the link carried while it carried a piece, and the stream
+  // needs that on average; what a link does when it is not perfect — a pause,
+  // another tab — is what the viewer's buffer and `drain-threat.js` measure.
+  if (linkMbps < load.totalMbps) {
     return answer(LINK_VERDICT.DOES_NOT_FIT, false, false);
   }
   return load.peakClass === PEAK_CLASS.KNOWN
@@ -338,7 +327,6 @@ export function linkAnswerFigures(answer) {
   return {
     verdict: answer.verdict,
     linkMbps: answer.linkMbps,
-    linkSafety: LINK_SAFETY,
     videoMbps: answer.load.video?.mbps ?? null,
     videoClass: answer.load.video?.peakClass ?? null,
     audioMbps: answer.load.audio?.mbps ?? null,

package/services/encode/run-inputs.js

@@ -11,6 +11,9 @@
  * sized in seconds of playback by whoever knows the file's byte rate.
  */
 
+/** The query parameter naming which run of an output a read feeds. */
+const RUN_PARAMETER = "run";
+
 /**
  * @param {object} params
  * @param {{ fileIndex: number, streamUrl: (baseUrl: string, options?: { sessionId?: string }) => URL }} params.picture
@@ -20,15 +23,23 @@
  * @param {"video-only" | "audio-only" | "muxed" | "empty"} params.carries
  * @param {boolean} params.audioSeparate - The picture's sound travels as its own output.
  * @param {string} params.sessionId - Which output this read feeds.
+ * @param {number} [params.runToken] - Which run of that output the read feeds,
+ *   so the time its input waits is charged to that run and not to another one
+ *   working on the same output.
  * @param {number} params.readWindowBytes - Zero when no window was measured.
  * @param {string} params.baseUrl
  * @returns {{ inputFile: object, audioFile: object, inputUrl: string, audioInputUrl: string }}
  */
-export function encoderInputs({ picture, soundtrack, carries, audioSeparate, sessionId, readWindowBytes, baseUrl }) {
+export function encoderInputs({ picture, soundtrack, carries, audioSeparate, sessionId, runToken, readWindowBytes, baseUrl }) {
   // A soundtrack shipped as its own file is encoded FROM that file, so a
   // rendition of it reads nothing else.
   const inputFile = carries === "audio-only" && soundtrack !== picture ? soundtrack : picture;
   const input = inputFile.streamUrl(baseUrl, { sessionId });
+  const forRun = (url) => {
+    if (Number.isInteger(runToken)) url.searchParams.set(RUN_PARAMETER, String(runToken));
+    return url;
+  };
+  forRun(input);
   if (Number.isFinite(readWindowBytes) && readWindowBytes > 0) {
     input.searchParams.set("windowBytes", String(readWindowBytes));
     input.searchParams.set("reader", "playback");
@@ -36,7 +47,7 @@ export function encoderInputs({ picture, soundtrack, carries, audioSeparate, ses
   // The second input exists only for a picture that carries its sound inside
   // itself when that sound is in another file.
   const audioInputUrl = carries !== "audio-only" && !audioSeparate && soundtrack !== inputFile
-    ? soundtrack.streamUrl(baseUrl, { sessionId }).toString()
+    ? forRun(soundtrack.streamUrl(baseUrl, { sessionId })).toString()
     : "";
   return { inputFile, audioFile: soundtrack, inputUrl: input.toString(), audioInputUrl };
 }

package/services/server/SegmentServing.js

@@ -607,7 +607,9 @@ export class SegmentServing {
       : this.#host.runStartTimeFor(session, this.#host.encodeRuns.earliestStartOf(session) ?? 0);
     const position = Number(progress?.processedSeconds);
     const produced = Number.isFinite(position) ? position - runStartSeconds : null;
-    const speed = progress?.speed || "n/a";
+    const measured = this.#host.encodeRuns.liveRunsOf(session)
+      .reduce((best, run) => Math.max(best, run.speedX || 0), 0);
+    const speed = measured > 0 ? `${measured.toFixed(2)}x` : "n/a";
     logger.warn(
       `transcode ${session.id} holding ${fileName}: ${reason} ` +
       `(runs from #${this.#host.encodeRuns.earliestStartOf(session) ?? "?"}, viewer at #${this.#host.outputTimes.segmentIndexForTime(session, this.#host.viewerSecondsOn(session))}, ` +

package/services/server/ViewerRequests.js

@@ -8,7 +8,7 @@
  */
 
 import { logger } from "../../utils/logger.js";
-import { isOutputName, SEGMENT_CUT_TIME_DELTA_SECONDS } from "../encode/output/index.js";
+import { isOutputName } from "../encode/output/index.js";
 
 function isWarmupTimeoutError(error) {
   if (!(error instanceof Error)) {
@@ -484,7 +484,6 @@ export class ViewerRequests {
       // segment (the only thing it waits for before playback starts) instead
       // of a percentage of the whole-file transcode.
       segmentDurationSec: this.#host.segmentDurationSec,
-      speed: progress.speed,
       outputMbps,
       playbackReadiness,
       // The height the viewer is WATCHING right now, which is what the menu
@@ -566,11 +565,7 @@ export class ViewerRequests {
       const timeline = output.timeline;
       const trackName = output === session ? "video" : "audio";
       const nativeRanges = Array.from({ length: timeline?.segmentCount ?? 0 }, (_, index) =>
-        this.#host.segmentStore.mediaRangesOf(output.outputKey, index, {
-          startSeconds: timeline.publishedStartOf(index),
-          endSeconds: index < timeline.segmentCount - 1 ?
-            timeline.publishedStartOf(index + 1) - SEGMENT_CUT_TIME_DELTA_SECONDS : undefined
-        }));
+        this.#host.encodeRuns.finishedMediaRangesOf(output, index));
       // The page states the offset its player applied to this track, and the
       // init it applied it to is the session's. Until both are known, the
       // pieces stay on their own presentation timeline: there is nothing yet

package/services/server/wire-outputs.js

@@ -247,7 +247,10 @@ export function wireOutputs({
     pathFor: (address) => parts.segmentStore.pathFor(address),
     initOf: (address) => parts.segmentStore.initOf(address),
     directoryFor: (address) => parts.segmentStore.directoryFor(address),
-    publish: (address, makingName, format, coverage) => parts.segmentStore.publish(address, makingName, format, coverage)
+    publish: (address, makingName, format, read) => parts.segmentStore.publish(address, makingName, format, read),
+    closedBytesOf: (address, makingName) => parts.segmentStore.closedBytesOf(address, makingName),
+    mediaRangesOf: (address, index, where) => parts.segmentStore.mediaRangesOf(address, index, where),
+    remove: (address, index, because) => parts.segmentStore.remove(address, index, because)
   };
   const segmentOutputFiles = {
     addresses: () => parts.segmentStore.addresses(),
@@ -257,7 +260,8 @@ export function wireOutputs({
     useFormat: (address, format) => parts.segmentStore.useFormat(address, format)
   };
   const segmentPaths = {
-    pathOf: (address, index) => parts.segmentStore.pathOf(address, index)
+    pathOf: (address, index) => parts.segmentStore.pathOf(address, index),
+    sizesOf: (address) => parts.segmentStore.sizesOf(address)
   };
   /**
    * Whether everything this output will ever serve is made: every segment of
@@ -303,6 +307,11 @@ export function wireOutputs({
   // The encoders of this proxy: built where the plan places them, followed while they run, accounted when they end.
   parts.encodeRuns = new EncodeRuns({
     logger,
+    // What this host is doing with an encode is learned each time a run has
+    // measured its processing speed, on every host.
+    noteRunSpeedMeasured: (session, run) => {
+      void parts.encodeCost.learnFrom(session, run);
+    },
     // What an admitted encode was seen to do, filed under its configuration.
     observeEncodeEnded: (session) => {
       if (!parts.localObservations || !session?.spec?.video?.encode) {
@@ -317,7 +326,6 @@ export function wireOutputs({
       });
     },
     viewerSecondsOn: (output, consumerId, now) => viewerSecondsOn(parts.viewers, output, consumerId, now),
-    noteRunStarting: (output) => parts.quality.noteRunStarting(output),
     inputOf: (...args) => parts.renditions.inputOf(...args),
     producedNumbers: (...args) => parts.serving.producedNumbers(...args),
     servesAudioSeparately: (...args) => parts.renditions.servesAudioSeparately(...args),
@@ -809,11 +817,8 @@ export function wireOutputs({
     runningEncoders: () => parts.encodeOrchestrator.runningCount(),
     encodersRunningNow: () => parts.encodeOrchestrator.runningCount(),
     torrentCostSecFor: (session) => parts.hostLoad.torrentCostSecFor(session),
-    boundBy: (session) => parts.quality.classifyTranscodeBound(session),
     runsFor: (session) => parts.encodeRuns.runsOf(session),
-    stateFor: (session) => parts.encodeRuns.runStateOf(session),
-    // The run's OWN progress: a speed is a pair of readings of one process.
-    progressFor: (_session, run) => run?.progress?.snapshot?.() ?? null
+    stateFor: (session) => parts.encodeRuns.runStateOf(session)
   });
   // WHICH HEIGHTS ARE ON THE MENU, which is the arithmetic above plus three
   // things that are nothing to do with it: whose answer it is, what may never

package/services/storage/segment-store/SegmentStore.js

@@ -421,33 +421,24 @@ export class SegmentStore {
    * over with the picture frozen at 319.66 s. `segment-00055.mp4` went the same
    * way, 211 957 against 2 620 617.
    *
+   * Whether the piece is whole is decided before this, by the encoding
+   * (`encode/piece-completeness.js`): the store keeps bytes and what is read
+   * from them, and does not judge them.
+   *
    * @param {string} key
    * @param {string} makingName - What the encoder called it while writing.
-   * @param {{ servedNameOf?: (name: string) => string | null }} format
+   * @param {{ servedNameOf?: (name: string) => string | null, segmentIndexFromName?: (name: string) => number }} format
+   * @param {{ mediaRanges?: object | null }} [read] - The piece's media
+   *   intervals as its format read them from the closed file, kept with it.
    * @returns {string | null} The served name, or null where nothing was renamed.
    */
-  publish(key, makingName, format, { endSeconds } = {}) {
+  publish(key, makingName, format, { mediaRanges = null } = {}) {
     const served = format?.servedNameOf?.(makingName) ?? null;
     if (!served) {
       return null;
     }
     const dir = path.join(this.#root, directoryNameFor(key));
     const index = format?.segmentIndexFromName?.(served) ?? -1;
-    let mediaRanges = null;
-    if (format?.readMediaRanges && index >= 0) {
-      try {
-        mediaRanges = format.readMediaRanges(readFileSync(path.join(dir, makingName)));
-        const end = format.producedThroughSeconds?.(mediaRanges);
-        if (end === null) throw new Error("The closed file contains no playable media intervals.");
-        if (Number.isFinite(endSeconds) && Number.isFinite(end) && end < endSeconds) {
-          this.#logger?.warn?.(`segment store: refusing short segment ${index}: produced through ${end}s, cut ${endSeconds}s`);
-          return null;
-        }
-      } catch (error) {
-        this.#logger?.warn?.(`segment store: could not read media coverage of ${makingName}: ${error.message}`);
-        return null;
-      }
-    }
     try {
       renameSync(path.join(dir, makingName), path.join(dir, served));
     } catch (error) {
@@ -476,20 +467,32 @@ export class SegmentStore {
     return served;
   }
 
-  mediaRangesOf(key, index, { startSeconds = 0, endSeconds } = {}) {
+  /**
+   * The bytes of a file the encoder has closed under its working name, for the
+   * encoding to judge before it is published.
+   *
+   * @param {string} key
+   * @param {string} makingName
+   * @returns {Buffer}
+   */
+  closedBytesOf(key, makingName) {
+    return readFileSync(path.join(this.#root, directoryNameFor(key), makingName));
+  }
+
+  /**
+   * The media intervals a stored piece holds, read once from its bytes and kept
+   * with them, or undefined where its format reads none or it is not here.
+   *
+   * @param {string} key
+   * @param {number} index
+   * @param {{ startSeconds?: number }} [where] - Where its cut puts it.
+   * @returns {object | undefined}
+   */
+  mediaRangesOf(key, index, { startSeconds = 0 } = {}) {
     const known = this.#mediaRanges.get(key)?.get(index);
     const format = this.#formats.get(key);
     if (!format?.readMediaRanges) return undefined;
-    const checked = (ranges) => {
-      const end = format.producedThroughSeconds?.(ranges);
-      if (Number.isFinite(endSeconds) && Number.isFinite(end) && end < endSeconds) {
-        this.#logger?.warn?.(`segment store: removing short cached segment ${index}: produced through ${end}s, cut ${endSeconds}s`);
-        this.#removeSegment(key, index);
-        return undefined;
-      }
-      return ranges;
-    };
-    if (known) return checked(known);
+    if (known) return known;
     const filePath = this.pathOf(key, index);
     if (!filePath) return undefined;
     try {
@@ -506,7 +509,7 @@ export class SegmentStore {
       const byIndex = this.#mediaRanges.get(key) ?? new Map();
       byIndex.set(index, ranges);
       this.#mediaRanges.set(key, byIndex);
-      return checked(ranges);
+      return ranges;
     } catch {
       return [];
     }
@@ -1086,6 +1089,20 @@ export class SegmentStore {
       .map(({ key, index }) => ({ key, index }));
   }
 
+  /**
+   * Take one segment off the disk because its owner says it is not usable.
+   *
+   * @param {string} key
+   * @param {number} index
+   * @param {string} because
+   * @returns {void}
+   */
+  remove(key, index, because) {
+    if (this.#removeSegment(key, index) > 0) {
+      this.#logger?.warn?.(`segment store: removed segment ${index} of ${key.slice(0, 60)}: ${because}`);
+    }
+  }
+
   /**
    * Take one segment off the disk.
    *

package/services/torrent/supply-margin.js

@@ -141,11 +141,13 @@ export function requiredSpeedFrom(waits) {
   const lostSec = interruptions
     .slice(0, last)
     .reduce((total, one) => total + (one.end - one.start), 0) / 1000;
-  // A span that is all interruption says the supply delivered nothing at all
-  // while it was watched. There is no speed that survives that, and saying a
-  // huge number is less honest than saying it is not a speed question — so the
-  // largest figure any step is ever compared against is stated and named.
-  const lostShare = spanSec > 0 ? Math.min(0.99, lostSec / spanSec) : 0;
+  // Strictly below one: the span holds at least one gap of positive length
+  // (`intervals` above is not empty), and the gaps are the time the supply
+  // delivered. So the speed this asks for is finite whatever it measured, and
+  // it is not cut down to a figure chosen here: a supply that delivered for a
+  // thousandth of the time asks a thousand times realtime, which no re-encode
+  // meets and which leaves the copy, as it should.
+  const lostShare = spanSec > 0 ? lostSec / spanSec : 0;
   return {
     requiredSpeed: 1 / (1 - lostShare),
     lostShare,

package/test/auto-quality-step.test.js

@@ -18,7 +18,7 @@
 
 import test from "node:test";
 import { recordViewerReport } from "../services/viewer/report-intake.js";
-import { fakeProcess as fakeEncoder, startRunOn } from "./helpers/encode-run.js";
+import { fakeProcess as fakeEncoder, measureSpeed, startRunOn } from "./helpers/encode-run.js";
 import assert from "node:assert/strict";
 import { SourceFile } from "../services/media/SourceFile.js";
 import { Timeline } from "../services/encode/output/Timeline.js";
@@ -92,7 +92,7 @@ function fakeSession({ dirPath, transcodeVideo = true, cutGrid = transcodeVideo
     usesExplicitCuts: false,
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
-    progress: { state: "running", processedSeconds: 40, startPositionSeconds: 0, speed: "1.0x" }
+    progress: { state: "running", processedSeconds: 40, startPositionSeconds: 0 }
   };
 }
 
@@ -162,7 +162,7 @@ function drainingReports(viewer, linkMbps) {
  * This viewer's page reports a buffer that grows, on the link named.
  *
  * @param {object} viewer
- * @param {number} linkMbps
+ * @param {number | null} linkMbps - Null when the page has not measured it.
  * @returns {void}
  */
 function fillingReports(viewer, linkMbps) {
@@ -195,12 +195,12 @@ test("a picture that cannot be kept up with is asked for as another VARIANT, and
   });
 
   const sizeBefore = `${session.encodeWidth}x${session.encodeHeight}`;
-  // Sustained sub-realtime, read as a slope: the run has been slow since well
-  // before the window, and the reading is from this very run.
-  qualityStateOf(session).budgetSlowSince = Date.now() - 60_000;
-  qualityStateOf(session).recentSpeed = { speed: 0.7, at: Date.now(), run: [...session.runs][0] };
+  // Below realtime over its own working time, and the viewer's buffer runs
+  // dry on its trend although their link carries the stream.
+  measureSpeed([...session.runs][0], 0.7);
+  drainingReports(manager.viewers.get("viewer"), 80);
 
-  await manager.quality.runQualityBudgetOnce();
+  await manager.quality.noteViewerReported(session.id, "viewer");
 
   assert.equal(
     `${session.encodeWidth}x${session.encodeHeight}`,
@@ -224,10 +224,10 @@ test("a manual viewer is never sent an automatic quality request", async (t) =>
     await rm(dirPath, { recursive: true, force: true });
   });
   manager.viewers.get("viewer").qualityMode = "manual";
-  qualityStateOf(session).budgetSlowSince = Date.now() - 60_000;
-  qualityStateOf(session).recentSpeed = { speed: 0.7, at: Date.now(), run: [...session.runs][0] };
+  measureSpeed([...session.runs][0], 0.7);
+  drainingReports(manager.viewers.get("viewer"), 80);
 
-  await manager.quality.runQualityBudgetOnce();
+  await manager.quality.noteViewerReported(session.id, "viewer");
 
   assert.equal(manager.viewers.get("viewer").qualityAsk, null);
   const progress = await manager.viewerRequests.getSessionProgress(BASE_ID, "viewer");
@@ -255,8 +255,8 @@ test("the request reaches the browser in the progress report, and stops once the
   assert.equal(manager.viewers.get("viewer").qualityAsk, null, "and it is let go of, not merely hidden");
 });
 
-test("a request the player never follows runs out instead of being repeated for the whole film", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
+test("a request stands while its conditions hold, and the next report that does not ask for it lets it go", async (t) => {
+  const { manager, session, dirPath } = await managerWithSession();
   t.after(async () => {
     await manager.lifecycle.disposeAll();
     // The store closes its watch on the directory as it drops the output, and
@@ -265,14 +265,39 @@ test("a request the player never follows runs out instead of being repeated for
     await rm(dirPath, { recursive: true, force: true });
   });
 
-  // A viewer on a manual pick ignores every request by design, and so does a
-  // stream with no variants. Neither is an error; both look the same from here.
+  // Asked when their buffer was running dry; no chosen time ends it.
   manager.viewers.get("viewer").qualityAsk = { height: 480, at: Date.now() - 120_000, reason: "measured" };
+  const standing = await manager.viewerRequests.getSessionProgress(BASE_ID, "viewer");
+  assert.equal(standing.requestedHeight, 480, "two minutes on, it still stands: nothing has said otherwise");
 
-  const progress = await manager.viewerRequests.getSessionProgress(BASE_ID, "viewer");
+  // Their next report shows a buffer that grows: what it was asked for is gone.
+  // The machine has no room to spare, so nothing else is asked in its place.
+  measureSpeed([...session.runs][0], 0.9);
+  fillingReports(manager.viewers.get("viewer"), null);
+  await manager.quality.noteViewerReported(session.id, "viewer");
 
+  const progress = await manager.viewerRequests.getSessionProgress(BASE_ID, "viewer");
   assert.equal(progress.requestedHeight, 0);
-  assert.equal(manager.viewers.get("viewer").qualityAsk, null, "said once and let go");
+  assert.equal(manager.viewers.get("viewer").qualityAsk, null, "let go by the judgement that did not repeat it");
+});
+
+test("a request the next report asks for again stands", async (t) => {
+  const { manager, session, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await manager.lifecycle.disposeAll();
+    await new Promise((resolve) => setImmediate(resolve));
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  measureSpeed([...session.runs][0], 0.7);
+  drainingReports(manager.viewers.get("viewer"), 80);
+  await manager.quality.noteViewerReported(session.id, "viewer");
+  const asked = manager.viewers.get("viewer").qualityAsk;
+  assert.ok(asked, "the machine cannot keep up and the buffer runs dry");
+
+  drainingReports(manager.viewers.get("viewer"), 80);
+  await manager.quality.noteViewerReported(session.id, "viewer");
+
+  assert.equal(manager.viewers.get("viewer").qualityAsk, asked, "the same request, not let go and not made again");
 });
 
 test("a COPIED picture is never asked to slow its encoder, because it has none", async (t) => {
@@ -287,10 +312,10 @@ test("a COPIED picture is never asked to slow its encoder, because it has none",
 
   // Whatever this reading says, a copy has no encoder to make cheaper: moving
   // the viewer to a RE-ENCODED rung costs the machine more, not less.
-  qualityStateOf(session).budgetSlowSince = Date.now() - 60_000;
-  qualityStateOf(session).recentSpeed = { speed: 0.4, at: Date.now(), run: [...session.runs][0] };
+  measureSpeed([...session.runs][0], 0.4);
+  drainingReports(manager.viewers.get("viewer"), 80);
 
-  await manager.quality.runQualityBudgetOnce();
+  await manager.quality.noteViewerReported(session.id, "viewer");
 
   assert.equal(manager.viewers.get("viewer").qualityAsk, null, "the copy path's lever is the viewer's link, not the CPU");
 });
@@ -467,15 +492,18 @@ test("the way BACK UP exists, one rung at a time", async (t) => {
     await rm(dirPath, { recursive: true, force: true });
   });
 
-  // The viewer is on 480p and the machine has been ahead of realtime for longer
-  // than the up window.
+  // The viewer is on 480p, the machine makes it ahead of realtime over its own
+  // working time, and their buffer grows and holds more than another output
+  // takes to be ready. No window has to pass: every term is measured.
   session.variantHeight = 480;
   session.encodeWidth = 854;
   session.encodeHeight = 480;
-  qualityStateOf(session).recentSpeed = { speed: 2.4, at: Date.now(), run: [...session.runs][0] };
-  qualityStateOf(session).budgetUpSince = Date.now() - 120_000;
+  measureSpeed([...session.runs][0], 2.4);
+  // Their link is not measured here: what is under test is the room, and a
+  // measured link would also weigh a soundtrack this fixture states no rate for.
+  fillingReports(manager.viewers.get("viewer"), null);
 
-  await manager.quality.runQualityBudgetOnce();
+  await manager.quality.noteViewerReported(session.id, "viewer");
 
   assert.ok(manager.viewers.get("viewer").qualityAsk, "for most of this project's life there was no step up at all");
   assert.equal(
@@ -642,8 +670,9 @@ test("a picture seen larger than the rung on screen is asked one rung up, when t
   session.variantHeight = 480;
   session.encodeWidth = 854;
   session.encodeHeight = 480;
-  qualityStateOf(session).recentSpeed = { speed: 2.4, at: Date.now(), run: [...session.runs][0] };
+  measureSpeed([...session.runs][0], 2.4);
   manager.viewers.get("viewer").noteVisiblePicture({ width: 1920, height: 1080 });
+  fillingReports(manager.viewers.get("viewer"), null);
 
   await manager.quality.noteViewerReported(session.id, "viewer");
 
@@ -696,12 +725,29 @@ test("a step down for the machine goes to the rung the picture seen bounds, wher
     await rm(dirPath, { recursive: true, force: true });
   });
   manager.viewers.get("viewer").noteVisiblePicture({ width: 640, height: 360 });
-  qualityStateOf(session).budgetSlowSince = Date.now() - 60_000;
-  qualityStateOf(session).recentSpeed = { speed: 0.7, at: Date.now(), run: [...session.runs][0] };
+  measureSpeed([...session.runs][0], 0.7);
+  drainingReports(manager.viewers.get("viewer"), 80);
 
-  await manager.quality.runQualityBudgetOnce();
+  await manager.quality.noteViewerReported(session.id, "viewer");
 
   const asked = manager.viewers.get("viewer").qualityAsk?.height;
   assert.ok(asked, "the machine cannot keep up: a step down is asked");
   assert.ok(asked <= 360, `not a rung between that the screen cannot show (asked for ${asked}p)`);
 });
+
+test("a machine below realtime whose viewer's buffer is filling moves nothing", async (t) => {
+  const { manager, session, dirPath } = await managerWithSession();
+  t.after(async () => {
+    await manager.lifecycle.disposeAll();
+    await new Promise((resolve) => setImmediate(resolve));
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  // What the cushion already holds covers the shortfall: no chosen window of
+  // slowness decides, the viewer's own buffer trend does.
+  measureSpeed([...session.runs][0], 0.7);
+  fillingReports(manager.viewers.get("viewer"), 80);
+
+  await manager.quality.noteViewerReported(session.id, "viewer");
+
+  assert.ok(!(manager.viewers.get("viewer").qualityAsk?.height < 720), "no step down while the buffer grows");
+});

package/test/decode-cost.test.js

@@ -355,7 +355,7 @@ test("the OFFER drops the rungs the host cannot hold, and the master keeps addre
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
     segmentCount: 100,
-    progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0, speed: "1.0x" }
+    progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0 }
   };
   manager.outputs.set(session.id, session);