@torrent-tv/proxy 2.107.42 → 2.107.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.107.42",
+  "version": "2.107.44",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "repository": {

package/services/encode/EncodeRun.js

@@ -39,7 +39,7 @@
 
 import { ENCODE_RUN_EVENT, ENCODE_RUN_STATE, INITIAL_RUN_STATE, nextState } from "./encode-run-state.js";
 import { classifyEncodeExit, ENCODE_EXIT } from "./encode-exit.js";
-import { speedFromWork } from "./encoder-readings.js";
+import { workDeltaBetween } from "./encoder-readings.js";
 import { RunClock } from "./RunClock.js";
 import { RunProgress } from "./RunProgress.js";
 
@@ -229,7 +229,7 @@ export class EncodeRun {
    * @param {{ info: (line: string) => void, warn: (line: string) => void, error?: (line: string) => void }} params.logger
    * @param {() => number} [params.now]
    * @param {(ended: RunEnded) => void} [params.onEnded]
-   * @param {(reading: { speed: number, at: number }) => void} [params.onSpeedMeasured] -
+   * @param {(reading: { speed: number, at: number, workSeconds: number, workingSeconds: number }) => void} [params.onSpeedMeasured] -
    *   Told each time this run has measured its processing speed, once per
    *   reading.
    * @param {(name: string, following: string | null) => string | null} [params.onClosed] - Called with the
@@ -353,10 +353,10 @@ export class EncodeRun {
   }
 
   /**
-   * The same speed with the moment it was measured, or null before a closed
-   * piece has enough progress data.
+   * The processing speed, its produced media and active working time, with
+   * the measurement time; null before a piece supplies a measured interval.
    *
-   * @returns {{ speed: number, at: number } | null}
+   * @returns {{ speed: number, at: number, workSeconds: number, workingSeconds: number } | null}
    */
   get speedReading() {
     return this.#speedReading === null ? null : { ...this.#speedReading };
@@ -764,9 +764,9 @@ export class EncodeRun {
     if (sample === null) {
       return;
     }
-    const speed = speedFromWork(this.#pieceSample, sample);
-    if (speed !== null) {
-      this.#speedReading = { speed, at: sample.at };
+    const work = workDeltaBetween(this.#pieceSample, sample);
+    if (work !== null) {
+      this.#speedReading = { speed: work.workSeconds / work.workingSeconds, at: sample.at, ...work };
       this.#pieceSample = sample;
       this.#speedMeasurementPending = false;
       this.onSpeedMeasured(this.speedReading);

package/services/encode/SpeedReadings.js

@@ -14,7 +14,7 @@
  */
 
 export class SpeedReadings {
-  /** @type {WeakMap<object, Array<{ speed: number, at: number }>>} */
+  /** @type {WeakMap<object, Array<{ speed: number, at: number, workSeconds?: number, workingSeconds?: number }>>} */
   #byOutput = new WeakMap();
   #keepMs;
 
@@ -25,7 +25,7 @@ export class SpeedReadings {
 
   /**
    * @param {object} output
-   * @param {{ speed: number, at: number } | null} reading
+   * @param {{ speed: number, at: number, workSeconds?: number, workingSeconds?: number } | null} reading
    */
   note(output, reading) {
     if (!output || !(reading?.speed > 0) || !Number.isFinite(reading.at)) return;
@@ -33,7 +33,12 @@ export class SpeedReadings {
     if (!readings) this.#byOutput.set(output, readings = []);
     let place = readings.length;
     while (place > 0 && readings[place - 1].at > reading.at) place -= 1;
-    readings.splice(place, 0, { speed: reading.speed, at: reading.at });
+    const sample = { speed: reading.speed, at: reading.at };
+    if (Number.isFinite(reading.workSeconds) && reading.workSeconds > 0 &&
+        Number.isFinite(reading.workingSeconds) && reading.workingSeconds > 0) {
+      Object.assign(sample, { workSeconds: reading.workSeconds, workingSeconds: reading.workingSeconds });
+    }
+    readings.splice(place, 0, sample);
     const cutoff = readings.at(-1).at - this.#keepMs;
     // As the forecast's own trend keeps them: the newest one before the horizon stays.
     while (readings.length > 1 && readings[1].at <= cutoff) readings.shift();
@@ -41,7 +46,7 @@ export class SpeedReadings {
 
   /**
    * @param {object} output
-   * @returns {Array<{ speed: number, at: number }>} The window, in the order the readings were taken.
+   * @returns {Array<{ speed: number, at: number, workSeconds?: number, workingSeconds?: number }>} The readings in measurement order.
    */
   windowOf(output) {
     return [...(this.#byOutput.get(output) ?? [])];

package/services/encode/encoder-readings.js

@@ -31,13 +31,21 @@
  * @returns {number | null} Film seconds made per second of the run's own work.
  */
 export function speedFromWork(previous, current) {
-  if (!previous || !current) {
-    return null;
-  }
-  const producedSeconds = current.producedSeconds - previous.producedSeconds;
+  const work = workDeltaBetween(previous, current);
+  return work === null ? null : work.workSeconds / work.workingSeconds;
+}
+
+/**
+ * Produced media and active processing time between samples of one run.
+ * @param {WorkSample | null} previous
+ * @param {WorkSample | null} current
+ * @returns {{ workSeconds: number, workingSeconds: number } | null}
+ */
+export function workDeltaBetween(previous, current) {
+  if (!previous || !current) return null;
+  const workSeconds = current.producedSeconds - previous.producedSeconds;
   const workingSeconds = (current.workingMs - previous.workingMs) / 1000;
-  if (!(producedSeconds > 0) || !(workingSeconds > 0)) {
-    return null;
-  }
-  return producedSeconds / workingSeconds;
+  return Number.isFinite(workSeconds) && workSeconds > 0 &&
+    Number.isFinite(workingSeconds) && workingSeconds > 0
+    ? { workSeconds, workingSeconds } : null;
 }

package/services/viewer/playback-readiness.js

@@ -76,12 +76,13 @@ export function forecastRate(readings, now = Date.now(), horizonSeconds = 0, wei
  * ordered by when each was taken, readings taken in the same millisecond kept
  * apart. Null for no reading.
  *
- * @param {Array<{ at: number, speed?: number, value?: number }>} readings
+ * @param {Array<{ at: number, speed?: number, value?: number, workSeconds?: number, workingSeconds?: number }>} readings
  * @returns {object | null}
  */
 export function rateSummaryOf(readings) {
   const ordered = (Array.isArray(readings) ? readings : [])
-    .map(reading => ({ at: reading?.at, value: reading?.value ?? reading?.speed }))
+    .map(reading => ({ at: reading?.at, value: reading?.value ?? reading?.speed,
+      workSeconds: reading?.workSeconds, workingSeconds: reading?.workingSeconds }))
     .filter(reading => Number.isFinite(reading.at) && Number.isFinite(reading.value) && reading.value >= 0)
     .sort((left, right) => left.at - right.at);
   return ordered.length > 0 ? summarizeRate(ordered) : null;
@@ -278,9 +279,9 @@ export function predictPlaybackReadiness(input = {}) {
       [{ start: at, end: add(at, measured ? nearest(fromSeconds(buffered), unit) :
         rescale(fromSeconds(buffered), unit)), frame: zero }],
     ready: new Set(Array.isArray(track.readySegmentIndices) ? track.readySegmentIndices : []),
-    // Film made over the encoder's working time, over the readings the trend
-    // keeps: one reading is one closed piece, so the harmonic mean is that
-    // ratio. The last reading alone is one piece's content and machine — a
+    // Film made over active processing time, summed over the readings retained.
+    // Point-only legacy readings retain their equal-work harmonic summary.
+    // The last reading alone is one piece's content and machine — a
     // first piece of credits read 6.49x and started a cold AVI on 2.4 s of
     // buffer that the next piece, at 0.57x, did not hold (torrent-tv/meta#178).
     curve: rateCurve(track.readings, now, "piece"),
@@ -855,6 +856,7 @@ function scheduleTail({ trackState, sourceState, runStarts, trackFinish, link,
 
   let outputBits = 0;
   let latestTrackFinish = 0;
+  let earliestTrackStart = Number.POSITIVE_INFINITY;
   for (let trackIndex = 0; trackIndex < trackState.length; trackIndex += 1) {
     const state = trackState[trackIndex];
     const end = state.tailEndSeconds;
@@ -873,7 +875,9 @@ function scheduleTail({ trackState, sourceState, runStarts, trackFinish, link,
     const localStart = tailStart - state.clockSeconds;
     const inRun = run.spans.some(span => localStart >= span.start && localStart < span.end);
     const open = work > 0 && !inRun ? run.openSeconds : 0;
-    const finishedAt = work > 0 ? processing.finish(work, trackFinish[trackIndex] + open) : trackFinish[trackIndex];
+    const productionStart = trackFinish[trackIndex] + open;
+    const finishedAt = work > 0 ? processing.finish(work, productionStart) : trackFinish[trackIndex];
+    if (work > 0) earliestTrackStart = Math.min(earliestTrackStart, productionStart);
     latestTrackFinish = Math.max(latestTrackFinish, finishedAt);
     const deliveryStart = Math.max(tailStart, position + buffered);
     outputBits += Math.max(0, state.bitsPerMediaSecond) * Math.max(0, end - deliveryStart);
@@ -884,7 +888,13 @@ function scheduleTail({ trackState, sourceState, runStarts, trackFinish, link,
 
   if (outputBits > 0) {
     const end = Math.max(...trackState.map(state => state.tailEndSeconds));
-    const completedAt = link.finish(outputBits, Math.max(transferFinish, latestTrackFinish));
+    // Production and transfer are tandem services. Starting the link only
+    // after the last track finishes charges both complete workloads in series.
+    // The fluid suffix is bounded by the later service completion, with the
+    // link queue beginning no earlier than the first produced output.
+    const deliveryStart = Math.max(transferFinish, Number.isFinite(earliestTrackStart) ? earliestTrackStart : 0);
+    const deliveryAt = link.finish(outputBits, deliveryStart);
+    const completedAt = Math.max(latestTrackFinish, deliveryAt);
     const ahead = Math.max(0, end - position);
     constrain(completedAt - Math.max(0, ahead - reserve), "delivery", 0,
       trackState[0]?.segments.at(-1)?.index ?? 0, completedAt, ahead, false, sourceArrivalAt, false);
@@ -1417,6 +1427,10 @@ function rateCurve(readings, now, weighting = "last") {
 
 function summarizeRate(readings) {
   const latest = readings.at(-1);
+  const workKnown = readings.every(reading => Number.isFinite(reading.workSeconds) && reading.workSeconds > 0 &&
+    Number.isFinite(reading.workingSeconds) && reading.workingSeconds > 0);
+  const workSeconds = workKnown ? readings.reduce((sum, reading) => sum + reading.workSeconds, 0) : null;
+  const workingSeconds = workKnown ? readings.reduce((sum, reading) => sum + reading.workingSeconds, 0) : null;
   let weighted = 0;
   for (let index = 0; index + 1 < readings.length; index += 1) {
     weighted += readings[index].value * (readings[index + 1].at - readings[index].at);
@@ -1427,12 +1441,13 @@ function summarizeRate(readings) {
     lastAt: latest.at,
     lastValue: latest.value,
     meanValue: readings.reduce((sum, reading) => sum + reading.value, 0) / readings.length,
-    // Each reading one piece of work: work over the time it took.
+    // Equal-work summary for legacy readings without measured work quantities.
     harmonicValue: readings.some(reading => !(reading.value > 0)) ? 0
       : readings.length / readings.reduce((sum, reading) => sum + 1 / reading.value, 0),
     // Each reading holding until the next: quantity over the span.
     timeWeightedValue: spanMs > 0 ? weighted / spanMs : latest.value,
-    spanSeconds: spanMs / 1000
+    spanSeconds: spanMs / 1000,
+    ...(workKnown ? { workSeconds, workingSeconds, workRateValue: workSeconds / workingSeconds } : {})
   };
 }
 
@@ -1440,7 +1455,8 @@ function rateCurveFrom(summary, weighting = "last") {
   // Conditional projection of the measured service. No exponential
   // relaxation, smoothing time, slope extrapolation or guessed recovery.
   // A new measurement changes the integral; polling does not change its rate.
-  const value = weighting === "piece" && Number.isFinite(summary.harmonicValue) ? summary.harmonicValue
+  const value = weighting === "piece" && Number.isFinite(summary.workRateValue) ? summary.workRateValue
+    : weighting === "piece" && Number.isFinite(summary.harmonicValue) ? summary.harmonicValue
     : weighting === "time" && Number.isFinite(summary.timeWeightedValue) ? summary.timeWeightedValue
       : summary.lastValue;
   const rate = Math.max(0, value);