@torrent-tv/proxy 2.9.101 → 2.9.102

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.9.102
+
+- **New**: The playback plan also reports what this host takes to CREATE a session — median of the last eight, 116-843 ms depending on whether the keyframe index is already in hand. It is the second term of the browser's end-to-end estimate, which is being rebuilt as a sum over the stages that have not happened yet rather than a choice between figures that each describe only one of them (`research/playback-eta-2026-08-05.md`).
+
 ## 2.9.101
 
 - **New**: The playback plan reports what this host takes to produce a session's first segment — the median of its last eight, measured from session-create to a servable segment (782-1518 ms on the field host). The browser needs it for the gap between "the file is downloaded" and "a segment exists", where until now it assumed the pipeline merely keeps up with realtime and therefore showed 15 s where 3.8 s were left. It is per-host, so a weak box and a fast one each answer for themselves.

package/package.json

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

package/server.js

@@ -165,7 +165,8 @@ export async function startProxyServer({ host, port, transcodeAudio, ffmpegBin,
     sourceRegistry,
     torrentPool,
     warmKeyframeIndex: (params) => hlsSessionManager.warmKeyframeIndex(params),
-    expectedFirstSegmentMs: () => hlsSessionManager.expectedFirstSegmentMs()
+    expectedFirstSegmentMs: () => hlsSessionManager.expectedFirstSegmentMs(),
+    expectedSessionCreateMs: () => hlsSessionManager.expectedSessionCreateMs()
   });
 
   app.get("/health", async (req, reply) => handleHealthGet(req, reply, { version }));

package/services/hls-session-manager.js

@@ -808,6 +808,16 @@ export class HlsSessionManager {
    */
   #firstSegmentLatencies = [];
 
+  /**
+   * Recent times to create a session, in ms — the second term of the browser's
+   * estimate. Measured for the same reason as the first: it is 116-843 ms
+   * depending on whether the keyframe index is already in hand, and guessing it
+   * was one of the ways the shown figure stopped describing the whole wait.
+   *
+   * @type {number[]}
+   */
+  #sessionCreateLatencies = [];
+
   /**
    * @param {HlsSessionManagerOptions} options
    */
@@ -1121,6 +1131,7 @@ export class HlsSessionManager {
         );
       });
     }
+    this.#rememberSessionCreateLatency(Date.now() - createEntryMs);
     logger.info(
       `cold-start ${sessionId.slice(0, 8)}: media-info=${mediaInfoMs}ms (${mediaInfoSource}) ` +
         `keyframes=${keyframeMs === -1 ? "skipped" : keyframeMs === -2 ? "background" : `${keyframeMs}ms`} ` +
@@ -2750,6 +2761,30 @@ export class HlsSessionManager {
    * @param {number} latencyMs
    * @returns {void}
    */
+  #rememberSessionCreateLatency(latencyMs) {
+    if (!Number.isFinite(latencyMs) || latencyMs <= 0) {
+      return;
+    }
+    this.#sessionCreateLatencies.push(latencyMs);
+    if (this.#sessionCreateLatencies.length > FIRST_SEGMENT_SAMPLES) {
+      this.#sessionCreateLatencies.shift();
+    }
+  }
+
+  /**
+   * What this host typically takes to create a session, in ms — the median of
+   * recent ones, or null before any has finished.
+   *
+   * @returns {number | null}
+   */
+  expectedSessionCreateMs() {
+    if (this.#sessionCreateLatencies.length === 0) {
+      return null;
+    }
+    const sorted = [...this.#sessionCreateLatencies].sort((left, right) => left - right);
+    return sorted[Math.floor(sorted.length / 2)];
+  }
+
   #rememberFirstSegmentLatency(latencyMs) {
     if (!Number.isFinite(latencyMs) || latencyMs <= 0) {
       return;

package/services/playback-planner.js

@@ -269,6 +269,7 @@ export function createPlaybackPlanner({
   // downloaded" and "a segment exists": until now it assumed the pipeline
   // merely keeps up with realtime, and showed 15 s where 3.8 s were left.
   expectedFirstSegmentMs,
+  expectedSessionCreateMs,
   // Optional. Called once the file's edges are downloaded, so the keyframe
   // index — which reads the same tail of the file — is fetched alongside the
   // codec probe instead of after it. Late-bound to the HLS session manager,
@@ -402,6 +403,7 @@ export function createPlaybackPlanner({
       const { audioCodec, videoCodec, container, durationSeconds, videoWidth, videoHeight, audioTracks, subtitleTracks } = probe;
       const codecsDetected = audioCodec.length > 0 || videoCodec.length > 0;
       const firstSegmentMs = expectedFirstSegmentMs?.() ?? null;
+      const sessionCreateMs = expectedSessionCreateMs?.() ?? null;
       logger.info(
         `plan ${sourceKey.slice(0, 8)}:${fileIndex} torrent-ready=${torrentReadyMs}ms ` +
           `file-edges=${edgesReadyMs - torrentReadyMs}ms probe=${Date.now() - planEntryMs - edgesReadyMs}ms ` +
@@ -430,7 +432,9 @@ export function createPlaybackPlanner({
         subtitleTracks: subtitleTracks ?? [],
         // What this host has recently taken to make a session's first segment.
         // Null until one has finished since startup.
-        expectedFirstSegmentMs: firstSegmentMs
+        expectedFirstSegmentMs: firstSegmentMs,
+        // Second term of the browser's estimate; see research/playback-eta-2026-08-05.md.
+        expectedSessionCreateMs: sessionCreateMs
       };
       // Only cache a plan whose codecs were actually detected. An empty probe is
       // a "header not downloaded yet" signal, not a valid result — caching it