@torrent-tv/proxy 2.107.41 → 2.107.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.107.41",
+  "version": "2.107.43",
   "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"),
@@ -687,16 +688,8 @@ export function predictPlaybackReadiness(input = {}) {
   }
   const tailStock = [];
   if (trackState.some(({ tailEndSeconds }) => Number.isFinite(tailEndSeconds))) {
-    // Where each source's bytes stop being the near window's: the last byte
-    // its pieces read, in the file's own offsets.
-    const windowEnds = new Map();
-    for (const { sourceByteIntervals } of jobs) {
-      for (const [sourceId, ranges] of sourceByteIntervals) {
-        for (const range of ranges) windowEnds.set(sourceId, Math.max(windowEnds.get(sourceId) ?? 0, range.end));
-      }
-    }
     const stop = scheduleTail({ trackState, sourceState, runStarts, trackFinish,
-      link, position, buffered, reserve, transferFinish, constrain, duration, stock: tailStock, windowEnds });
+      link, position, buffered, reserve, transferFinish, constrain, duration, stock: tailStock });
     if (stop) {
       return { ...result(false, null, buffered, reserve, null, stop.reason, preparedSegments),
         ...(stop.unavailableSource ? { unavailableSource: stop.unavailableSource } : {}) };
@@ -799,7 +792,7 @@ function isPiece(segment) {
  * @returns {{ reason: string, unavailableSource?: object } | null} Why there is no answer, or null.
  */
 function scheduleTail({ trackState, sourceState, runStarts, trackFinish, link,
-  position, buffered, reserve, transferFinish, constrain, duration, stock = null, windowEnds = null }) {
+  position, buffered, reserve, transferFinish, constrain, duration, stock = null }) {
   const tailStart = Math.max(position, ...trackState.map(state => state.tailStartSeconds));
   if (!Number.isFinite(tailStart)) return null;
   const sourceDurations = new Map();
@@ -823,11 +816,17 @@ function scheduleTail({ trackState, sourceState, runStarts, trackFinish, link,
       stock?.push({ sourceId, skipped: "complete" });
       continue;
     }
-    // Held means on this proxy now, past the last byte the near window's
-    // pieces read: those are counted above, and the window's planned arrivals
-    // counted again as held took 117 s of film off a 90-minute tail. The
-    // torrent thread's plan is not that end: it can reach the end of the file.
-    const windowEnd = windowEnds?.get(sourceId) ?? 0;
+    // Held means on this proxy now, in the bytes of the film after the near
+    // window: the window's own bytes are counted above, and its planned
+    // arrivals counted again as held took 117 s of film off a 90-minute tail.
+    // Where those bytes begin is placed by the density the tail is priced at.
+    // Neither the torrent thread's plan nor the bytes the window reads are
+    // that place: both can reach the end of the file — a copied Matroska file
+    // reads its index there — and the whole of Despicable Me 3 then counted
+    // as held (Home Assistant 2026-10-26, torrent-tv/meta#239).
+    const fileLength = Number(source.source.fileLength);
+    const windowEnd = fileLength > 0 && duration > 0
+      ? Math.min(fileLength, Math.max(0, fileLength * tailStart / duration)) : 0;
     const bytes = estimateUnmappedSourceBytes(source.source, seconds, duration,
       heldBeyond(source.source.residence, windowEnd), windowEnd);
     if (bytes === null) return { reason: "source-measurement-unavailable",
@@ -1419,6 +1418,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);
@@ -1429,12 +1432,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 } : {})
   };
 }
 
@@ -1442,7 +1446,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);