@torrent-tv/proxy 2.89.3 → 2.89.5

package/test/encode-plan-viewers.test.js

@@ -28,6 +28,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { EventEmitter } from "node:events";
 import { EncodeRun } from "../services/encode/EncodeRun.js";
+import { measureSpeed } from "./helpers/encode-run.js";
 import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
 import { EncodeOrchestrator } from "../services/encode/EncodeOrchestrator.js";
 import { mapForViewer, mergeMaps, runsOf } from "../services/viewer/PriorityMap.js";
@@ -52,10 +53,16 @@ const SEGMENT_SECONDS = 4;
 const FILM_SECONDS = 4000;
 const SEGMENTS = FILM_SECONDS / SEGMENT_SECONDS;
 
+/** What every run of these tests reads as now; a measurement advances it. */
+const clock = { at: 1000 };
+
 class FakeProcess extends EventEmitter {
   constructor() {
     super();
     this.pid = 1;
+    // The progress channel and the channel closed pieces are named on.
+    this.stdout = new EventEmitter();
+    this.stdio = [null, this.stdout, null, new EventEmitter()];
   }
 
   kill(signal) {
@@ -75,7 +82,7 @@ function orchestrator({ maxRuns = 3 } = {}) {
     buildArgs: () => ["-i", "in", "out"],
     spawn: () => new FakeProcess(),
     logger: { info() {}, warn() {} },
-    now: () => 1000,
+    now: () => clock.at,
     onEnded: (ended) => made.noteEnded(ended)
   });
   made = new EncodeOrchestrator({
@@ -209,7 +216,7 @@ test("one viewer playing: the encoder keeping up buys no second one", () => {
   watches("one", { atSeconds: 400 });
   made.reconcile();
   const [run] = made.runsOn(PICTURE);
-  run.noteSpeed(6);
+  measureSpeed(run, 6, clock);
   for (let index = 100; index < 130; index += 1) {
     made.noteProduced(PICTURE, index);
   }
@@ -225,7 +232,7 @@ test("one viewer seeking far ahead: an encoder is placed there", () => {
   const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   made.reconcile();
-  made.runsOn(PICTURE)[0].noteSpeed(6);
+  measureSpeed(made.runsOn(PICTURE)[0], 6, clock);
   made.noteProduced(PICTURE, 100);
 
   // The peak JUMPS. Nothing about the old place is wanted now.
@@ -243,7 +250,7 @@ test("one viewer paused: nothing is late, so no encoder is added", () => {
   const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   made.reconcile();
-  made.runsOn(PICTURE)[0].noteSpeed(1);
+  measureSpeed(made.runsOn(PICTURE)[0], 1, clock);
   made.noteProduced(PICTURE, 100);
 
   watches("one", { atSeconds: 404, playing: false });
@@ -295,7 +302,7 @@ test("two viewers far apart get an encoder each", () => {
   const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   made.reconcile();
-  made.runsOn(PICTURE)[0].noteSpeed(6);
+  measureSpeed(made.runsOn(PICTURE)[0], 6, clock);
   made.noteProduced(PICTURE, 100);
 
   watches("two", { atSeconds: 3000 });
@@ -314,12 +321,12 @@ test("two viewers: one seeking does not take the other's encoder", () => {
   // long one takes to reach a number is the whole comparison. Real life
   // measures it from the first run; a test that stated both viewers before any
   // run existed would be asking the plan to buy a process on no evidence.
-  made.runsOn(PICTURE)[0].noteSpeed(6);
+  measureSpeed(made.runsOn(PICTURE)[0], 6, clock);
   made.noteProduced(PICTURE, 100);
   watches("two", { atSeconds: 3000 });
   made.reconcile();
   for (const run of made.runsOn(PICTURE)) {
-    run.noteSpeed(6);
+    measureSpeed(run, 6, clock);
   }
   assert.ok(made.runsOn(PICTURE).length >= 2, "one each to begin with");
 
@@ -342,7 +349,7 @@ test("two viewers: one pausing leaves the other served", () => {
   watches("two", { atSeconds: 3000 });
   made.reconcile();
   for (const run of made.runsOn(PICTURE)) {
-    run.noteSpeed(1);
+    measureSpeed(run, 1, clock);
   }
 
   watches("two", { atSeconds: 3000, playing: false });
@@ -359,7 +366,7 @@ test("two viewers: the one who leaves takes nothing from the one who stays", ()
   watches("two", { atSeconds: 3000 });
   made.reconcile();
   for (const run of made.runsOn(PICTURE)) {
-    run.noteSpeed(1);
+    measureSpeed(run, 1, clock);
   }
 
   leaves("two");
@@ -379,7 +386,7 @@ test("three viewers far apart get an encoder each when the machine affords it",
   watches("three", { atSeconds: 3600 });
   made.reconcile();
   for (const run of made.runsOn(PICTURE)) {
-    run.noteSpeed(6);
+    measureSpeed(run, 6, clock);
   }
   made.reconcile();
 
@@ -402,7 +409,7 @@ test("three viewers, a machine that affords two: the budget binds, not the map",
   watches("three", { atSeconds: 3600 });
   made.reconcile();
   for (const run of made.runsOn(PICTURE)) {
-    run.noteSpeed(1);
+    measureSpeed(run, 1, clock);
   }
   made.reconcile();
 
@@ -415,13 +422,13 @@ test("three viewers: one seeks onto another, and the two of them share", () => {
   const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   made.reconcile();
-  made.runsOn(PICTURE)[0].noteSpeed(6);
+  measureSpeed(made.runsOn(PICTURE)[0], 6, clock);
   made.noteProduced(PICTURE, 100);
   watches("two", { atSeconds: 2000 });
   watches("three", { atSeconds: 3600 });
   made.reconcile();
   for (const run of made.runsOn(PICTURE)) {
-    run.noteSpeed(6);
+    measureSpeed(run, 6, clock);
   }
   made.reconcile();
   assert.equal(made.runsOn(PICTURE).length, 3);
@@ -438,7 +445,7 @@ test("three viewers: all paused, and no encoder is added for any of them", () =>
   const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   made.reconcile();
-  made.runsOn(PICTURE)[0].noteSpeed(1);
+  measureSpeed(made.runsOn(PICTURE)[0], 1, clock);
   const before = made.runsOn(PICTURE).length;
 
   watches("one", { atSeconds: 400, playing: false });
@@ -461,7 +468,7 @@ test("the plan is a function of the state: the same state twice gives the same a
   watches("two", { atSeconds: 2000 });
   made.reconcile();
   for (const run of made.runsOn(PICTURE)) {
-    run.noteSpeed(1);
+    measureSpeed(run, 1, clock);
   }
   made.reconcile();
   const first = placements(made);
@@ -483,7 +490,7 @@ test("exactly realtime arrives exactly on time, and no second encoder is bought"
   const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   made.reconcile();
-  made.runsOn(PICTURE)[0].noteSpeed(1);
+  measureSpeed(made.runsOn(PICTURE)[0], 1, clock);
   made.noteProduced(PICTURE, 100);
   made.reconcile();
 
@@ -507,7 +514,7 @@ test("below realtime, whether a second encoder helps is arithmetic, and here it
   const { made, watches, leaves } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   made.reconcile();
-  made.runsOn(PICTURE)[0].noteSpeed(0.5);
+  measureSpeed(made.runsOn(PICTURE)[0], 0.5, clock);
   made.noteProduced(PICTURE, 100);
   made.reconcile();
 
@@ -531,7 +538,7 @@ test("two viewers arriving together on a cold output get one encoder, then are m
   assert.ok(made.runsOn(PICTURE).length >= 1, "at least one, until something is measured");
   assert.equal(onTheStretchOf(made, 100), 1, "and not two on the same place");
 
-  made.runsOn(PICTURE)[0].noteSpeed(6);
+  measureSpeed(made.runsOn(PICTURE)[0], 6, clock);
   made.noteProduced(PICTURE, 100);
   made.reconcile();
   assert.ok(placements(made).includes(750), "and now the far one is served too");
@@ -542,7 +549,7 @@ test("an encoder comfortably faster than realtime is left to do the whole stretc
   const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   made.reconcile();
-  made.runsOn(PICTURE)[0].noteSpeed(6);
+  measureSpeed(made.runsOn(PICTURE)[0], 6, clock);
   made.noteProduced(PICTURE, 100);
   made.reconcile();
 
@@ -561,7 +568,7 @@ test("a swarm that feeds one encoder moves it to whoever is late, rather than se
   const [run] = made.runsOn(PICTURE);
   // 6x against a swarm charging 0.25 s per second of film: one encoder already
   // takes one and a half of what is delivered, so the budget is one.
-  run.noteSpeed(6);
+  measureSpeed(run, 6, clock);
   made.refetchSecPerFilmSecond = () => 0.25;
   made.noteProduced(PICTURE, 100);
 
@@ -583,7 +590,7 @@ test("one viewer seeking back into film that exists is served from it, with no e
   const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   made.reconcile();
-  made.runsOn(PICTURE)[0].noteSpeed(6);
+  measureSpeed(made.runsOn(PICTURE)[0], 6, clock);
   for (let index = 100; index <= 160; index += 1) {
     made.noteProduced(PICTURE, index);
   }
@@ -616,7 +623,7 @@ test("one viewer seeking back into film nobody has gets an encoder there", () =>
   const { made, watches } = orchestrator();
   watches("one", { atSeconds: 3000 });
   made.reconcile();
-  made.runsOn(PICTURE)[0].noteSpeed(6);
+  measureSpeed(made.runsOn(PICTURE)[0], 6, clock);
   made.noteProduced(PICTURE, 750);
 
   watches("one", { atSeconds: 400 });
@@ -631,14 +638,14 @@ test("two viewers: one seeks back onto film the other already had made", () => {
   const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   made.reconcile();
-  made.runsOn(PICTURE)[0].noteSpeed(6);
+  measureSpeed(made.runsOn(PICTURE)[0], 6, clock);
   for (let index = 100; index <= 200; index += 1) {
     made.noteProduced(PICTURE, index);
   }
   watches("two", { atSeconds: 3000 });
   made.reconcile();
   for (const run of made.runsOn(PICTURE)) {
-    run.noteSpeed(6);
+    measureSpeed(run, 6, clock);
   }
   const before = made.runsOn(PICTURE).length;
 
@@ -662,7 +669,7 @@ test("three viewers: one forward, one back, one paused", () => {
   watches("three", { atSeconds: 3600 });
   made.reconcile();
   for (const run of made.runsOn(PICTURE)) {
-    run.noteSpeed(6);
+    measureSpeed(run, 6, clock);
   }
   made.reconcile();
 
@@ -690,7 +697,7 @@ test("a viewer scrubbing back and forth does not accumulate encoders", () => {
   const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   made.reconcile();
-  made.runsOn(PICTURE)[0].noteSpeed(6);
+  measureSpeed(made.runsOn(PICTURE)[0], 6, clock);
   made.noteProduced(PICTURE, 100);
   made.reconcile();
   const settled = placements(made);
@@ -698,7 +705,7 @@ test("a viewer scrubbing back and forth does not accumulate encoders", () => {
   watches("one", { atSeconds: 2000 });
   made.reconcile();
   for (const run of made.runsOn(PICTURE)) {
-    run.noteSpeed(6);
+    measureSpeed(run, 6, clock);
   }
   watches("one", { atSeconds: 404 });
   made.reconcile();

package/test/encode-run.test.js

@@ -146,13 +146,41 @@ test("a process that could not be started ends like any other failure", () => {
   assert.match(ends[0].because, /ENOENT/);
 });
 
-test("only a measured speed is kept", () => {
-  const { run } = makeRun();
+test("its speed is film made between closed pieces over its own working time", () => {
+  const clock = { at: 1000 };
+  const process_ = new FakeProcess();
+  process_.stdout = new EventEmitter();
+  process_.stdio = [null, process_.stdout, null, new EventEmitter()];
+  const readings = [];
+  const run = new EncodeRun({
+    address: "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy",
+    encoder: new SoftwareEncoder(),
+    from: 0,
+    to: 9,
+    buildArgs: () => [],
+    spawn: () => process_,
+    logger: { info() {}, warn() {} },
+    now: () => clock.at,
+    onSpeedMeasured: (reading) => readings.push(reading)
+  });
   assert.equal(run.speedX, 0, "nothing measured yet");
-  run.noteSpeed(0);
-  assert.equal(run.speedX, 0);
-  run.noteSpeed(2.5);
-  assert.equal(run.speedX, 2.5);
+  const report = (seconds) => process_.stdout.emit("data", `out_time_ms=${seconds * 1_000_000}\n`);
+  const closed = (name) => process_.stdio[3].emit("data", `${name}\n`);
+  report(0);
+  closed("a");
+  clock.at += 1000;
+  report(4);
+  closed("b"); // "a" is published: the reckoning starts here
+  assert.equal(run.speedX, 0, "one closed piece measures nothing");
+  // The input waits for the swarm for 30 s; that is not the run's work.
+  run.inputWaitBegins();
+  clock.at += 30_000;
+  run.inputWaitEnds();
+  clock.at += 2000;
+  report(12);
+  closed("c"); // "b" is published
+  assert.equal(run.speedX, 4, "8 s of film over 2 s of work");
+  assert.deepEqual(readings, [{ speed: 4, at: 34_000 }], "told once, with when");
 });
 
 test("a segment number behind its own start is not its to claim", () => {

package/test/encoder-readings.test.js

@@ -1,46 +1,68 @@
 /**
- * @file What two readings of a running encoder say about its speed.
+ * @file What two work samples of a running encoder say about its speed.
  *
- * The case this exists for is a COPY. ffmpeg's own cumulative `speed=` counts
- * the seconds the look-ahead cap keeps the encoder stopped, and a copy is
- * stopped for most of its life — reaching the cap in about fifteen seconds and
- * then waiting a minute. Read cumulatively, a copy running at 8x reports 1.6x,
- * which filed as the price of copying would refuse rungs on a measurement of a
- * pause.
+ * The cases this exists for: a copy whose cumulative speed counts the time it
+ * was stopped, and a run whose input waited for the swarm (field 2026-10-01: a
+ * copy read 0.21x after waiting 32.93 s and 43.91 s for two pieces). A work
+ * sample states the run's own working time, so neither enters the speed.
  */
 
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { speedFromReadings } from "../services/encode/encoder-readings.js";
+import { RunClock } from "../services/encode/RunClock.js";
+import { speedFromWork } from "../services/encode/encoder-readings.js";
 
-const at = (seconds, processedSeconds) => ({ takenAt: seconds * 1000, processedSeconds });
+const sample = (at, producedSeconds, workingMs) => ({ at, producedSeconds, workingMs });
 
-test("a copy producing eight seconds of video per second reads as eight", () => {
-  assert.equal(speedFromReadings(at(10, 100), at(15, 140), 3), 8);
+test("film made over the run's own work is the speed", () => {
+  assert.equal(speedFromWork(sample(10_000, 100, 5_000), sample(15_000, 140, 10_000)), 8);
 });
 
-test("a stretch too short to divide by says nothing", () => {
-  assert.equal(speedFromReadings(at(10, 100), at(11, 108), 3), null);
+test("a stretch with nothing made says nothing", () => {
+  assert.equal(speedFromWork(sample(10_000, 100, 5_000), sample(20_000, 100, 15_000)), null);
 });
 
-test("a run that produced nothing between the readings says nothing", () => {
-  // What a repositioned run looks like before it reaches its new start.
-  assert.equal(speedFromReadings(at(10, 100), at(20, 100), 3), null);
+test("a run that went backwards says nothing rather than a negative speed", () => {
+  assert.equal(speedFromWork(sample(10_000, 200, 5_000), sample(20_000, 100, 15_000)), null);
 });
 
-test("a run that went BACKWARDS says nothing rather than a negative speed", () => {
-  assert.equal(speedFromReadings(at(10, 200), at(20, 100), 3), null);
+test("a missing sample is not an answer", () => {
+  assert.equal(speedFromWork(null, sample(20_000, 100, 1_000)), null);
+  assert.equal(speedFromWork(sample(10_000, 100, 1_000), null), null);
 });
 
-test("a missing reading is not an answer", () => {
-  assert.equal(speedFromReadings(null, at(20, 100), 3), null);
-  assert.equal(speedFromReadings(at(10, 100), null, 3), null);
+test("waiting for the input and being stopped are not working time", () => {
+  let now = 0;
+  const clock = new RunClock({ now: () => now });
+  now = 2_000;
+  clock.inputWaitBegins();
+  now = 34_930; // the field's 32.93 s wait for one piece
+  clock.inputWaitEnds();
+  now = 36_000;
+  clock.stopped();
+  now = 50_000;
+  clock.continued();
+  now = 51_000;
+  assert.equal(clock.workingMs(), 2_000 + 1_070 + 1_000);
 });
 
-test("the pair is judged on wall clock, so a pause between them is the caller's problem", () => {
-  // Deliberate: this function cannot see a pause. The session drops its
-  // previous reading whenever the encoder is stopped or restarted, which is
-  // what makes every surviving pair an uninterrupted stretch.
-  assert.equal(speedFromReadings(at(0, 0), at(60, 60), 3), 1);
+test("two inputs waiting at once, or a wait while stopped, are idle once", () => {
+  let now = 0;
+  const clock = new RunClock({ now: () => now });
+  clock.inputWaitBegins();
+  now = 1_000;
+  clock.inputWaitBegins();
+  clock.stopped();
+  now = 3_000;
+  clock.inputWaitEnds();
+  clock.continued();
+  now = 4_000;
+  clock.inputWaitEnds();
+  now = 5_000;
+  assert.equal(clock.workingMs(), 1_000);
+  // An ongoing wait is idle up to the moment asked.
+  clock.inputWaitBegins();
+  now = 6_000;
+  assert.equal(clock.workingMs(), 1_000);
 });

package/test/helpers/encode-run.js

@@ -15,6 +15,79 @@
 
 import { EncodeRun } from "../../services/encode/EncodeRun.js";
 
+/** The working time between two closed pieces of a test measurement. */
+const MEASURED_STEP_MS = 1000;
+
+/** Closed pieces in a test measurement: the last two give the reading. */
+const MEASURED_STEPS = 3;
+
+/**
+ * The clock each run built by `startRunOn` reads: standing while a measurement
+ * is said, the wall clock otherwise. @type {WeakMap<EncodeRun, { at: number | null }>}
+ */
+const wallClocks = new WeakMap();
+
+/**
+ * Make a run measure a speed the way it does in the product: progress reports
+ * and the names of closed pieces on the encoder's own channels, one second of
+ * the run's own work apart. A closed piece is published when the next name
+ * arrives, and each publication is one reading against the one before, so the
+ * last of three steps reads exactly `speedX` whatever the run measured before.
+ *
+ * @param {EncodeRun} run - Its process exposes `stdout` and `stdio[3]`.
+ * @param {number} speedX - Film seconds per second of the run's work.
+ * @param {{ at: number } | null} [clock] - What the run's `now` reads; advanced
+ *   here. Absent for a run built by `startRunOn` without one: its clock is
+ *   stood just behind the wall clock for the measurement and released after,
+ *   so the reading is dated now.
+ * @param {number} [waitedMs] - How long the run's input waits for the swarm in
+ *   each step, on top of its second of work.
+ * @returns {void}
+ */
+export function measureSpeed(run, speedX, clock = null, waitedMs = 0) {
+  if (clock === null) {
+    const wall = wallClocks.get(run);
+    if (!wall) {
+      throw new TypeError("measureSpeed needs the clock the run reads");
+    }
+    // Never behind the run's start or its own last reading: a step back in
+    // time is no work.
+    wall.at = Math.max(
+      Date.now() - (MEASURED_STEP_MS + waitedMs) * MEASURED_STEPS,
+      run.startedAt,
+      run.speedReading?.at ?? Number.NEGATIVE_INFINITY
+    );
+    measureSpeed(run, speedX, wall, waitedMs);
+    wall.at = null;
+    return;
+  }
+  const { stdout, stdio } = run.process;
+  let produced = run.progress.processedSeconds - run.progress.startPositionSeconds;
+  for (let step = 0; step < MEASURED_STEPS; step += 1) {
+    if (waitedMs > 0) {
+      run.inputWaitBegins();
+      clock.at += waitedMs;
+      run.inputWaitEnds();
+    }
+    clock.at += MEASURED_STEP_MS;
+    produced += (speedX * MEASURED_STEP_MS) / 1000;
+    say(stdout, `out_time_ms=${Math.round(produced * 1_000_000)}\n`);
+    say(stdio[3], `measured-${step}\n`);
+  }
+}
+
+/**
+ * @param {{ write?: (text: string) => void, emit?: (event: string, text: string) => void }} channel
+ * @param {string} text
+ */
+function say(channel, text) {
+  if (typeof channel.write === "function") {
+    channel.write(text);
+  } else {
+    channel.emit("data", text);
+  }
+}
+
 /**
  * A child process that records what was done to it.
  *
@@ -26,6 +99,8 @@ import { EncodeRun } from "../../services/encode/EncodeRun.js";
 export function fakeProcess({ pid = null, exitsWhenKilled = true } = {}) {
   /** @type {Map<string, (...args: unknown[]) => void>} */
   const listeners = new Map();
+  const stdout = channel();
+  const closedPieces = channel();
   return {
     pid,
     killed: false,
@@ -33,8 +108,10 @@ export function fakeProcess({ pid = null, exitsWhenKilled = true } = {}) {
     signalCode: null,
     /** Every signal it was sent, in order. */
     signals: [],
-    stdout: { on() {} },
+    stdout,
     stderr: { on() {} },
+    // The descriptor the encoder names its closed pieces on (`-segment_list pipe:3`).
+    stdio: [null, stdout, null, closedPieces],
     on(event, handler) {
       const kept = listeners.get(event) ?? [];
       kept.push(handler);
@@ -71,6 +148,24 @@ export function fakeProcess({ pid = null, exitsWhenKilled = true } = {}) {
   };
 }
 
+/**
+ * A readable side of a pipe that a test writes into.
+ *
+ * @returns {{ on: (event: string, handler: (chunk: string) => void) => void, write: (text: string) => void }}
+ */
+function channel() {
+  /** @type {((chunk: string) => void)[]} */
+  const handlers = [];
+  return {
+    on(event, handler) {
+      if (event === "data") handlers.push(handler);
+    },
+    write(text) {
+      for (const handler of handlers) handler(text);
+    }
+  };
+}
+
 /** A logger that says nothing, for tests that are not about the log. */
 export const silentLogger = { info() {}, warn() {}, error() {} };
 
@@ -100,14 +195,17 @@ export function startRunOn(session, options = {}) {
     producing = true,
     lastSegmentIndex = null,
     usesExplicitCuts = false,
-    // WHAT FFMPEG HAS REPORTED IT IS RUNNING AT. It says so on its progress
-    // channel from the first seconds, before any piece closes — so a run can be
-    // starting and already have a speed, and every real one does. Left at zero,
-    // the plan has no speed to compute an arrival from, every arrangement of
-    // encoders is equally hopeless, they all tie, and the encoder is taken away
-    // for changing nothing.
-    speedX = 0
+    // THE SPEED IT HAS MEASURED: film made over its own working time between
+    // two closed pieces. Left at zero, the plan has no speed to compute an
+    // arrival from, every arrangement of encoders is equally hopeless, they all
+    // tie, and the encoder is taken away for changing nothing.
+    speedX = 0,
+    // What the run reads as now, for a test that drives time itself. Absent,
+    // the run reads the wall clock, which stands still only while a
+    // measurement is said.
+    clock: given = null
   } = options;
+  const clock = given ?? { at: null };
   const run = new EncodeRun({
     address: session.outputKey ?? session.id ?? "output",
     encoder: { name: "libx264", kind: "software" },
@@ -118,9 +216,15 @@ export function startRunOn(session, options = {}) {
     logger: silentLogger,
     lastSegmentIndex: () => lastSegmentIndex,
     usesExplicitCuts,
+    now: () => clock.at ?? Date.now(),
     because: "a test asked for it"
   });
-  run.noteSpeed(speedX);
+  if (given === null) {
+    wallClocks.set(run, clock);
+  }
+  if (speedX > 0) {
+    measureSpeed(run, speedX, given);
+  }
   if (producing) {
     // What moves a run out of starting is its first segment, in the product as
     // here — so a run that is producing has made one, and its head stands one

package/test/link-budget.test.js

@@ -9,7 +9,6 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import {
   admissionRank,
-  LINK_SAFETY,
   LINK_VERDICT,
   linkCouldCarry,
   loadOf,
@@ -67,11 +66,11 @@ test("a load is as trustworthy as its least trustworthy part", () => {
   assert.ok(Math.abs(loadOf(known(3), known(0.128)).totalMbps - 3.128) < 1e-9, "the sound is added to the picture");
 });
 
-test("the sound is counted before the link's usable share is applied", () => {
-  // The picture alone fits the usable share exactly; with the soundtrack the
-  // viewer hears, it does not.
+test("the sound is counted with the picture against the whole measured link", () => {
+  // The picture alone fits the link exactly; with the soundtrack the viewer
+  // hears, it does not. No share of the link is held back.
   const link = 10;
-  const picture = known(link * LINK_SAFETY);
+  const picture = known(link);
   assert.equal(linkCouldCarry(link, loadOf(picture, null)).verdict, LINK_VERDICT.FITS, "without sound it would pass");
   assert.equal(
     linkCouldCarry(link, loadOf(picture, known(AUDIO_TRANSCODE_KBPS / 1000))).verdict,

package/test/manager-surface.test.js

@@ -142,7 +142,7 @@ function fakeSession({ id = SESSION_ID } = {}) {
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
     segmentCount: 10,
-    progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0, speed: "1.0x" }
+    progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0 }
   };
 }
 
@@ -182,7 +182,6 @@ test("the progress report keeps every figure it carries today", async () => {
     "percent",
     "remainingSeconds",
     "segmentDurationSec",
-    "speed",
     "currentHeight",
     "offeredHeights",
     "requestedHeight",

package/test/orchestrator-wired.test.js

@@ -18,7 +18,7 @@ import { wireOutputs } from "../services/server/wire-outputs.js";
 import { SegmentStore } from "../services/storage/segment-store/SegmentStore.js";
 import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
 import { qualityStateOf } from "../services/encode/quality/OutputQualityState.js";
-import { startRunOn } from "./helpers/encode-run.js";
+import { measureSpeed, startRunOn } from "./helpers/encode-run.js";
 import { outputSpec } from "./helpers/output-spec.js";
 
 const KEY = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
@@ -65,9 +65,10 @@ function sessionOn({ manager, id, dirPath, encodeStartIndex = 0, runEndIndex = -
     const run = startRunOn(session, { from: encodeStartIndex, to: runEndIndex });
     manager.encodeOrchestrator.adopt(KEY, run);
     session.testRun = run;
-    // A speed is a reading taken FROM a run, so it names the run it came from.
-    qualityStateOf(session).recentSpeed = speed > 0 ? { speed, at: Date.now(), run } : null;
-    run.noteSpeed(speed);
+    // A speed is the run's own reading, measured from its closed pieces.
+    if (speed > 0) {
+      measureSpeed(run, speed);
+    }
   }
   return session;
 }

package/test/output-speed.test.js

@@ -25,7 +25,6 @@ function costOf(sessions, host = {}) {
   return new EncodeCost({
     runsFor: () => [],
     stateFor: () => "IDLE",
-    progressFor: () => null,
     outputs,
     host: () => ({
       benchmark: host.benchmark ?? null,