@torrent-tv/proxy 2.89.3 → 2.89.5

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

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