@torrent-tv/proxy 2.97.16 → 2.97.17

package/package.json

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

package/routes/api/transcode-sessions/net-report/post.js

@@ -19,14 +19,15 @@ import { recordViewerReport } from "../../../../services/viewer/report-intake.js
  *
  * @param {import("fastify").FastifyRequest} req
  * @param {import("fastify").FastifyReply} reply
- * @param {{ outputs: { get: (id: string) => object | undefined }, viewers: object, renditions: { viewerPlays: Function, noteViewerReported: Function }, quality: { noteViewerReported: Function } }} deps -
+ * @param {{ outputs: { get: (id: string) => object | undefined }, viewers: object, renditions: { viewerPlays: Function, noteViewerReported: Function }, quality: { noteViewerReported: Function }, planSoon?: () => void, segmentAt?: (output: object, seconds: number) => number | null }} deps -
  *   The live outputs, the registry of viewers, and the rungs of a picture. The
  *   VIEWER component takes the statement; which rung a stated height is, is the
  *   encoding component's. This route's whole job is turning a request into
  *   those calls and their answer into a status code.
  * @returns {Promise<void>}
  */
-export async function handleApiTranscodeSessionNetReportPost(req, reply, { outputs, viewers, renditions, quality }) {
+export async function handleApiTranscodeSessionNetReportPost(req, reply,
+  { outputs, viewers, renditions, quality, planSoon = () => {}, segmentAt = () => null }) {
   const sessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
   const body = req.body && typeof req.body === "object" && !Array.isArray(req.body) ? req.body : {};
   // WHAT THIS REPORT IS. A statement by one viewer about itself: where the
@@ -100,6 +101,10 @@ export async function handleApiTranscodeSessionNetReportPost(req, reply, { outpu
       Number.isFinite(positionSeconds) && positionSeconds >= 0 ? positionSeconds : undefined
     );
   }
+  // Where they stood and whether they were playing or waiting, before this
+  // report: what the encoders are planned from (`movedForThePlan`).
+  const before = viewers.get?.(consumerId);
+  const was = before ? { seconds: before.position?.seconds ?? null, playing: before.playing, waiting: before.waiting } : null;
   const recorded = recordViewerReport({
     outputs,
     viewers,
@@ -127,6 +132,14 @@ export async function handleApiTranscodeSessionNetReportPost(req, reply, { outpu
   if (!recorded) {
     return reply.code(404).send({ error: "Transcode session was not found." });
   }
+  // A VIEWER WHO MOVED INTO ANOTHER PIECE, or started or stopped playing or
+  // waiting, changed the maps the encoders are placed from; the plan is taken
+  // again now. Recorded and not re-planned, a soundtrack the viewer was
+  // stopped for waited 59 s behind a picture that had long left the urgent
+  // band, because only the end of that picture's run planned again (Home
+  // Assistant 2026-10-12, torrent-tv/meta#178).
+  const after = viewers.get?.(consumerId);
+  if (after && movedForThePlan(was, after, outputs.get(sessionId), segmentAt)) planSoon();
   // After the statement is recorded, so what is judged is what they just said:
   // a move of theirs to another limit may no longer be wanted.
   renditions.noteViewerReported(sessionId, consumerId);
@@ -136,3 +149,23 @@ export async function handleApiTranscodeSessionNetReportPost(req, reply, { outpu
   void quality.noteViewerReported(sessionId, consumerId);
   return reply.code(204).send();
 }
+
+/**
+ * Whether a report changed what the encoders are planned from: the piece the
+ * viewer stands in, or whether they play or wait.
+ *
+ * @param {{ seconds: number | null, playing: boolean, waiting: boolean } | null} was
+ * @param {{ position?: { seconds: number } | null, playing: boolean, waiting: boolean }} now
+ * @param {object | undefined} output
+ * @param {(output: object, seconds: number) => number | null} segmentAt
+ * @returns {boolean}
+ */
+export function movedForThePlan(was, now, output, segmentAt) {
+  if (!was) return true;
+  if (was.playing !== now.playing || was.waiting !== now.waiting) return true;
+  const seconds = now.position?.seconds;
+  if (!Number.isFinite(seconds)) return false;
+  if (!Number.isFinite(was.seconds)) return true;
+  if (!output) return false;
+  return segmentAt(output, was.seconds) !== segmentAt(output, seconds);
+}

package/server.js

@@ -568,9 +568,15 @@ export async function startProxyServer({
               value = new SegmentInputs({ index, tracks: wanted }).forInterval({ ...interval, mode: track => modes.get(track) });
             }
           } catch { value = null; }
+          // A zone worked out gives the thread back before the next: worked out
+          // in one stretch, the first pass over a film's 4000 zones held the main
+          // thread 5-7 s while FFmpeg's first open waited for its answers. What
+          // was worked out is kept, so a pass a newer map ends is not lost
+          // (torrent-tv/meta#178).
+          if (value?.kind === "result") segmentSourceRanges.set(rangesKey, value.ranges);
+          await new Promise(resolve => setImmediate(resolve));
           if (!map.isCurrent()) return [];
           if (value?.kind === "result") {
-            segmentSourceRanges.set(rangesKey, value.ranges);
             convert(value.ranges);
             continue;
           }
@@ -1301,7 +1307,12 @@ export async function startProxyServer({
       outputs: outputParts.outputs,
       viewers: outputParts.viewers,
       renditions: outputParts.renditions,
-      quality: outputParts.quality
+      quality: outputParts.quality,
+      planSoon: () => outputParts.encodeRuns.planEncodersSoon(),
+      segmentAt: (output, seconds) => {
+        // A cut table not built yet has no pieces to move between.
+        try { return outputParts.outputTimes.segmentIndexForTime(output, seconds); } catch { return null; }
+      }
     })
   );
   app.post("/api/transcode-sessions/:sessionId/fragment-far", async (req, reply) =>

package/services/encode/EncodeOrchestrator.js

@@ -130,6 +130,17 @@ export class EncodeOrchestrator {
    * @type {{ urgent: boolean, priority: number, address: string, index: number } | null}
    */
   #leading = null;
+  /**
+   * Outputs whose start the last plan held back behind a more urgent encoder,
+   * and the band of the number it would have started at. Looked at again
+   * whenever that encoder moves on (`shareTheMachine`), because a closed piece
+   * is what lowers its band: placed only by a full plan, a soundtrack the
+   * viewer was stopped for waited 59 s behind a picture that had long left
+   * the urgent band (Home Assistant 2026-10-12, torrent-tv/meta#178).
+   *
+   * @type {Map<string, { urgent: boolean, priority: number }>}
+   */
+  #heldBack = new Map();
 
   /** What a stop and a start have cost on this host. */
   #costs = new RunCosts();
@@ -689,7 +700,10 @@ export class EncodeOrchestrator {
   shareTheMachine() {
     const leading = this.#leadingBand();
     this.#leading = leading;
-    if (!leading) return;
+    if (!leading) {
+      this.#placeHeldBack(null);
+      return;
+    }
     for (const [address, runs] of this.#runs) {
       for (const run of runs) {
         if (!run.isAlive || run.isStopping || typeof run.pause !== "function") continue;
@@ -702,6 +716,22 @@ export class EncodeOrchestrator {
         }
       }
     }
+    this.#placeHeldBack(leading);
+  }
+
+  /**
+   * Plan again every output whose start was held back behind what is no
+   * longer more urgent than it: the start is placed now, by the same plan,
+   * rather than at whatever event next re-plans everything.
+   *
+   * @param {{ urgent: boolean, priority: number } | null} leading
+   */
+  #placeHeldBack(leading) {
+    for (const [address, band] of [...this.#heldBack]) {
+      if (leading && compareUrgency(band, leading) > 0) continue;
+      this.#heldBack.delete(address);
+      this.#reconcileOne(address);
+    }
   }
 
   /**
@@ -916,6 +946,8 @@ export class EncodeOrchestrator {
     // a 159 090-line file, 31 % of the log, all of one wedge.
     const wanting = firstUnmetWant(coverage, windows);
     const stillRunning = this.runsOn(address).filter((run) => run.isAlive);
+    if (heldBack) this.#heldBack.set(address, this.#bandAt(address, heldBack.from));
+    else this.#heldBack.delete(address);
     if (wanting === null || stillRunning.length > 0) {
       this.#lastUnmet.delete(address);
     } else if (heldBack) {

package/services/media/container/AviContainer.js

@@ -404,8 +404,19 @@ export class AviContainer extends Container {
           packets.append(track.trackNumber, { pts: stream.times[previous], duration: Math.max(0, end - stream.times[previous]),
             keyframe: true, ranges: [[stream.starts[previous], stream.starts[previous] + stream.lengths[previous] - 1]] });
         };
+        // THE THREAD IS GIVEN BACK at each portion of the file the table
+        // reaches: a two-hour soundtrack is some 300 000 packets, and built in
+        // one stretch it held the main thread with the map's first pass for
+        // 5-7 s while FFmpeg's first open waited for its answers
+        // (torrent-tv/meta#178).
+        let portion = -1;
         for (let at = 0; at < stream.count; at++) {
           if (!stream.lengths[at]) continue;
+          const reached = Math.floor(stream.starts[at] / this.portionBytes);
+          if (Number.isFinite(reached) && reached !== portion) {
+            if (portion >= 0) await new Promise(resolve => setImmediate(resolve));
+            portion = reached;
+          }
           if (previous >= 0) append(stream.times[at]);
           previous = at;
         }

package/services/server/ViewerRequests.js

@@ -646,6 +646,14 @@ export class ViewerRequests {
         processingRanges: liveRuns.map(({ progress }) => ({
           start: progress.startPositionSeconds, end: progress.processedSeconds
         })),
+        // What a run's start costs this output, and the stretches its live
+        // runs were given: the forecast starts a run wherever production meets
+        // bytes that were not held when the run before was admitted.
+        openSeconds: this.#host.openSecondsOf?.(output) ?? null,
+        runSpans: liveRuns.map(run => ({
+          start: output.timeline?.publishedStartOf?.(run.from),
+          end: Number.isInteger(run.to) && run.to >= run.from ? output.timeline?.publishedStartOf?.(run.to + 1) : Number.POSITIVE_INFINITY
+        })),
         bitsPerMediaSecond: Number.isFinite(observedMbps) && observedMbps > 0 ? observedMbps * 1_000_000 :
           this.#host.initialOutputBitsPerMediaSecondOf?.(output) ?? 0,
         readings: trackRates,
@@ -705,7 +713,8 @@ export class ViewerRequests {
     const forecast = withSubtitleReadiness(this.#host.playbackReadiness.predict(input), subtitle,
       subtitle ? this.#host.subtitleReadyFor?.(viewer) !== false : true);
     forecast.operations = outputs.flatMap((output, index) => {
-      const common = { speed: this.#host.playbackReadiness.forecastRate(tracks[index].readings), processedSeconds: tracks[index].processedSeconds };
+      const common = { speed: this.#host.playbackReadiness.forecastRate(tracks[index].readings, now, 0, "piece"),
+        processedSeconds: tracks[index].processedSeconds };
       return [
         ...(output.spec.video ? [{ ...common, track: "video",
           operation: output.spec.transcodesVideo ? "encode" : "copy",
@@ -855,10 +864,17 @@ export class ViewerRequests {
     const reading = this.#host.encodeSpeedReadingOf?.(output, now) ?? null;
     if (Number.isFinite(reading?.speed) && reading.speed > 0 && Number.isFinite(reading.at)) {
       trend.add(reading.at, reading.speed);
-    } else {
-      const projected = Number(this.#host.projectedEncodeSpeedOf?.(output));
+    } else if (!trend.snapshot()) {
+      // ONLY UNTIL A PIECE IS MEASURED does the prediction stand for the
+      // encoder, and it is not kept among the readings. Added on every poll
+      // between runs, it put the machine's share of that moment — 1 % at a
+      // cold start — on the whole film, and the forecast read 0.03x
+      // (torrent-tv/meta#178).
+      const projected = Number(this.#host.predictedEncodeSpeedOf?.(output) ?? this.#host.projectedEncodeSpeedOf?.(output));
       if (Number.isFinite(projected) && projected > 0) {
-        trend.add(now, projected);
+        const seed = new this.#host.playbackReadiness.RateTrend();
+        seed.add(now, projected);
+        return seed.snapshot();
       }
     }
     return trend.snapshot();

package/services/server/wire-outputs.js

@@ -579,13 +579,16 @@ export function wireOutputs({
     sourceInputsFor: (output, index) => parts.sourceInputsFor?.(output, index),
     encodeSpeedReadingOf: (output) => parts.encodeCost.latestSpeedReadingOf(output),
     projectedEncodeSpeedOf: (output) => parts.encodeCost.projectedSpeedOf(output),
+    // The speed the offer predicted for this output when it chose its mode: a
+    // forecast with no measured piece yet stands on it rather than on the
+    // machine's share of the moment (torrent-tv/meta#178).
+    predictedEncodeSpeedOf: (output) => {
+      const predicted = Number(qualityStateOf(output).predictedSpeedWhenOffered);
+      return Number.isFinite(predicted) && predicted > 0 ? predicted : null;
+    },
     audioDescriptionOf,
-    processingStartupSecondsOf: (output) => output.spec.carries === "audio-only" ?
-      audioReadingFor(audioCalibration, { ...audioDescriptionOf(output),
-        codec: audioDescriptionOf(output)?.codec ?? output.file.media?.audioCodec,
-        transcode: output.spec.audio?.transcode })?.startupSeconds ?? 0 :
-      Math.max(0, (startStopCost?.firstByteWaitSec ?? 0) - parts.segmentDurationSec /
-        parts.encodeCost.projectedSpeedOf(output)),
+    openSecondsOf: (output) => runStartSecondsOf(output),
+    processingStartupSecondsOf: (output) => runStartSecondsOf(output),
     initialOutputBitsPerMediaSecondOf: (output) => {
       const description = audioDescriptionOf(output);
       const reference = audioReadingFor(audioCalibration, { codec: description?.codec, transcode: false });
@@ -1045,6 +1048,27 @@ export function wireOutputs({
     readFree: freeBytesFor,
     logger
   });
+  /**
+   * What starting a run costs this output before its first piece is encoded:
+   * its own measured open where it has one (`RunCosts.openOf`), else the
+   * host's startup reading of spawn to first piece less that piece's encoding;
+   * for sound, its packaged startup reading.
+   *
+   * @param {object} output
+   * @returns {number}
+   */
+  function runStartSecondsOf(output) {
+    if (output.spec.carries === "audio-only") {
+      return audioReadingFor(audioCalibration, { ...audioDescriptionOf(output),
+        codec: audioDescriptionOf(output)?.codec ?? output.file.media?.audioCodec,
+        transcode: output.spec.audio?.transcode })?.startupSeconds ?? 0;
+    }
+    const open = parts.encodeOrchestrator?.openOf?.(output.outputKey ?? "");
+    if (open?.measured) return open.seconds;
+    return Math.max(0, (startStopCost?.firstByteWaitSec ?? 0) - parts.segmentDurationSec /
+      parts.encodeCost.projectedSpeedOf(output));
+  }
+
   // Realtime-budget monitor: only meaningful for the software encoder with a
   // benchmark (the only path that can pick/step resolution). Cheap no-op scan
   // otherwise.

package/services/viewer/playback-readiness.js

@@ -49,8 +49,8 @@ const CLIENT_RANGE_START_TOLERANCE_SECONDS = 0.25;
  * @param {number} horizonSeconds
  * @returns {number | null}
  */
-export function forecastRate(readings, now = Date.now(), horizonSeconds = 0) {
-  const curve = rateCurve(readings, now);
+export function forecastRate(readings, now = Date.now(), horizonSeconds = 0, weighting = "last") {
+  const curve = rateCurve(readings, now, weighting);
   if (!curve) {
     return null;
   }
@@ -192,7 +192,12 @@ 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 : []),
-    curve: rateCurve(track.readings, now),
+    // 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
+    // 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"),
     bitsPerMediaSecond: averageBitsPerMediaSecond(track, track.segments,
       new Set(Array.isArray(track.readySegmentIndices) ? track.readySegmentIndices : [])),
     segments: segmentsOf[trackIndex]
@@ -211,7 +216,10 @@ export function predictPlaybackReadiness(input = {}) {
     const serviceKey = typeof source.serviceKey === "string" ? source.serviceKey : id;
     let service = sourceServices.get(serviceKey);
     if (!service) {
-      service = { rate: rateCurve(source.downloadRateReadings, now), finish: 0 };
+      // Bytes over time across the readings the trend keeps: the last 5 s of a
+      // swarm moved between 0.97 and 5.8 MB/s and was carried to the end of the
+      // film each time (torrent-tv/meta#178).
+      service = { rate: rateCurve(source.downloadRateReadings, now, "time"), finish: 0 };
       sourceServices.set(serviceKey, service);
     }
     sourceState.set(id, { source, service });
@@ -330,6 +338,22 @@ export function predictPlaybackReadiness(input = {}) {
     }
   }
   const trackFinish = trackState.map(({ track }) => finiteNonNegative(track.startupRemainingSeconds));
+  // WHERE A RUN STARTS, AND WHAT IT COSTS. A run is given the stretch whose
+  // bytes are held when its input is admitted, and the next one starts after
+  // it, when more bytes are held, and opens its input first — 6-10 s on an
+  // OpenDML AVI. Charged once at the first start only, a cold AVI made of runs
+  // of one to five pieces was forecast as one run (torrent-tv/meta#178). So a
+  // piece outside the live runs' stretches whose bytes arrive after the run
+  // the schedule last started was admitted begins a run of its own, admitted
+  // when the piece before it is made and its bytes are held, then opened.
+  // The first run's start is `startupRemainingSeconds`, charged once above; a
+  // stretch's bound by memory and by its copy time is not modelled.
+  const runStarts = trackState.map(({ track }) => ({
+    openSeconds: finiteNonNegative(track.openSeconds),
+    spans: (Array.isArray(track.runSpans) ? track.runSpans : [])
+      .filter(span => Number.isFinite(span?.start) && span.end > span.start),
+    admittedAt: finiteNonNegative(track.startupRemainingSeconds) > 0 ? 0 : null
+  }));
   const sourceByteCoverage = new Map([...sourceByteService].map(([id, ranges]) => [id, numericCoverage(ranges)]));
   const sourceArrivals = new Map([...sourceByteService].map(([id, ranges]) => [id, indexedArrivals(ranges)]));
   let transferFinish = 0;
@@ -386,7 +410,15 @@ export function predictPlaybackReadiness(input = {}) {
     // Production accepts a complete held segment input. It cannot overlap its
     // own source download; reused input retains its original arrival time.
     const processing = trackState[trackIndex].curve;
-    const admittedAt = Math.max(trackFinish[trackIndex], sourceArrivalAt);
+    let admittedAt = Math.max(trackFinish[trackIndex], sourceArrivalAt);
+    if (!job.produced && encodeWork > 0) {
+      const run = runStarts[trackIndex];
+      const live = run.spans.some(span => segment.startSeconds >= span.start && segment.startSeconds < span.end);
+      if (!live && (run.admittedAt === null || sourceArrivalAt > run.admittedAt)) {
+        run.admittedAt = admittedAt;
+        admittedAt += run.openSeconds;
+      }
+    }
     const producedAt = job.produced || encodeWork === 0 ? 0 : processing.finish(encodeWork, admittedAt);
     trackFinish[trackIndex] = Math.max(trackFinish[trackIndex], producedAt);
     productions.push({ at: producedAt, trackIndex, segment, requiresSource: sourceArrivalAt > 0 });
@@ -787,11 +819,19 @@ function roundedHalfUp(numerator, denominator) {
   return 2n * (numerator - floor * denominator) >= denominator ? floor + 1n : floor;
 }
 
-function rateCurve(readings, now) {
+/**
+ * @param {*} readings - A summary (`RateTrend.snapshot`) or the readings themselves.
+ * @param {number} now
+ * @param {"last" | "piece" | "time"} [weighting] - Which rate the readings
+ *   stand for: the last one; work per working time where each reading is one
+ *   piece of film; or quantity per wall time where each reading holds until
+ *   the next.
+ */
+function rateCurve(readings, now, weighting = "last") {
   if (readings && Number.isFinite(readings.count) && readings.count > 0 &&
     Number.isFinite(readings.lastAt) && Number.isFinite(readings.lastValue) &&
     Number.isFinite(readings.meanValue) && Number.isFinite(readings.spanSeconds)) {
-    return rateCurveFrom(readings, now);
+    return rateCurveFrom(readings, weighting);
   }
   const ordered = (Array.isArray(readings) ? readings : [])
     .filter((reading) => Number.isFinite(reading?.at) && Number.isFinite(reading?.value) && reading.value >= 0)
@@ -802,25 +842,38 @@ function rateCurve(readings, now) {
     return null;
   }
 
-  return rateCurveFrom(summarizeRate(ordered), now);
+  return rateCurveFrom(summarizeRate(ordered), weighting);
 }
 
 function summarizeRate(readings) {
   const latest = readings.at(-1);
+  let weighted = 0;
+  for (let index = 0; index + 1 < readings.length; index += 1) {
+    weighted += readings[index].value * (readings[index + 1].at - readings[index].at);
+  }
+  const spanMs = latest.at - readings[0].at;
   return {
     count: readings.length,
     lastAt: latest.at,
     lastValue: latest.value,
     meanValue: readings.reduce((sum, reading) => sum + reading.value, 0) / readings.length,
-    spanSeconds: (latest.at - readings[0].at) / 1000
+    // Each reading one piece of work: work over the time it took.
+    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
   };
 }
 
-function rateCurveFrom({ lastValue }) {
-  // Conditional projection of the current measured service. No exponential
+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 rate = Math.max(0, lastValue);
+  const value = weighting === "piece" && Number.isFinite(summary.harmonicValue) ? summary.harmonicValue
+    : weighting === "time" && Number.isFinite(summary.timeWeightedValue) ? summary.timeWeightedValue
+      : summary.lastValue;
+  const rate = Math.max(0, value);
   const workBy = (seconds) => rate * Math.max(0, seconds);
   return {
     rateAt: () => rate,