@torrent-tv/proxy 2.101.34 → 2.101.36

package/package.json

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

package/routes/api/sources/stats/get.js

@@ -1,4 +1,5 @@
 import { logger } from "../../../../utils/logger.js";
+import { performance } from "node:perf_hooks";
 
 /**
  * Return download statistics for a registered torrent source.
@@ -65,7 +66,13 @@ export async function handleApiSourceStatsGet(req, reply, { sourceRegistry, torr
   // Awaited: with the torrent on its own thread this is a round trip, not a
   // local lookup. Without the await the reply was the pending promise itself,
   // which serialises to `{}` — the empty stats seen in the field 2026-08-02.
-  const stats = await torrentPool.getFileStats(torrent, fileIndex);
+  const statsStartedAt = performance.now();
+  let stats;
+  try {
+    stats = await torrentPool.getFileStats(torrent, fileIndex);
+  } finally {
+    logger.info(`[stats] ${sourceKey.slice(0, 8)} getFileStatsMs=${(performance.now() - statsStartedAt).toFixed(1)}`);
+  }
   if (stats?.pending || !stats) {
     const waitEstimate = initialEstimate();
     return reply.code(202).send({ pending: true, ...(waitEstimate ? { waitEstimate } : {}) });

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

@@ -10,6 +10,7 @@
  */
 
 import { logger } from "../../../utils/logger.js";
+import { performance } from "node:perf_hooks";
 import { OUTPUT_NO_CAPACITY, OUTPUT_UNAVAILABLE } from "../../../services/encode/output/index.js";
 import { replyNoCapacity, replyOutputUnavailable } from "../../../services/server/http-responses.js";
 import { waitForPlan } from "../../../services/media/await-plan.js";
@@ -81,38 +82,49 @@ export async function handleApiTranscodeSessionsPost(req, reply, { viewerRequest
   }
 
   const cancellation = new AbortController();
+  const timing = { startedAt: performance.now(), openMs: 0, openCalls: 0,
+    planWaitInclusiveMs: null, masterMs: null, offerMs: null, tracksMs: null };
   const cancelled = () => cancellation.abort();
   reply.raw?.once?.("close", cancelled);
   if (reply.raw?.destroyed) cancelled();
   try {
-    const open = () => viewerRequests.createOrGetSession({
-      signal: cancellation.signal,
-      sourceKey,
-      fileIndex,
-      transcodeVideo,
-      transcodeAudio,
-      consumerId,
-      fileName,
-      targetWidth: Number.isInteger(targetWidth) && targetWidth > 0 ? targetWidth : 0,
-      targetHeight: Number.isInteger(targetHeight) && targetHeight > 0 ? targetHeight : 0,
-      exactSize,
-      visiblePicture,
-      audioRenditions,
-      startPositionSeconds:
-        Number.isFinite(startPositionSeconds) && startPositionSeconds > 0
-          ? startPositionSeconds
-          : 0,
-      viewerLinkMbps: Number.isFinite(viewerLinkMbps) && viewerLinkMbps > 0 ? viewerLinkMbps : null,
-      linkSampleMbps: Number.isFinite(linkSampleMbps) && linkSampleMbps > 0 ? linkSampleMbps : null,
-      linkSampleAt: Number.isFinite(linkSampleAt) && linkSampleAt > 0 ? linkSampleAt : null,
-      linkSampleAgeMs: Number.isFinite(linkSampleAgeMs) && linkSampleAgeMs >= 0 ? linkSampleAgeMs : null,
-      bufferedAheadSec: Number.isFinite(bufferedAheadSec) && bufferedAheadSec >= 0 ? bufferedAheadSec : 0,
-      bufferLimitSeconds:
-        Number.isFinite(bufferLimitSeconds) && bufferLimitSeconds > 0 ? bufferLimitSeconds : null,
-      audioTrackIndex:
-        Number.isInteger(audioTrackIndex) && audioTrackIndex > 0 ? audioTrackIndex : 0,
-      segmentFormatId
-    });
+    const open = async () => {
+      const openStartedAt = performance.now();
+      timing.openCalls += 1;
+      try {
+        return await viewerRequests.createOrGetSession({
+          signal: cancellation.signal,
+          sourceKey,
+          fileIndex,
+          transcodeVideo,
+          transcodeAudio,
+          consumerId,
+          fileName,
+          targetWidth: Number.isInteger(targetWidth) && targetWidth > 0 ? targetWidth : 0,
+          targetHeight: Number.isInteger(targetHeight) && targetHeight > 0 ? targetHeight : 0,
+          exactSize,
+          visiblePicture,
+          audioRenditions,
+          startPositionSeconds:
+            Number.isFinite(startPositionSeconds) && startPositionSeconds > 0
+              ? startPositionSeconds
+              : 0,
+          viewerLinkMbps: Number.isFinite(viewerLinkMbps) && viewerLinkMbps > 0 ? viewerLinkMbps : null,
+          linkSampleMbps: Number.isFinite(linkSampleMbps) && linkSampleMbps > 0 ? linkSampleMbps : null,
+          linkSampleAt: Number.isFinite(linkSampleAt) && linkSampleAt > 0 ? linkSampleAt : null,
+          linkSampleAgeMs: Number.isFinite(linkSampleAgeMs) && linkSampleAgeMs >= 0 ? linkSampleAgeMs : null,
+          bufferedAheadSec: Number.isFinite(bufferedAheadSec) && bufferedAheadSec >= 0 ? bufferedAheadSec : 0,
+          bufferLimitSeconds:
+            Number.isFinite(bufferLimitSeconds) && bufferLimitSeconds > 0 ? bufferLimitSeconds : null,
+          audioTrackIndex:
+            Number.isInteger(audioTrackIndex) && audioTrackIndex > 0 ? audioTrackIndex : 0,
+          segmentFormatId
+        });
+      } finally {
+        timing.openMs += performance.now() - openStartedAt;
+      }
+    };
+    const planWaitStartedAt = performance.now();
     const session = subscribeSource ? (await waitForPlan({ signal: cancellation.signal,
       subscribe: listener => subscribeSource(sourceKey, fileIndex, listener),
       read: async () => {
@@ -123,13 +135,22 @@ export async function handleApiTranscodeSessionsPost(req, reply, { viewerRequest
         }
       }
     })).session : await open();
+    timing.planWaitInclusiveMs = performance.now() - planWaitStartedAt;
     // The index of quality variants, when this session has more than one to
     // offer. Its presence is what tells the browser it can change quality
     // without a new session: the player switches variants itself, appending the
     // new one after what is already buffered. Absent for a copied video, whose
     // segments are cut at the source's own keyframes and so cannot be spliced
     // with a re-encoded rung.
+    let stageStartedAt = performance.now();
     const hasVariants = renditions.buildMasterPlaylist(session.id) !== null;
+    timing.masterMs = performance.now() - stageStartedAt;
+    stageStartedAt = performance.now();
+    const offeredHeights = quality.offeredHeights(session);
+    timing.offerMs = performance.now() - stageStartedAt;
+    stageStartedAt = performance.now();
+    const tracks = renditions.declaredTracks(session);
+    timing.tracksMs = performance.now() - stageStartedAt;
     return reply.send({
       sessionId: session.id,
       playlistPath: `/transcode/${session.id}/index.m3u8`,
@@ -149,12 +170,12 @@ export async function handleApiTranscodeSessionsPost(req, reply, { viewerRequest
       // it, it fell back to a ladder of its own invention and offered rungs the
       // proxy had just refused, and picking one re-opened the session at a
       // height measured at a third of realtime.
-      offeredHeights: quality.offeredHeights(session),
+      offeredHeights,
       // What this session's output will carry, stated rather than left to be
       // discovered. The browser checks what it actually got against this: a
       // track that never arrives is otherwise noticed only by its absence,
       // minutes later, as a black picture with working sound.
-      tracks: renditions.declaredTracks(session),
+      tracks,
       // The soundtrack this viewer is sent and whether it is re-encoded — the
       // proxy's decision, which can differ from what the page asked for: a
       // track no figure states a rate for is re-encoded even for a browser that
@@ -196,5 +217,13 @@ export async function handleApiTranscodeSessionsPost(req, reply, { viewerRequest
     return reply.code(500).send({ error: `Failed to prepare transcode session: ${message}` });
   } finally {
     reply.raw?.removeListener?.("close", cancelled);
+    const elapsed = (key) => Number.isFinite(timing[key]) ? timing[key].toFixed(1) : "n/a";
+    logger.info(
+      `transcode-session timing outcome=${cancellation.signal.aborted ? "cancelled" : "handler-return"} ` +
+        `consumer=${consumerId || "unknown"} file=${fileIndex} openCalls=${timing.openCalls} ` +
+        `openMs=${timing.openMs.toFixed(1)} planWaitInclusiveMs=${elapsed("planWaitInclusiveMs")} ` +
+        `masterMs=${elapsed("masterMs")} offerMs=${elapsed("offerMs")} tracksMs=${elapsed("tracksMs")} ` +
+        `handlerMs=${(performance.now() - timing.startedAt).toFixed(1)}`
+    );
   }
 }

package/services/server/SegmentServing.js

@@ -1031,48 +1031,6 @@ export class SegmentServing {
     }
   }
 
-  /**
-   * Wait for a valid HLS playlist or a terminal output state, without polling.
-   *
-   * @param {HlsSession} session
-   * @returns {Promise<void>}
-   */
-  async waitUntilReady(session) {
-    // With a synthetic VOD playlist there is nothing to wait for: the playlist
-    // is generated from the probed duration and is available immediately.
-    // Individual segments are long-polled by the segment route as ffmpeg
-    // produces them.
-    if (session.useSyntheticPlaylist) {
-      if (this.#host.encodeRuns.hasFailed(session)) {
-        throw new Error(this.#host.encodeRuns.lastErrorOf(session) || "ffmpeg failed to start HLS session.");
-      }
-      return;
-    }
-
-    const playlistPath = path.join(this.#host.segmentStore.pathFor(session.outputKey ?? ""), PLAYLIST_FILE_NAME);
-    while (this.#host.outputs.get(session.id) === session) {
-      const change = this.subscribeFileChange(session.id);
-      try {
-      if (this.#host.encodeRuns.hasFailed(session)) {
-        throw new Error(this.#host.encodeRuns.lastErrorOf(session) || "ffmpeg failed to start HLS session.");
-      }
-      try {
-        await access(playlistPath);
-        const text = await readFile(playlistPath, "utf8");
-        if (text.includes("#EXTM3U")) {
-            return;
-        }
-      } catch (_error) {
-        // Playlist is not ready yet.
-      }
-      await change.changed;
-      } finally {
-        change.release();
-      }
-    }
-    throw new Error("HLS output was disposed before its playlist became available.");
-  }
-
   /**
    * Answer the player's report that a delivered fragment sits far from the edge
    * of its buffer, with the one fact only this side holds: which boundary the

package/services/server/ViewerRequests.js

@@ -11,13 +11,6 @@ import { logger } from "../../utils/logger.js";
 import { isOutputName, OutputSpec } from "../encode/output/index.js";
 import { withSubtitleReadiness } from "./subtitle-readiness.js";
 
-function isWarmupTimeoutError(error) {
-  if (!(error instanceof Error)) {
-    return false;
-  }
-  return error.message === "HLS playlist is still warming up.";
-}
-
 /**
  * The segment number an assignment is recorded under for this file, −1 for the
  * init, or null for anything that is neither (a playlist).
@@ -93,7 +86,7 @@ export class ViewerRequests {
   #forecastPieces = new WeakMap();
 
   /**
-   * @param {object} host - `opening`, `activeOutputFor`, `viewerSecondsOn`, `minimumBufferSecondsFor`, `getSourceStats`, `disposeSession`, `planEncodersSoon`, `waitUntilReady`, `encodeRuns`, `encodeSpeedReadingsOf`, `outputTimes`, `outputs`, `lookaheadSeconds`, `quality`, `qualityOffer`, `renditions`, `segmentDurationSec`, `segmentStore`, `sourceFiles`, `startupWaitMs`, `viewers`, `acceptsGeneration`, `generationOfRequest`, `noteGivenOutput`, `holdForResponse`, `noteServingVerdict`, `servingVerdictOf`
+   * @param {object} host - `opening`, `activeOutputFor`, `viewerSecondsOn`, `minimumBufferSecondsFor`, `getSourceStats`, `planEncodersSoon`, `encodeRuns`, `encodeSpeedReadingsOf`, `outputTimes`, `outputs`, `lookaheadSeconds`, `quality`, `qualityOffer`, `renditions`, `segmentDurationSec`, `segmentStore`, `sourceFiles`, `startupWaitMs`, `viewers`, `acceptsGeneration`, `generationOfRequest`, `noteGivenOutput`, `holdForResponse`, `noteServingVerdict`, `servingVerdictOf`
    */
   constructor(host) {
     this.#host = host;
@@ -421,19 +414,13 @@ export class ViewerRequests {
       // Where the first encoder goes is the plan's, from where the viewers stand.
       this.#host.planEncodersSoon();
     }
-    try {
-      await this.#host.waitUntilReady(output);
-    } catch (error) {
-      if (!existed && this.#host.encodeRuns.hasFailed(output)) {
-        await this.#host.disposeSession(output.id);
-        throw error;
-      }
-      if (existed && !isWarmupTimeoutError(error)) {
-        throw error;
-      }
-      // Not a failure of the request: the synthetic playlist is already there
-      // and segments appear as the encoder produces them.
-    }
+    // Return the allocated session before a keyframe-based output writes its
+    // first playlist. The browser can then poll this session's live playback
+    // forecast while the source, proxy and client-link work is still underway;
+    // otherwise this request hides all revised estimates until the first
+    // segment is already ready. The playlist route and the viewer's existing
+    // wait loop handle output that is still being prepared, and the progress
+    // route reports a terminal encoder failure.
     return output;
   }
 

package/services/server/wire-outputs.js

@@ -631,7 +631,6 @@ export function wireOutputs({
     getSourceStats: (...args) => parts.getSourceStats?.(...args) ?? null,
     disposeSession: (...args) => parts.lifecycle.disposeSession(...args),
     planEncodersSoon: (...args) => parts.encodeRuns.planEncodersSoon(...args),
-    waitUntilReady: (...args) => parts.serving.waitUntilReady(...args),
     noteViewerWaiting: (viewer, wait) => parts.encodeOrchestrator?.noteViewerWaiting(viewer, wait),
     get encodeRuns() { return parts.encodeRuns; },
     // When this viewer's playback can start and run to the end: the viewer