@torrent-tv/proxy 2.89.3 → 2.89.4

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,

package/test/piece-completeness.test.js

@@ -0,0 +1,42 @@
+/**
+ * @file Whether a closed piece holds the whole of its stretch of film.
+ *
+ * Decided by the encoding from the cut table and the piece's own media; the
+ * segment store only keeps what it is given.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { cutOf, judgePiece } from "../services/encode/piece-completeness.js";
+import { SEGMENT_CUT_TIME_DELTA_SECONDS } from "../services/encode/output/index.js";
+
+/** Media ending where stated, in the shape a format's reading has. */
+const endingAt = (seconds) => ({ end: seconds });
+const format = { producedThroughSeconds: (ranges) => ranges?.end ?? null };
+
+/** Cuts every ten seconds, ten pieces. */
+const timeline = { segmentCount: 10, publishedStartOf: (index) => index * 10 };
+
+test("a piece must reach its next cut less the delta the muxer is given", () => {
+  assert.equal(cutOf(timeline, 3), 40 - SEGMENT_CUT_TIME_DELTA_SECONDS);
+});
+
+test("the final piece has no next cut", () => {
+  assert.equal(cutOf(timeline, 9), undefined);
+  assert.deepEqual(judgePiece(format, endingAt(95), cutOf(timeline, 9)), { whole: true, throughSeconds: 95 });
+});
+
+test("an audio piece ending within the delta of its cut is whole", () => {
+  // Field 2026-10-01: AAC frames end 4.7389 s into a piece cut at 4.755 s.
+  const cut = 4.755 - SEGMENT_CUT_TIME_DELTA_SECONDS;
+  assert.equal(judgePiece(format, endingAt(4.738913832199547), cut).whole, true);
+});
+
+test("a piece closed short of its cut is not whole", () => {
+  // A run killed mid-piece: 84 ms of film where ten seconds were cut.
+  assert.deepEqual(judgePiece(format, endingAt(456.084), 466), { whole: false, throughSeconds: 456.084 });
+});
+
+test("a piece with no playable media is not whole, whatever its cut", () => {
+  assert.deepEqual(judgePiece(format, null, undefined), { whole: false, throughSeconds: null });
+});

package/test/quality-offer.test.js

@@ -58,10 +58,8 @@ function offerOver(
     runningEncoders: () => 0,
     encodersRunningNow: () => 0,
     torrentCostSecFor: () => 0,
-    boundBy: async () => "cpu",
     runsFor: (session) => [...(session.runs ?? [])],
-    stateFor: (session) => runStateOf(session.runs),
-    progressFor: (session) => session.progress ?? null
+    stateFor: (session) => runStateOf(session.runs)
   });
   let computed = 0;
   const real = cost.sustainableHeights.bind(cost);

package/test/quality-variants.test.js

@@ -131,7 +131,7 @@ function fakeSession({
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
     segmentCount: 100,
-    progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0, speed: "1.0x" }
+    progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0 }
   };
 }
 

package/test/run-progress.test.js

@@ -16,7 +16,7 @@ test("a run rebases ffmpeg's relative clock onto its own source position", () =>
   let now = 10;
   const progress = new RunProgress({ startSeconds: 600, totalSeconds: 1000, now: () => now });
   now = 20;
-  progress.note({ processedSeconds: 12.5, speed: "2.0x" });
+  progress.note({ processedSeconds: 12.5 });
 
   assert.deepEqual(progress.snapshot(), {
     processedSeconds: 612.5,
@@ -24,7 +24,6 @@ test("a run rebases ffmpeg's relative clock onto its own source position", () =>
     totalSeconds: 1000,
     percent: 3.125,
     remainingSeconds: 387.5,
-    speed: "2.0x",
     updatedAt: 20
   });
 });
@@ -33,7 +32,7 @@ test("two runs of one output retain separate clocks", () => {
   const made = orchestrator();
   const first = { from: 0, to: 49, isAlive: true, progress: new RunProgress({ startSeconds: 0 }) };
   const second = { from: 50, to: 99, isAlive: true, progress: new RunProgress({ startSeconds: 200 }) };
-  first.progress.note({ processedSeconds: 40, speed: "1.0x" });
+  first.progress.note({ processedSeconds: 40 });
   second.progress.note({ processedSeconds: 8, speed: "2.0x" });
   made.adopt("picture", first);
   made.adopt("picture", second);

package/test/same-height-switch.test.js

@@ -65,7 +65,6 @@ import { SourceFile } from "../services/media/SourceFile.js";
 import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
 import { outputSpec } from "./helpers/output-spec.js";
 import { maxrateKbpsFor, nominalKbpsFor, softwareRateControlFor } from "../services/encode/args.js";
-import { LINK_SAFETY } from "../services/encode/quality/link-budget.js";
 
 const BASE_ID = "1111111122223333";
 const SEGMENT_SECONDS = 4;
@@ -86,7 +85,7 @@ const AUDIO_MBPS = 0.128;
  * @returns {number}
  */
 function linkJustFor(limit) {
-  return (maxrateKbpsFor(limit) / 1000 + AUDIO_MBPS + 0.01) / LINK_SAFETY;
+  return maxrateKbpsFor(limit) / 1000 + AUDIO_MBPS + 0.01;
 }
 
 /**

package/test/segment-store.test.js

@@ -10,7 +10,6 @@ import os from "node:os";
 import path from "node:path";
 import { directoryNameFor, SegmentStore } from "../services/storage/segment-store/SegmentStore.js";
 import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-import { SEGMENT_CUT_TIME_DELTA_SECONDS } from "../services/encode/output/index.js";
 
 /**
  * @returns {{ store: SegmentStore, root: string, lines: string[] }}
@@ -36,32 +35,33 @@ function writeSegment(dir, index, bytes = 16) {
 
 const KEY = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
 
-test("a complete audio cut within the configured muxer delta remains usable", (t) => {
+test("a published piece keeps the media intervals the encoding read from it", (t) => {
+  // The store does not judge a piece; whether it is whole is the encoding's
+  // decision (`encode/piece-completeness.js`), taken before it is published.
   const { store, root } = storeInATempRoot();
   t.after(() => { store.dropAll("the check is over"); rmSync(root, { recursive: true, force: true }); });
-  const format = { ...fmp4Format, readMediaRanges: () => [{ start: 0, end: 4.738913832199547 }],
-    producedThroughSeconds: (ranges) => ranges.at(-1).end };
+  const format = { ...fmp4Format, readMediaRanges: () => assert.fail("the store does not read a piece it was handed") };
   const dir = store.directoryFor(KEY);
   store.useFormat(KEY, format);
-  const endSeconds = 4.755 - SEGMENT_CUT_TIME_DELTA_SECONDS;
-  writeFileSync(path.join(dir, "making-0-00000.mp4"), Buffer.alloc(16));
-  assert.equal(store.publish(KEY, "making-0-00000.mp4", format, { endSeconds }), "segment-00000.mp4");
-  assert.ok(store.mediaRangesOf(KEY, 0, { endSeconds }));
+  writeFileSync(path.join(dir, "making-0-00000.mp4"), Buffer.from("closed"));
+  assert.deepEqual(store.closedBytesOf(KEY, "making-0-00000.mp4"), Buffer.from("closed"));
+  const mediaRanges = { tracks: [] };
+  assert.equal(store.publish(KEY, "making-0-00000.mp4", format, { mediaRanges }), "segment-00000.mp4");
+  assert.equal(store.mediaRangesOf(KEY, 0), mediaRanges);
 });
 
-test("a closed but truncated non-final piece is not published or reused", (t) => {
-  const { store, root } = storeInATempRoot();
+test("a stored piece is taken off the disk at its owner's word", (t) => {
+  const { store, root, lines } = storeInATempRoot();
   t.after(() => { store.dropAll("the check is over"); rmSync(root, { recursive: true, force: true }); });
-  const format = { ...fmp4Format, readMediaRanges: () => [{ start: 456, end: 456.084 }],
-    producedThroughSeconds: (ranges) => ranges.at(-1).end };
+  const format = { ...fmp4Format, readMediaRanges: () => ({ tracks: [] }) };
   const dir = store.directoryFor(KEY);
   store.useFormat(KEY, format);
-  writeFileSync(path.join(dir, "making-0-00071.mp4"), Buffer.alloc(16));
-  assert.equal(store.publish(KEY, "making-0-00071.mp4", format, { endSeconds: 466 }), null);
   writeSegment(dir, 71);
   assert.ok(store.mediaRangesOf(KEY, 71));
-  assert.equal(store.mediaRangesOf(KEY, 71, { endSeconds: 466 }), undefined);
+  store.remove(KEY, 71, "short of its cut");
   assert.equal(store.pathOf(KEY, 71), null);
+  assert.equal(store.mediaRangesOf(KEY, 71), undefined);
+  assert.ok(lines.some((line) => line.includes("segment 71") && line.includes("short of its cut")));
 });
 
 test("two viewers of one output are given the same directory", (t) => {

package/test/stream-route.test.js

@@ -207,3 +207,31 @@ test("a file this proxy does not have whole still goes to the torrent", async ()
   await handleStreamGet(req, reply, deps);
   assert.equal(state.prioritized.length, 1, "the ordinary path was not taken");
 });
+
+test("every wait of an encoder's input read is marked for the run its URL names", async () => {
+  // The run's processing speed is read over its own working time; the time its
+  // input waits for the swarm is what this marks (RunClock).
+  const { req, reply, deps } = harness({ method: "GET", range: "bytes=0-5" });
+  const { files: [file] } = await deps.torrentPool.getTorrent();
+  const pieces = [Buffer.from("abc"), Buffer.from("def")];
+  file.createFragmentReader = () => ({
+    cancel() {},
+    async *[Symbol.asyncIterator]() {
+      for (const bytes of pieces) {
+        yield { bytes, release() {} };
+      }
+    }
+  });
+  reply.raw.write = (_bytes, done) => done();
+  reply.raw.writableEnded = false;
+  reply.raw.destroyed = false;
+  req.query.session = "output-1";
+  req.query.run = "7";
+  const marks = [];
+  deps.noteInputWaiting = (runToken, waiting) => marks.push([runToken, waiting]);
+
+  await handleStreamGet(req, reply, deps);
+
+  assert.deepEqual(marks, [[7, true], [7, false], [7, true], [7, false], [7, true], [7, false]],
+    "a wait before each fragment and one before the end, each closed");
+});

package/test/supply-margin.test.js

@@ -175,3 +175,16 @@ test("a term with nothing observed contributes nothing", () => {
   assert.equal(minimumBufferFrom({}), null, "without a segment duration nothing can be said");
   assert.equal(minimumBufferFrom({ segmentSeconds: 0 }), null);
 });
+
+test("a supply that delivered for a sliver of the time asks for what it measured, uncut", () => {
+  // Two stalls of 99.9 s with 0.1 s of delivery between them: the share lost is
+  // 0.999, and the speed asked for is a thousand times realtime. A cap at a
+  // chosen 0.99 used to report a hundred.
+  const answer = requiredSpeedFrom([
+    { waitedMs: 99_900, at: 99_900 },
+    { waitedMs: 99_900, at: 199_900 }
+  ]);
+  assert.ok(answer);
+  assert.ok(Math.abs(answer.lostShare - 0.999) < 1e-9, `got ${answer.lostShare}`);
+  assert.ok(Math.abs(answer.requiredSpeed - 1000) < 1e-6, `got ${answer.requiredSpeed}`);
+});

package/test/two-viewers-one-picture.test.js

@@ -132,7 +132,7 @@ function fakeSession({
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
     segmentCount: 100,
-    progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0, speed: "1.0x" }
+    progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0 }
   };
 }
 

package/test/viewer-outputs.test.js

@@ -98,7 +98,7 @@ function fakeSession({ id, dirPath, file, encodeHeight = 0, audioOnly = false, i
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
     segmentCount: 100,
-    progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0, speed: "1.0x" }
+    progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0 }
   };
 }