@torrent-tv/proxy 2.101.29 → 2.101.30

package/package.json

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

package/routes/api/client-logs/post.js

@@ -91,14 +91,19 @@ export async function handleApiClientLogsPost(req, reply, { clientLogs, viewerRe
   }
   for (const row of rows) {
     const message = row && typeof row.msg === "string" ? row.msg : "";
-    const match = /^\[first-frame-observation\] consumer=([^ ]+) generation=(\d+) waitId=([^ ]+) wait=(\d+) audioReady=(true|false) elapsedMs=([\d.]+)$/.exec(message);
+    const match = /^\[first-frame-observation\] consumer=([^ ]+) generation=(\d+) waitId=([^ ]+) wait=(\d+) audioReady=(true|false) elapsedMs=([\d.]+)(?: coldStartTotalMs=([\d.]+) transportMs=([\d.]+) planMs=([\d.]+) prepareMs=([\d.]+) prebufferMs=([\d.]+) presentationMs=([\d.]+))?$/.exec(message);
     if (match) {
       const elapsedMs = Number(match[6]);
       if (match[1].length <= 64 && Number.isSafeInteger(Number(match[2])) && match[3].length <= 256 &&
           Number.isSafeInteger(Number(match[4])) && match[5] === "true" &&
           Number.isFinite(elapsedMs) && elapsedMs >= 0) {
+        const stageValues = match.slice(7).map(value => value === undefined ? null : Number(value));
+        const stages = stageValues.every(value => value !== null && Number.isFinite(value) && value >= 0)
+          ? { totalMs: stageValues[0], transportMs: stageValues[1], planMs: stageValues[2],
+            prepareMs: stageValues[3], prebufferMs: stageValues[4], presentationMs: stageValues[5] }
+          : null;
         viewerRequests?.noteFirstFrameObservation?.({ consumerId: match[1], generation: Number(match[2]),
-          waitId: match[3], wait: Number(match[4]), elapsedMs });
+          waitId: match[3], wait: Number(match[4]), elapsedMs, stages });
       }
     }
   }

package/services/encode/LocalObservations.js

@@ -6,7 +6,7 @@
  * NOT A TABLE OF QUALITY, and not a condition for anything. The proxy selects,
  * admits and serves with nothing kept here at all: the startup calibration is
  * what qualifies a mode and prices it, and the admission is what decides
- * whether there is room. What is kept here makes three of those figures more
+ * whether there is room. What is kept here makes four of those figures more
  * exact on THIS machine once it has done the work for real:
  *
  * 1. how fast an encode of this mode, at this size, actually ran alone on this
@@ -19,6 +19,9 @@
  * 3. how long an output of this mode took to have the piece a viewer needed
  *    after it was asked for, and what that viewer held when they moved — used
  *    as the time to ready when deciding whether a draining buffer is a threat.
+ * 4. the measured transport, track-plan, output-preparation, prebuffer and
+ *    first-presented-frame stages for an earlier start on this proxy
+ *    configuration, used as separate inputs to an early wait forecast.
  *
  * WHAT IS NEVER KEPT: a picture, a clip, a segment, anything about a viewer
  * beyond the seconds they held, and anything that leaves this machine.
@@ -265,31 +268,21 @@ export class LocalObservations {
   }
 
   /**
-   * Keep a browser-measured wait outcome with the source and link readings
-   * visible before the container was inspected. These readings are useful
-   * only on the encoder configurations present on this host.
+   * The viewer presented its first audio-ready frame: keep the separately
+   * measured stage timings and the input snapshots from the start of that run.
    *
-   * @param {{ seconds: number, features: object }} params
+   * @param {{ seconds: number, features: object, featureSnapshots?: object[], stages?: object | null }} params
    * @returns {void}
    */
-  noteFirstFrame({ seconds, features }) {
+  noteFirstFrame({ seconds, features, featureSnapshots = null, stages = null }) {
     if (!Number.isFinite(seconds) || seconds < 0 || !features || typeof features !== "object") return;
     const key = this.#firstFrameKey();
+    const snapshots = [features, ...(Array.isArray(featureSnapshots) ? featureSnapshots : [])]
+      .filter(value => value && typeof value === "object").slice(0, 2).map(firstFrameFeatures);
     const readings = [...(this.#entries.firstFrame[key] ?? []), {
-      seconds,
-      extension: typeof features.extension === "string" ? features.extension : "",
-      fileLength: positive(features.fileLength),
-      downloadSpeed: nonNegative(features.downloadSpeed),
-      linkMbps: nonNegative(features.linkMbps),
-      linkSampleAgeMs: nonNegative(features.linkSampleAgeMs),
-      preparedOutputBytes: nonNegative(features.preparedOutputBytes),
-      fileAvailable: typeof features.fileAvailable === "boolean" ? features.fileAvailable : null,
-      headerRemaining: nonNegative(features.headerRemaining),
-      peers: nonNegative(features.peers),
-      videoOperation: operationOf(features.videoOperation),
-      audioOperation: operationOf(features.audioOperation),
-      videoSpeedX: nonNegative(features.videoSpeedX),
-      audioSpeedX: nonNegative(features.audioSpeedX),
+      ...snapshots[0],
+      featureSnapshots: snapshots,
+      stages: stagesOf(stages),
       at: this.#now()
     }].slice(-READINGS_KEPT);
     this.#entries.firstFrame[key] = readings;
@@ -297,62 +290,86 @@ export class LocalObservations {
   }
 
   /**
-   * Predict this host's first-frame wait from the closest measured start with
-   * the same media suffix. Distance uses squared log-ratios for numeric
-   * inputs and exact-state distance for categorical inputs; it does not mix
-   * bytes, bit rates, processing speed and peers in their raw units. Missing
-   * data contributes distance only when the other observation measured it.
+   * Predict the first-frame wait as the sum of separately predicted cold-start
+   * stages. Each stage uses all compatible measurements, weighted by the
+   * normalized distance between the measured inputs; no complete past wait is
+   * returned as the forecast. A known cache/source state must also be known in
+   * the training observation, otherwise that observation is not comparable.
    *
    * @param {object} features
    * @returns {number | null}
    */
   firstFrameSeconds(features) {
     if (!features || typeof features !== "object") return null;
-    const readings = this.#entries.firstFrame[this.#firstFrameKey()] ?? [];
-    const candidates = readings.filter(reading => reading.extension === (features.extension ?? ""));
+    const candidates = (this.#entries.firstFrame[this.#firstFrameKey()] ?? [])
+      .filter(reading => reading.extension === (features.extension ?? "") && reading.stages);
     if (candidates.length === 0) return null;
     const dimensions = ["fileLength", "downloadSpeed", "linkMbps", "linkSampleAgeMs", "preparedOutputBytes",
       "fileAvailable", "headerRemaining", "peers", "videoOperation", "audioOperation", "videoSpeedX", "audioSpeedX"];
-    const scales = new Map(dimensions.map(key => [key, median(candidates
-      .map(reading => FIRST_FRAME_CATEGORICAL.has(key) ? null : nonNegative(reading[key]))
+    const pointsOf = reading => Array.isArray(reading.featureSnapshots) && reading.featureSnapshots.length > 0
+      ? reading.featureSnapshots : [reading];
+    const scales = new Map(dimensions.map(key => [key, median(candidates.flatMap(reading => pointsOf(reading)
+      .map(point => FIRST_FRAME_CATEGORICAL.has(key) ? null : nonNegative(point[key])))
       .filter(value => value !== null && value > 0))]));
-    let best = null;
+    const distances = [];
     for (const reading of candidates) {
-      let distance = 0;
-      let used = 0;
-      let shared = 0;
-      for (const key of dimensions) {
-        const current = FIRST_FRAME_CATEGORICAL.has(key)
-          ? key === "fileAvailable" ? (typeof features[key] === "boolean" ? features[key] : null)
-            : operationOf(features[key])
-          : nonNegative(features[key]);
-        const previous = FIRST_FRAME_CATEGORICAL.has(key)
-          ? key === "fileAvailable" ? (typeof reading[key] === "boolean" ? reading[key] : null)
-            : operationOf(reading[key])
-          : nonNegative(reading[key]);
-        if (current === null && previous === null) continue;
-        if (current === null || previous === null) {
-          distance += 1;
+      let bestDistance = null;
+      for (const point of pointsOf(reading)) {
+        if ((features.preparedOutputBytes !== null && features.preparedOutputBytes !== undefined &&
+            point.preparedOutputBytes === null) ||
+            [...FIRST_FRAME_CATEGORICAL].some(key => {
+              const current = key === "fileAvailable" ? features[key] : operationOf(features[key]);
+              return current !== null && current !== undefined && point[key] !== current;
+            })) continue;
+        let distance = 0;
+        let used = 0;
+        let shared = 0;
+        for (const key of dimensions) {
+          const current = FIRST_FRAME_CATEGORICAL.has(key)
+            ? key === "fileAvailable" ? (typeof features[key] === "boolean" ? features[key] : null)
+              : operationOf(features[key])
+            : nonNegative(features[key]);
+          const previous = FIRST_FRAME_CATEGORICAL.has(key)
+            ? key === "fileAvailable" ? (typeof point[key] === "boolean" ? point[key] : null)
+              : operationOf(point[key])
+            : nonNegative(point[key]);
+          if (current === null && previous === null) continue;
+          if (current === null || previous === null) {
+            distance += 1;
+            used += 1;
+            continue;
+          }
+          shared += 1;
+          const scale = scales.get(key);
+          const difference = typeof current !== "number" && typeof previous !== "number"
+            ? Number(current !== previous)
+            : scale === null
+              ? Number(current !== previous)
+              : Math.log1p(current / scale) - Math.log1p(previous / scale);
+          distance += difference * difference;
           used += 1;
-          continue;
         }
-        shared += 1;
-        const scale = scales.get(key);
-        const difference = typeof current !== "number" && typeof previous !== "number"
-          ? Number(current !== previous)
-          : scale === null
-            ? Number(current !== previous)
-            : Math.log1p(current / scale) - Math.log1p(previous / scale);
-        distance += difference * difference;
-        used += 1;
-      }
-      if (used === 0 || shared === 0) continue;
-      distance /= used;
-      if (!best || distance < best.distance || (distance === best.distance && reading.at > best.reading.at)) {
-        best = { distance, reading };
+        if (used === 0 || shared === 0) continue;
+        distance /= used;
+        if (bestDistance === null || distance < bestDistance) bestDistance = distance;
       }
+      if (bestDistance !== null) distances.push({ distance: bestDistance, reading });
     }
-    return best?.reading.seconds ?? null;
+    if (distances.length === 0) return null;
+    const exact = distances.filter(candidate => candidate.distance === 0);
+    const weighted = exact.length > 0
+      ? exact.map(candidate => ({ ...candidate, weight: 1 }))
+      : distances.map(candidate => ({ ...candidate, weight: 1 / candidate.distance }));
+    const stages = ["transportMs", "planMs", "prepareMs", "prebufferMs", "presentationMs"];
+    const predicted = stages.map(stage => {
+      const applicable = weighted.filter(candidate => Number.isFinite(candidate.reading.stages[stage]));
+      const totalWeight = applicable.reduce((sum, candidate) => sum + candidate.weight, 0);
+      return totalWeight > 0
+        ? applicable.reduce((sum, candidate) => sum + candidate.reading.stages[stage] * candidate.weight, 0) / totalWeight
+        : null;
+    });
+    if (predicted.some(value => value === null)) return null;
+    return predicted.reduce((sum, value) => sum + value, 0) / 1000;
   }
 
   #firstFrameKey() {
@@ -470,6 +487,33 @@ function operationOf(value) {
   return value === "copy" || value === "encode" ? value : null;
 }
 
+/** @param {unknown} value @returns {{ totalMs: number, transportMs: number, planMs: number, prepareMs: number, prebufferMs: number, presentationMs: number } | null} */
+function stagesOf(value) {
+  if (!value || typeof value !== "object") return null;
+  const keys = ["totalMs", "transportMs", "planMs", "prepareMs", "prebufferMs", "presentationMs"];
+  const stages = Object.fromEntries(keys.map(key => [key, nonNegative(value[key])]));
+  return keys.every(key => stages[key] !== null) ? stages : null;
+}
+
+/** @param {object} features @returns {object} */
+function firstFrameFeatures(features) {
+  return {
+    extension: typeof features.extension === "string" ? features.extension : "",
+    fileLength: positive(features.fileLength),
+    downloadSpeed: nonNegative(features.downloadSpeed),
+    linkMbps: nonNegative(features.linkMbps),
+    linkSampleAgeMs: nonNegative(features.linkSampleAgeMs),
+    preparedOutputBytes: nonNegative(features.preparedOutputBytes),
+    fileAvailable: typeof features.fileAvailable === "boolean" ? features.fileAvailable : null,
+    headerRemaining: nonNegative(features.headerRemaining),
+    peers: nonNegative(features.peers),
+    videoOperation: operationOf(features.videoOperation),
+    audioOperation: operationOf(features.audioOperation),
+    videoSpeedX: nonNegative(features.videoSpeedX),
+    audioSpeedX: nonNegative(features.audioSpeedX)
+  };
+}
+
 /** @param {number[]} values @returns {number | null} */
 function median(values) {
   if (values.length === 0) return null;

package/services/server/ViewerRequests.js

@@ -8,7 +8,7 @@
  */
 
 import { logger } from "../../utils/logger.js";
-import { isOutputName } from "../encode/output/index.js";
+import { isOutputName, OutputSpec } from "../encode/output/index.js";
 import { withSubtitleReadiness } from "./subtitle-readiness.js";
 
 function isWarmupTimeoutError(error) {
@@ -190,7 +190,10 @@ export class ViewerRequests {
     const changed = this.#recordEarlyWaitSnapshot(context, context.features);
     if (sameWait && changed) context.revision += 1;
     this.#pruneEarlyWaits();
-    const totalSeconds = this.#host.firstFrameSecondsOf?.(context.features) ?? null;
+    const measuredWorkSeconds = processing.firstRequiredSegmentsSeconds;
+    const totalSeconds = Number.isFinite(measuredWorkSeconds) && measuredWorkSeconds >= 0
+      ? waitElapsedSince(context, waitElapsedMs) / 1000 + measuredWorkSeconds
+      : this.#host.firstFrameSecondsOf?.(context.features) ?? null;
     const seconds = earlyWaitRemainingSeconds(totalSeconds, waitElapsedSince(context, waitElapsedMs));
     if (!Number.isFinite(seconds) || seconds < 0) return null;
     return { version: 1, waitId, revision: context.revision, remainingSeconds: seconds, ageMs: 0 };
@@ -201,16 +204,20 @@ export class ViewerRequests {
    * viewing. The saved source and link readings are the ones available at
    * selection time, before the full track plan existed.
    *
-   * @param {{ consumerId: string, generation: number, waitId: string, wait: number, elapsedMs: number }} params
+   * @param {{ consumerId: string, generation: number, waitId: string, wait: number, elapsedMs: number,
+   *   stages?: { totalMs: number, transportMs: number, planMs: number, prepareMs: number,
+   *     prebufferMs: number, presentationMs: number } | null }} params
    * @returns {void}
    */
-  noteFirstFrameObservation({ consumerId, generation, waitId, wait, elapsedMs }) {
+  noteFirstFrameObservation({ consumerId, generation, waitId, wait, elapsedMs, stages = null }) {
     const key = `${consumerId}:${waitId}`;
     const early = this.#earlyWaits.get(key);
     if (!early || early.generation !== generation || !Number.isSafeInteger(wait) || wait < 0 || early.observedWaits.has(wait) ||
         !Number.isFinite(elapsedMs) || elapsedMs < 0) return;
-    for (const snapshot of early.snapshots) {
-      this.#host.noteFirstFrame?.({ seconds: elapsedMs / 1000, features: snapshot });
+    const initialFeatures = early.snapshots[0];
+    if (initialFeatures) {
+      this.#host.noteFirstFrame?.({ seconds: elapsedMs / 1000, features: initialFeatures,
+        featureSnapshots: early.snapshots.slice(1), stages });
     }
     early.observedWaits.add(wait);
     early.updatedAt = Date.now();
@@ -259,11 +266,21 @@ export class ViewerRequests {
     if (!outputs?.values || !segmentStore?.sizesOf) return null;
     let bytes = 0;
     const seen = new Set();
-    for (const output of outputs.values()) {
-      if (output.file?.sourceKey !== sourceKey || output.file?.fileIndex !== fileIndex || !output.outputKey) continue;
-      if (seen.has(output.outputKey)) continue;
-      seen.add(output.outputKey);
-      for (const size of segmentStore.sizesOf(output.outputKey).values()) {
+    const liveOutputs = [...outputs.values()];
+    const keys = new Set([
+      ...liveOutputs.map(output => output.outputKey),
+      ...(segmentStore.addresses?.() ?? [])
+    ].filter(key => typeof key === "string" && key.length > 0));
+    for (const outputKey of keys) {
+      const output = liveOutputs.find(candidate => candidate.outputKey === outputKey);
+      const spec = output ? null : OutputSpec.fromKey(outputKey);
+      const matchesFile = output
+        ? output.file?.sourceKey === sourceKey && output.file?.fileIndex === fileIndex
+        : spec?.sourceKey === sourceKey &&
+          (spec.video?.fileIndex === fileIndex || spec.audio?.fileIndex === fileIndex);
+      if (!matchesFile || seen.has(outputKey)) continue;
+      seen.add(outputKey);
+      for (const size of segmentStore.sizesOf(outputKey).values()) {
         if (Number.isFinite(size) && size > 0) bytes += size;
       }
     }
@@ -976,7 +993,8 @@ export class ViewerRequests {
           videoOperation: videoOperation?.operation,
           audioOperation: audioOperation?.operation,
           videoSpeedX: videoOperation?.speed,
-          audioSpeedX: audioOperation?.speed
+          audioSpeedX: audioOperation?.speed,
+          firstRequiredSegmentsSeconds: forecast.firstRequiredSegmentsSeconds
         } });
       if (waitEstimate) forecast.waitEstimate = waitEstimate;
     }

package/services/viewer/playback-readiness.js

@@ -542,6 +542,15 @@ export function predictPlaybackReadiness(input = {}) {
         ...(stop.unavailableSource ? { unavailableSource: stop.unavailableSource } : {}) };
     }
   }
+  const firstRequiredTrackSeconds = trackState.slice(0, requiredTracks).map((state, trackIndex) => {
+    const first = state.segments.find(segment => segment.endSeconds > position);
+    if (!first) return 0;
+    if (first.ranges.every(range => contains(state.clientRanges, range.start, range.end))) return 0;
+    const completion = completions.find(item => item.trackIndex === trackIndex && item.segment.index === first.index);
+    return completion?.at ?? null;
+  });
+  const firstRequiredSegmentsSeconds = firstRequiredTrackSeconds.every(Number.isFinite)
+    ? Math.max(0, ...firstRequiredTrackSeconds) : null;
   const delay = Math.max(0, ...constraints);
   const originReady = trackState.every(({ clientRanges }) => compare(contiguousEnd(clientRanges, at), at) > 0);
   const ready = delay === 0 && originReady;
@@ -549,6 +558,7 @@ export function predictPlaybackReadiness(input = {}) {
     Math.max(0, reserve - buffered), ready ? 'trajectory-safe-now' :
       Number.isFinite(delay) ? 'minimum-safe-delay' : 'service-not-advancing', preparedSegments);
   return { ...forecast, measuredAt: now, predictedStartAt: Number.isFinite(delay) ? now + delay * 1000 : null,
+    firstRequiredSegmentsSeconds,
     // The piece whose `kind` — its production, or its delivery to the page —
     // comes `atSeconds` from now while the media before it lasts
     // `aheadSeconds`: the difference is the delay.