@torrent-tv/proxy 2.89.3 → 2.89.5

package/services/encode/Renditions.js

@@ -1661,7 +1661,7 @@ export class Renditions {
     ) ?? null;
   }
 
-  inputOf(session) {
+  inputOf(session, runToken) {
     return encoderInputs({
       picture: session.file,
       soundtrack: session.spec.audio
@@ -1670,6 +1670,7 @@ export class Renditions {
       carries: session.spec.carries,
       audioSeparate: this.servesAudioSeparately(session),
       sessionId: session.id,
+      runToken,
       readWindowBytes: this.#host.encodeRuns.readWindowFor(session),
       baseUrl: this.#host.localBaseUrl
     });

package/services/encode/RunClock.js

@@ -0,0 +1,87 @@
+/**
+ * @file Where one encoder run's time went: working, waiting for its input, or
+ * stopped.
+ *
+ * A speed read as "film made per second of clock" measures the swarm as well
+ * as the machine whenever the input runs dry: field 2026-10-01, a copy waited
+ * 32.93 s and 43.91 s for two pieces and its speed read 0.21x, which the
+ * forecast then carried over the whole remaining film while it charged the
+ * same download separately. So the clock is split, from two facts that are
+ * observed and not inferred:
+ *
+ * 1. the input read waited — the stream route says when it starts and stops
+ *    waiting for bytes of this run's input;
+ * 2. the process was stopped — the run says when it sends `SIGSTOP` and
+ *    `SIGCONT`.
+ *
+ * Time during which either holds is idle; the rest is the run's own work. Two
+ * inputs that wait at once, or a wait while the process is stopped, are idle
+ * once. What is not separated is what the encoder does with bytes it already
+ * holds while its read waits; that is bounded by its input buffer, which is
+ * the one error this split has.
+ */
+export class RunClock {
+  /** @type {() => number} */
+  #now;
+  #startedAt;
+  /** Idle causes in force now: input reads waiting, plus one while stopped. */
+  #idleCauses = 0;
+  #idleSince = 0;
+  #idleMs = 0;
+
+  /**
+   * @param {{ now?: () => number }} [options]
+   */
+  constructor({ now = Date.now } = {}) {
+    this.#now = now;
+    this.#startedAt = now();
+  }
+
+  #idleBegins() {
+    if (this.#idleCauses === 0) {
+      this.#idleSince = this.#now();
+    }
+    this.#idleCauses += 1;
+  }
+
+  #idleEnds() {
+    if (this.#idleCauses === 0) {
+      return;
+    }
+    this.#idleCauses -= 1;
+    if (this.#idleCauses === 0) {
+      this.#idleMs += this.#now() - this.#idleSince;
+    }
+  }
+
+  /** An input read of this run starts waiting for bytes. */
+  inputWaitBegins() {
+    this.#idleBegins();
+  }
+
+  /** An input read of this run has its bytes. */
+  inputWaitEnds() {
+    this.#idleEnds();
+  }
+
+  /** The process is stopped. */
+  stopped() {
+    this.#idleBegins();
+  }
+
+  /** The process runs again. */
+  continued() {
+    this.#idleEnds();
+  }
+
+  /**
+   * Milliseconds of the run's own work so far.
+   *
+   * @param {number} [at]
+   * @returns {number}
+   */
+  workingMs(at = this.#now()) {
+    const idleNow = this.#idleCauses > 0 ? at - this.#idleSince : 0;
+    return Math.max(0, at - this.#startedAt - this.#idleMs - idleNow);
+  }
+}

package/services/encode/RunProgress.js

@@ -28,23 +28,19 @@ export class RunProgress {
     this.totalSeconds = Number.isFinite(totalSeconds) && totalSeconds > 0 ? totalSeconds : null;
     this.percent = null;
     this.remainingSeconds = this.totalSeconds;
-    this.speed = "";
     this.updatedAt = now();
     this.lastLoggedAt = 0;
     this.now = now;
     this.#derive();
   }
 
-  note({ processedSeconds = null, outTime, speed = null }) {
+  note({ processedSeconds = null, outTime }) {
     const relative = Number.isFinite(processedSeconds)
       ? processedSeconds
       : parseTimestamp(outTime);
     if (relative !== null) {
       this.processedSeconds = this.startPositionSeconds + Math.max(0, relative);
     }
-    if (typeof speed === "string") {
-      this.speed = speed;
-    }
     this.updatedAt = this.now();
     this.#derive();
     return this.snapshot();
@@ -65,7 +61,6 @@ export class RunProgress {
       totalSeconds: this.totalSeconds,
       percent: this.percent,
       remainingSeconds: this.remainingSeconds,
-      speed: this.speed,
       updatedAt: this.updatedAt
     };
   }

package/services/encode/encoder-readings.js

@@ -1,45 +1,43 @@
 /**
- * @file Turning two readings of a running encoder into a speed.
+ * @file Turning two work samples of a running encoder into a speed.
  *
- * ffmpeg reports `speed=` cumulatively, over the whole run. That figure counts
- * every second the encoder spent SIGSTOPped by the look-ahead cap, and a COPY
- * spends most of its life there — it reaches the cap in about fifteen seconds
- * and then waits a minute. Read that way, a copy running at eight times
- * realtime reports 1.6x and falling; filed as the price of copying, it would
- * refuse quality rungs on arithmetic that had measured a pause.
+ * ffmpeg reports `speed=` cumulatively, over the whole run: every second the
+ * encoder was stopped and every second its input waited for the swarm is in
+ * the denominator. A copy at eight times realtime that waits a minute reads
+ * 1.6x; a copy that waited 32.93 s and 43.91 s for two pieces read 0.21x in the
+ * field on 2026-10-01, and the forecast carried that over the whole film while
+ * charging the same download separately.
  *
- * The difference between two readings of an uninterrupted stretch does not have
- * that fault, and it is the same technique the startup benchmarks use.
+ * A run's work sample states the film made and the milliseconds of the run's
+ * OWN work, with input waits and stops taken out (`RunClock`). Two samples of
+ * one run give its processing speed over the stretch between them; the run
+ * takes them when it closes pieces (`EncodeRun.speedReading`), so there is no
+ * window to choose.
  */
 
 /**
- * @typedef {object} EncoderReading
- * @property {number} takenAt - Wall clock, in milliseconds.
- * @property {number} processedSeconds - Output position ffmpeg has reached.
+ * @typedef {object} WorkSample
+ * @property {number} at - Wall clock, in milliseconds.
+ * @property {number} producedSeconds - Film this run has made.
+ * @property {number} workingMs - The run's own working time so far.
  */
 
 /**
- * Speed between two readings, or null when the pair cannot answer.
+ * Processing speed between two samples of one run, or null when the pair
+ * cannot answer: nothing made, or no working time between them.
  *
- * @param {EncoderReading | null} previous
- * @param {EncoderReading | null} current
- * @param {number} minimumWindowSec - The narrowest stretch worth dividing by.
- * @returns {number | null} Video seconds produced per second of clock.
+ * @param {WorkSample | null} previous
+ * @param {WorkSample | null} current
+ * @returns {number | null} Film seconds made per second of the run's own work.
  */
-export function speedFromReadings(previous, current, minimumWindowSec) {
+export function speedFromWork(previous, current) {
   if (!previous || !current) {
     return null;
   }
-  const wallSeconds = (current.takenAt - previous.takenAt) / 1000;
-  const producedSeconds = current.processedSeconds - previous.processedSeconds;
-  if (!Number.isFinite(wallSeconds) || !Number.isFinite(producedSeconds)) {
+  const producedSeconds = current.producedSeconds - previous.producedSeconds;
+  const workingSeconds = (current.workingMs - previous.workingMs) / 1000;
+  if (!(producedSeconds > 0) || !(workingSeconds > 0)) {
     return null;
   }
-  // A window too narrow to divide by, or one in which nothing was produced —
-  // the second happens when a run has just been repositioned and has not yet
-  // reached the position it is restarting from.
-  if (!(wallSeconds >= minimumWindowSec) || !(producedSeconds > 0)) {
-    return null;
-  }
-  return producedSeconds / wallSeconds;
+  return producedSeconds / workingSeconds;
 }

package/services/encode/piece-completeness.js

@@ -0,0 +1,46 @@
+/**
+ * @file Whether a closed piece holds the whole of its stretch of film.
+ *
+ * A fact of production, decided where production is known: the cut a piece
+ * must reach comes from the output's cut table, and what it holds from the
+ * piece's own media intervals as its format reads them. The segment store keeps
+ * the bytes and whatever is derived from them; it does not judge them.
+ *
+ * A non-final piece is whole when the end of its last frame, on every track,
+ * reaches its next cut less `SEGMENT_CUT_TIME_DELTA_SECONDS`, the delta the
+ * muxer is configured with. The final piece has no next cut and is whole when
+ * it holds playable media at all. A piece that holds no playable media is never
+ * whole: an interrupted run can close a file with nothing in it.
+ */
+
+import { SEGMENT_CUT_TIME_DELTA_SECONDS } from "./output/index.js";
+
+/**
+ * The time a piece must reach, or undefined for the final piece.
+ *
+ * @param {{ segmentCount: number, publishedStartOf: (index: number) => number }} timeline
+ * @param {number} index
+ * @returns {number | undefined}
+ */
+export function cutOf(timeline, index) {
+  return index < timeline.segmentCount - 1
+    ? timeline.publishedStartOf(index + 1) - SEGMENT_CUT_TIME_DELTA_SECONDS
+    : undefined;
+}
+
+/**
+ * @param {{ producedThroughSeconds?: (ranges: object) => number | null }} format
+ * @param {object} ranges - The piece's media intervals, as the format read them.
+ * @param {number | undefined} cutSeconds - From {@link cutOf}.
+ * @returns {{ whole: boolean, throughSeconds: number | null }}
+ */
+export function judgePiece(format, ranges, cutSeconds) {
+  const throughSeconds = format.producedThroughSeconds?.(ranges) ?? null;
+  if (throughSeconds === null) {
+    return { whole: false, throughSeconds };
+  }
+  if (Number.isFinite(cutSeconds) && throughSeconds < cutSeconds) {
+    return { whole: false, throughSeconds };
+  }
+  return { whole: true, throughSeconds };
+}