@torrent-tv/proxy 2.101.37 → 2.101.39

package/package.json

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

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

@@ -219,6 +219,7 @@ 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 handlerReturnAt = performance.now();
     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"} ` +
@@ -226,7 +227,8 @@ export async function handleApiTranscodeSessionsPost(req, reply, { viewerRequest
         `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)}`
+        `handlerReturnAtMs=${handlerReturnAt.toFixed(3)} ` +
+        `handlerMs=${(handlerReturnAt - timing.startedAt).toFixed(1)}`
     );
   }
 }

package/server.js

@@ -153,6 +153,15 @@ export async function startProxyServer({
     // receives torrent source payloads that may be arbitrarily large.
     bodyLimit: 256 * 1024 * 1024 // 256 MB
   });
+  const forwardedSessionResponseStarts = new WeakMap();
+  const logForwardedSessionResponseStage = (stage, req) => {
+    const startedAt = forwardedSessionResponseStarts.get(req);
+    const requestId = req.headers["x-ttv-forwarded-request-id"];
+    if (startedAt === undefined || typeof requestId !== "string") return;
+    const at = performance.now();
+    logger.info(`[forecast-http] stage=${stage} requestId=${requestId} atMs=${at.toFixed(3)} ` +
+      `elapsedMs=${(at - startedAt).toFixed(3)}`);
+  };
 
   await app.register(fastifyHelmet, {
     // Proxy serves media to a different origin (registry UI), so CORP must allow cross-origin usage.
@@ -173,20 +182,32 @@ export async function startProxyServer({
   });
   app.addHook("onRequest", async (req, reply) => {
     const requestId = req.headers["x-ttv-forwarded-request-id"];
-    if (typeof requestId !== "string") return;
+    if (typeof requestId !== "string" || req.method !== "POST" || req.url !== "/api/transcode-sessions") return;
     const startedAt = performance.now();
+    forwardedSessionResponseStarts.set(req, startedAt);
+    logForwardedSessionResponseStage("onRequest", req);
     reply.raw.once("finish", () => {
+      logForwardedSessionResponseStage("finish", req);
       logger.info(`[http-response] requestId=${requestId} method=${req.method} url=${req.url} ` +
         `responseMs=${(performance.now() - startedAt).toFixed(1)} status=${reply.statusCode} ` +
         `contentLength=${reply.raw.getHeader("content-length") ?? "unknown"}`);
     });
     reply.raw.once("close", () => {
       if (!reply.raw.writableFinished) {
+        logForwardedSessionResponseStage("close", req);
         logger.warn(`[http-response] requestId=${requestId} method=${req.method} url=${req.url} ` +
           `closedMs=${(performance.now() - startedAt).toFixed(1)} status=${reply.statusCode}`);
       }
     });
   });
+  app.addHook("preSerialization", async (req, _reply, payload) => {
+    logForwardedSessionResponseStage("preSerialization", req);
+    return payload;
+  });
+  app.addHook("onSend", async (req, _reply, payload) => {
+    logForwardedSessionResponseStage("onSend", req);
+    return payload;
+  });
 
   const sourceRegistry = createSourceRegistry(200);
   // The torrent runs on its own thread. Profiling a live seek (2026-08-02)
@@ -687,8 +708,13 @@ export async function startProxyServer({
       const waiting = new Set();
       const turn = takeTurns();
       // ONLY THE SEGMENTS WHOSE RANGES ARE NOT KNOWN are worked out, in the
-      // order the swarm is to fetch them.
+      // order the swarm is to fetch them. Range resolution can use either a
+      // direct source index or the fallback reads below; yield between zones
+      // in both cases so a large map cannot hold the main thread across its
+      // full projection.
       for (const zone of projection.unresolved()) {
+        if (!map.isCurrent()) return [];
+        await turn();
         if (!map.isCurrent()) return [];
         const reader = readers.get(zone.outputKey);
         if (!reader) continue;
@@ -743,14 +769,7 @@ export async function startProxyServer({
             waiting.add(zone.outputKey);
             continue;
           }
-          // The pass shares the thread in equal turns (`takeTurns`): in one
-          // stretch the first pass over a film's 4000 zones held the main thread
-          // for all of its work, and handed back after every zone it took
-          // 14.7-22 s while the start forecast waited for it. 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);
-          if (await turn() && !map.isCurrent()) return [];
           if (value?.kind === "result") {
             convert(value.ranges);
             continue;

package/services/transport/data-channel-handler.js

@@ -1182,6 +1182,13 @@ export function createDataChannelHandler({
     // route to return a response — e.g. long-polling until an HLS segment is
     // finalized by ffmpeg) vs. the body transfer over the data channel.
     const fetchStartedAt = Date.now();
+    const traceSessionResponse = method === "POST" && path === "/api/transcode-sessions" &&
+      typeof requestId === "string";
+    const fetchStartedAtMonotonic = traceSessionResponse ? performance.now() : null;
+    if (traceSessionResponse) {
+      log(`[forecast-http] stage=local-fetch-start requestId=${requestId} ` +
+        `atMs=${fetchStartedAtMonotonic.toFixed(3)}`);
+    }
     try {
       response = await fetch(targetUrl, {
         method,
@@ -1197,6 +1204,12 @@ export function createDataChannelHandler({
       send(channel, { type: "response-error", requestId, error: fetchError?.message ?? String(fetchError) });
       return;
     }
+    if (traceSessionResponse) {
+      const headersAt = performance.now();
+      log(`[forecast-http] stage=local-fetch-headers requestId=${requestId} ` +
+        `atMs=${headersAt.toFixed(3)} elapsedMs=${(headersAt - fetchStartedAtMonotonic).toFixed(3)} ` +
+        `status=${response.status}`);
+    }
 
     if (response.status !== 200 && response.status !== 206) {
       log(`[dc] ${method} ${path}${queryInfo} → ${response.status}`);