@torrent-tv/proxy 2.89.2 → 2.89.4

package/test/encode-cost.test.js

@@ -10,7 +10,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { EncodeCost } from "../services/encode/quality/EncodeCost.js";
-import { startRunOn } from "./helpers/encode-run.js";
+import { measureSpeed, startRunOn } from "./helpers/encode-run.js";
 import { outputSpec } from "./helpers/output-spec.js";
 import { runStateOf } from "../services/encode/encode-run-state.js";
 import { qualityStateOf } from "../services/encode/quality/OutputQualityState.js";
@@ -39,10 +39,8 @@ function costOn(readings = {}) {
     runningEncoders: () => readings.runningEncoders?.() ?? 0,
     encodersRunningNow: () => 0,
     torrentCostSecFor: () => 0,
-    boundBy: async () => readings.boundBy ?? "cpu",
     runsFor: (session) => [...(session.runs ?? [])],
-    stateFor: (session) => runStateOf(session.runs),
-    progressFor: (session) => session.progress ?? null
+    stateFor: (session) => runStateOf(session.runs)
   });
   return { cost, asked: () => asked, host };
 }
@@ -64,30 +62,28 @@ function sessionProducing(what = {}) {
     }),
     file: { key: what.key ?? "torrent:abc:0", name: "film.mkv" },
     output: { encodeWidth: 0, encodeHeight: 0, outputFps: 25, softwarePreset: null },
-    progress: { processedSeconds: 0 },
+    clock: { at: 1000 },
     runs: new Set()
   };
-  startRunOn(session, { from: 0, speedX: 1 });
+  startRunOn(session, { from: 0, clock: session.clock });
   return session;
 }
 
 /**
- * Two readings of one run, far enough apart to be a speed.
+ * The session's run measures its speed, and is learned from as the product
+ * learns: once the run has a reading.
  *
  * @param {EncodeCost} cost
  * @param {object} session
- * @param {number} speedX - Seconds of film produced per second of clock.
+ * @param {number} speedX - Seconds of film produced per second of the run's own work.
+ * @param {number} [waitedMs] - How long the run's input waits for the swarm
+ *   between two closed pieces.
  * @returns {Promise<void>}
  */
-async function watchItRun(cost, session, speedX) {
-  session.progress.processedSeconds = 0;
-  await cost.learnFrom(session);
-  // The pair is a DELTA, and the first reading has nothing to be a delta from.
-  // Backdated rather than waited for: the window a speed may be read over is
-  // seconds, and a test that sleeps through it measures the clock.
-  qualityStateOf(session).learnSample.takenAt -= 10_000;
-  session.progress.processedSeconds = 10 * speedX;
-  await cost.learnFrom(session);
+async function watchItRun(cost, session, speedX, waitedMs = 0) {
+  const run = [...session.runs][0];
+  measureSpeed(run, speedX, session.clock, waitedMs);
+  await cost.learnFrom(session, run);
 }
 
 test("the host is asked at the moment of the question, not when this was built", () => {
@@ -163,17 +159,16 @@ test("a copy is priced from what it was seen doing", async () => {
   );
 });
 
-test("a reading taken while the swarm is short is not filed as the price of this host", async () => {
-  // A run starved of torrent data reports a speed that measures the swarm. Filed
-  // as a price it reads as more work per second than the machine has, and every
-  // quality step is then refused on the download's account.
-  const { cost } = costOn({ boundBy: "download" });
+test("the time a run's input waited for the swarm is not in the price of this host", async () => {
+  // Field 2026-10-01: a copy waited 32.93 s and 43.91 s for two pieces and read
+  // 0.21x over the clock. Over its own working time it is the machine's speed.
+  const { cost } = costOn();
   const session = sessionProducing({ transcodeVideo: false });
 
-  await watchItRun(cost, session, 0.3);
+  await watchItRun(cost, session, 8, 9_000);
 
-  assert.equal(cost.copyVersionFor("torrent:abc:0"), 0, "nothing was learned about the machine");
-  assert.equal(qualityStateOf(session).lastAloneSpeed, undefined, "and nothing claims this rung was seen failing");
+  assert.equal(qualityStateOf(session).lastAloneSpeed, 8, "the speed is the run's own, not the swarm's");
+  assert.equal(cost.copyVersionFor("torrent:abc:0"), 1, "and it is filed as what copying costs here");
 });
 
 test("a picture's reading taken beside another encoder is not filed", async () => {
@@ -189,30 +184,27 @@ test("a picture's reading taken beside another encoder is not filed", async () =
   assert.equal(cost.copyVersionFor("torrent:abc:0"), 0);
 });
 
-test("one reading is not a speed", async () => {
+test("a run that has measured nothing teaches nothing", async () => {
   const { cost } = costOn();
   const session = sessionProducing({ transcodeVideo: false });
-  session.progress.processedSeconds = 40;
+  const run = [...session.runs][0];
 
-  await cost.learnFrom(session);
+  await cost.learnFrom(session, run);
 
-  assert.equal(cost.copyVersionFor("torrent:abc:0"), 0, "a delta needs two readings of one run");
-  assert.ok(qualityStateOf(session).learnSample, "and the first is kept to be the other half of the next");
+  assert.equal(run.speedReading, null, "a speed needs two closed pieces of one run");
+  assert.equal(cost.copyVersionFor("torrent:abc:0"), 0);
 });
 
-test("a pair that straddles a restart measures the seek, not the host", async () => {
+test("a restarted run starts its own reckoning, so a seek is never read as speed", async () => {
+  // Twenty minutes of film against five seconds of work is a seek, and filed as
+  // a price it admits every step there is. The reading belongs to the run that
+  // made it, so a new run at another place has none until its own pieces close.
   const { cost } = costOn();
   const session = sessionProducing({ transcodeVideo: false });
-  await cost.learnFrom(session);
-  qualityStateOf(session).learnSample.takenAt -= 10_000;
-  // A new run, at another place in the film: twenty minutes of film against five
-  // seconds of clock is a seek, and filed as a price it admits every step there
-  // is.
   session.runs = new Set();
-  startRunOn(session, { from: 300, speedX: 1 });
-  session.progress.processedSeconds = 1200;
+  const moved = startRunOn(session, { from: 300, clock: session.clock });
 
-  await cost.learnFrom(session);
+  await cost.learnFrom(session, moved);
 
   assert.equal(cost.copyVersionFor("torrent:abc:0"), 0);
 });

package/test/encode-orchestrator.test.js

@@ -12,6 +12,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 { ENCODE_EXIT } from "../services/encode/encode-exit.js";
 import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
 import { EncodeOrchestrator } from "../services/encode/EncodeOrchestrator.js";
@@ -33,10 +34,16 @@ const RUN_COSTS = { killCostSec: 0, firstByteWaitSec: 0.12 };
 
 const PICTURE = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
 
+/** 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()];
     this.signals = [];
   }
 
@@ -123,7 +130,7 @@ function orchestrator({ maxRuns = 2 } = {}) {
         buildArgs: () => ["-i", "in", "out"],
         spawn: () => process_,
         logger: { info: (line) => lines.push(line), warn: (line) => lines.push(line) },
-        now: () => 1000,
+        now: () => clock.at,
         onEnded: (ended) => made.noteEnded(ended)
       });
       // Filed under the run itself: a run has no name, so a test that has to
@@ -146,7 +153,7 @@ function orchestrator({ maxRuns = 2 } = {}) {
       buildArgs: () => ["-i", "in", "out"],
       spawn: () => process_,
       logger: { info: (line) => lines.push(line), warn: (line) => lines.push(line) },
-      now: () => 1000,
+      now: () => clock.at,
       onEnded: (ended) => made.noteEnded(ended)
     });
     processes.set(run, process_);
@@ -210,7 +217,7 @@ test("an encoder already working covers what it will reach in time", () => {
   // wanted at all.
   const { made, buildRun } = orchestrator();
   const first = buildRun({ from: 0, to: -1 });
-  first.noteSpeed(8);
+  measureSpeed(first, 8, clock);
   made.adopt(PICTURE, first);
   made.noteProduced(PICTURE, 0);
   made.noteProduced(PICTURE, 1);
@@ -240,7 +247,7 @@ test("somebody stopped where no encoder can arrive in time is served, and the sc
   // seconds anybody spends looking at a spinner — outranks it.
   const { made, buildRun } = orchestrator();
   const first = buildRun({ from: 0, to: -1 });
-  first.noteSpeed(1);
+  measureSpeed(first, 1, clock);
   made.adopt(PICTURE, first);
   made.noteProduced(PICTURE, 0);
   made.noteProduced(PICTURE, 1);
@@ -260,7 +267,7 @@ test("two encoders on one output never share a segment number", () => {
   // what that neighbour makes sooner.
   const { made, buildRun } = orchestrator();
   const first = buildRun({ from: 0, to: -1 });
-  first.noteSpeed(1);
+  measureSpeed(first, 1, clock);
   made.adopt(PICTURE, first);
   made.noteProduced(PICTURE, 0);
   wants(made, [{ from: 200, to: 230, withinSeconds: 0 }]);
@@ -294,7 +301,7 @@ test("a second viewer far behind is served, at whatever the score says is soones
   wants(made, [{ from: 500, to: 530, withinSeconds: 0 }]);
   made.reconcile();
   for (const run of made.runsOn(PICTURE)) {
-    run.noteSpeed(2);
+    measureSpeed(run, 2, clock);
   }
   wants(made, [
     { from: 500, to: 530, withinSeconds: 0 },
@@ -359,7 +366,7 @@ test("a run that meets material made elsewhere is moved past it", () => {
   for (let index = 102; index <= 150; index += 1) {
     made.coverageOf(PICTURE).markReady(index);
   }
-  first.noteSpeed(1);
+  measureSpeed(first, 1, clock);
   made.reconcile();
   const runs = made.runsOn(PICTURE);
   assert.equal(runs.length, 1, "one encoder, moved rather than joined by another");
@@ -407,7 +414,7 @@ test("the swarm limits the encoders, whatever the processor allows", () => {
   const { made, lines } = orchestrator({ maxRuns: 2 });
   wants(made, [{ from: 100, to: 130 }]);
   made.reconcile();
-  made.runsOn(PICTURE)[0].noteSpeed(8);
+  measureSpeed(made.runsOn(PICTURE)[0], 8, clock);
   wants(made, [{ from: 500, to: 530 }]);
   made.reconcile();
 

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);
 });