@torrent-tv/proxy 2.105.13 → 2.106.1

package/package.json

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

package/routes/api/playback-plan/post.js

@@ -24,7 +24,7 @@ function getPayload(body) {
   return {};
 }
 
-export async function handleApiPlaybackPlanPost(req, reply, { playbackPlanner, sourceRegistry, torrentPool, ffmpegBin, localBaseUrl, viewers }) {
+export async function handleApiPlaybackPlanPost(req, reply, { playbackPlanner, sourceRegistry, torrentPool, ffmpegBin, localBaseUrl, viewers, observeWait }) {
   const payload = getPayload(req.body);
   const sourceKey = typeof payload.sourceKey === "string" ? payload.sourceKey.trim() : "";
   const fileIndex = Number(payload.fileIndex);
@@ -38,10 +38,13 @@ export async function handleApiPlaybackPlanPost(req, reply, { playbackPlanner, s
   if (typeof payload.positionSeconds === "number" && Number.isFinite(payload.positionSeconds) && payload.positionSeconds >= 0) selection.positionSeconds = payload.positionSeconds;
   if (typeof payload.wantsToPlay === "boolean") selection.wantsToPlay = payload.wantsToPlay;
   if (consumerId) viewers?.selectsFile(consumerId, sourceKey, fileIndex, Date.now(), selection);
+  const startedAt = performance.now();
 
   // Interface delegates to PlaybackController (orchestrator + domain). Keeps route thin.
   const { PlaybackController } = await import("../../../services/server/controllers/PlaybackController.js");
   const controller = new PlaybackController({ torrentPool, sourceRegistry, ffmpegBin, localBaseUrl, playbackPlanner });
+  const waitFields = { process: "P3", sourceKey, fileIndex };
+  observeWait?.(sourceKey, "process", { ...waitFields, phase: "begin", at: startedAt });
   const cancellation = new AbortController();
   const aborted = () => cancellation.abort();
   const closed = () => { if (!reply.raw?.writableEnded) aborted(); };
@@ -52,8 +55,14 @@ export async function handleApiPlaybackPlanPost(req, reply, { playbackPlanner, s
     const params = { sourceKey, fileIndex, userAgent };
     const plan = payload.waitForReady === true
       ? await controller.getReadyPlan(params, { signal: cancellation.signal }) : await controller.getPlan(params);
+    const endedAt = performance.now();
+    observeWait?.(sourceKey, "process", { ...waitFields, phase: "end", at: endedAt, startedAt,
+      endedAt, durationMs: endedAt - startedAt, outcome: "plan-ready" });
     return reply.send(plan);
   } catch (error) {
+    const endedAt = performance.now();
+    observeWait?.(sourceKey, "process", { ...waitFields, phase: "end", at: endedAt, startedAt,
+      endedAt, durationMs: endedAt - startedAt, outcome: cancellation.signal.aborted ? "cancelled" : "error" });
     if (cancellation.signal.aborted) return;
     if (error instanceof Error && error.code === "SOURCE_NOT_FOUND") {
       return reply.code(404).send({ error: error.message });

package/server.js

@@ -23,6 +23,7 @@ import { trackChoicesOf } from "./services/viewer/segment-demands.js";
 import { PlaybackProjection } from "./services/torrent/PlaybackProjection.js";
 import { SegmentInputTable } from "./services/viewer/segment-input-table.js";
 import { SourcePreparation, preparationInterval } from "./services/viewer/SourcePreparation.js";
+import { publishPlaybackBeforePreparationRefresh } from "./services/server/publish-playback-before-preparation-refresh.js";
 import { handleHealthzGet } from "./routes/healthz/get.js";
 import { handleApiDeliverySinkGet } from "./routes/api/delivery-sink/get.js";
 import { handleApiLinkProbeGet } from "./routes/api/link-probe/get.js";
@@ -1213,7 +1214,6 @@ export async function startProxyServer({
     setDownloadRate: (bytesPerSecond, because) => torrentPool.setDownloadRate?.(bytesPerSecond, because),
     setSpeculativeHold: (held, because) => torrentPool.setSpeculativeHold?.(held, because),
     setPriorityMap: async ({ sourceKey, fileIndex, durationSeconds, zones }) => {
-      void sourcePreparation?.refresh();
       const record = sourceRegistry.get(sourceKey);
       if (!record) {
         return;
@@ -1224,9 +1224,13 @@ export async function startProxyServer({
           if (!outputParts.viewers.forSource(sourceKey).length) probeReads.forget(sourceKey, fileIndex);
           await downloadMaps.forget(sourceKey, fileIndex, { keepPreparation: true });
           playbackProjections.get(`${sourceKey}:${fileIndex}`)?.clear();
+          void sourcePreparation?.refresh();
           return;
         }
-        await downloadMaps.playback({ sourceKey, fileIndex, durationSeconds, zones });
+        await publishPlaybackBeforePreparationRefresh(
+          () => downloadMaps.playback({ sourceKey, fileIndex, durationSeconds, zones }),
+          () => { void sourcePreparation?.refresh(); }
+        );
         mediaReads.retain(sourceKey, fileIndex, params => !params.requestId?.startsWith("download:") ||
           zones.some(zone => zone.from === params.downloadInterval?.from && zone.to === params.downloadInterval?.to));
       } catch (error) {
@@ -1375,6 +1379,7 @@ export async function startProxyServer({
       const held = await torrentPool.heldRangesOf(torrent, work.fileIndex);
       return work.inputRanges.every(([start, end]) => held.some(([from, to]) => from <= start && to >= end));
     },
+    playbackAppliedFor: (sourceKey, fileIndex) => downloadMaps.hasAppliedPlayback(sourceKey, fileIndex),
     readyChanged: (work, ready) => logger.info(`source urgent request=${work.requestId} viewer=${work.ownerId} ` +
       `source=${work.sourceKey} file=${work.fileIndex} inputReady=${ready}`),
     inspect: async work => {
@@ -1614,7 +1619,8 @@ export async function startProxyServer({
     handleApiClientLogsPost(req, reply, { clientLogs, viewerRequests: outputParts.viewerRequests })
   );
   app.post("/api/playback-plan", async (req, reply) =>
-    handleApiPlaybackPlanPost(req, reply, { playbackPlanner, viewers: outputParts.viewers })
+    handleApiPlaybackPlanPost(req, reply, { playbackPlanner, viewers: outputParts.viewers,
+      observeWait: (sourceKey, event, fields) => waitTrace.source(sourceKey, event, fields) })
   );
   app.post("/api/playback-plan/audio-tracks", async (req, reply) =>
     handleApiPlaybackPlanAudioTracksPost(req, reply, { playbackPlanner })

package/services/encode/EncodeRuns.js

@@ -1234,7 +1234,21 @@ export class EncodeRuns {
         if (mediaRanges === false && tentative) return null;
         if (mediaRanges === false) throw Object.assign(new Error(`Closed piece #${index} has incomplete media.`),
           { code: "ERR_INCOMPLETE_MEDIA" });
-        const published = this.#host.segmentFiles.publish(address, name, session.segmentFormat, { mediaRanges, bytes });
+        const publishStartedAt = performance.now();
+        const publishProcess = session.spec?.carries === "audio-only" ? "P11.a" : "P11.v";
+        this.#host.observeWait?.(session.file.sourceKey, "process", { process: publishProcess, phase: "begin",
+          output: address, segment: index, at: publishStartedAt });
+        let published;
+        let publishOutcome = "error";
+        try {
+          published = this.#host.segmentFiles.publish(address, name, session.segmentFormat, { mediaRanges, bytes });
+          publishOutcome = published ? "published" : "not-published";
+        } finally {
+          const publishEndedAt = performance.now();
+          this.#host.observeWait?.(session.file.sourceKey, "process", { process: publishProcess, phase: "end",
+            output: address, segment: index, at: publishEndedAt, startedAt: publishStartedAt, endedAt: publishEndedAt,
+            durationMs: publishEndedAt - publishStartedAt, outcome: publishOutcome });
+        }
         if (!published) throw new Error(`Closed piece #${index} could not be stored.`);
         if (index === safeIndex) this.#host.observeWait?.(session.file.sourceKey, "first-piece-published", {
           output: address, segment: index, startedAt: observedStart, endedAt: performance.now(),

package/services/server/ViewerRequests.js

@@ -865,6 +865,11 @@ export class ViewerRequests {
   }
 
   async #playbackReadinessFor(session, consumerId, progress, outputMbps) {
+    const waitStartedAt = performance.now();
+    const waitFields = { process: "P14", sessionId: session.id, consumerId };
+    this.#host.observeWait?.(session.file.sourceKey, "process", { ...waitFields, phase: "begin", at: waitStartedAt });
+    let waitOutcome = "error";
+    try {
     const now = Date.now();
     // WHERE AN ANSWER'S TIME GOES, said with each answer. On Home Assistant a
     // held viewer's answer took 11.2 s while its forecast took 0.1-0.4 s and
@@ -1116,7 +1121,14 @@ export class ViewerRequests {
     this.#host.noteViewerWaiting?.(consumerId || session.id,
       holding?.kind === "production" ? { address: holding.track, index: holding.segment } : null);
     delete forecast.firstRequiredStages;
+    waitOutcome = "forecast-ready";
     return forecast;
+    } finally {
+      const waitEndedAt = performance.now();
+      this.#host.observeWait?.(session.file.sourceKey, "process", { ...waitFields, phase: "end", at: waitEndedAt,
+        startedAt: waitStartedAt, endedAt: waitEndedAt, durationMs: waitEndedAt - waitStartedAt,
+        outcome: waitOutcome });
+    }
   }
 
   /**

package/services/server/publish-playback-before-preparation-refresh.js

@@ -0,0 +1,11 @@
+/**
+ * Keep source preparation stated until the viewer's playback map is applied.
+ *
+ * @param {() => Promise<unknown>} publishPlayback
+ * @param {() => unknown} refreshPreparation
+ * @returns {Promise<void>}
+ */
+export async function publishPlaybackBeforePreparationRefresh(publishPlayback, refreshPreparation) {
+  await publishPlayback();
+  refreshPreparation();
+}

package/services/viewer/DownloadMaps.js

@@ -162,6 +162,11 @@ export class DownloadMaps {
     return this.#files.get(`${sourceKey}:${fileIndex}`)?.epoch ?? 0;
   }
 
+  hasAppliedPlayback(sourceKey, fileIndex) {
+    const file = this.#files.get(`${sourceKey}:${fileIndex}`);
+    return Boolean(file?.zones.length && file.shape && file.appliedShape === file.shape);
+  }
+
   native({ sourceKey, fileIndex, zones }) {
     const file = this.#file(sourceKey, fileIndex);
     file.nativeZones = zones;
@@ -325,7 +330,12 @@ export class DownloadMaps {
         const answeredAt = this.#clock();
         // A torrent not yet in the thread applies nothing, so this map was not
         // delivered and the next one, however alike, has to be.
-        if (reply?.appliedMs === null && file.shape === shape) file.shape = null;
+        if (reply?.appliedMs === null) {
+          if (file.shape === shape) file.shape = null;
+          if (file.appliedShape === shape) file.appliedShape = null;
+        } else {
+          file.appliedShape = shape;
+        }
         // The window open now, which a report since this map was asked for may have started.
         const stats = this.#statsOf(file);
         stats.sent += 1;
@@ -345,6 +355,7 @@ export class DownloadMaps {
     // sent, and leaves nothing to compare the next one against.
     file.pending = pending.catch(() => {
       if (file.shape === shape) file.shape = null;
+      if (file.appliedShape === shape) file.appliedShape = null;
     });
     return pending;
   }

package/services/viewer/SourcePreparation.js

@@ -38,6 +38,7 @@ export class SourcePreparation {
   #reprice;
   #inputReady;
   #readyChanged;
+  #playbackAppliedFor;
   #work = new Map();
   #revision = 0;
   #completedRevision = null;
@@ -45,7 +46,8 @@ export class SourcePreparation {
   #candidateAbort = new AbortController();
 
   constructor({ viewers, candidatesFor, relatedFilesFor = () => [], priorityFor = (_viewer, priority) => priority,
-    inputReady = async () => false, readyChanged = () => {}, inspect, withdraw, reprice = () => {}, failed }) {
+    inputReady = async () => false, readyChanged = () => {}, playbackAppliedFor = () => true,
+    inspect, withdraw, reprice = () => {}, failed }) {
     this.#viewers = viewers;
     this.#candidates = candidatesFor;
     this.#related = relatedFilesFor;
@@ -56,6 +58,7 @@ export class SourcePreparation {
     this.#reprice = reprice;
     this.#inputReady = inputReady;
     this.#readyChanged = readyChanged;
+    this.#playbackAppliedFor = playbackAppliedFor;
   }
 
   refresh() {
@@ -80,8 +83,13 @@ export class SourcePreparation {
 
   /** Current owners determine priority; old work never restores a withdrawn read. */
   demandFor(work) {
+    const handoffFileIndex = work.selected || (work.role === "source-rest" && work.ownerFileIndex === work.fileIndex)
+      ? work.fileIndex : null;
+    const opening = Number.isInteger(handoffFileIndex) && this.#viewers.forSource(work.sourceKey).some(viewer =>
+      (work.ownerId === undefined || viewer.id === work.ownerId) && viewer.source.selectedFileIndex === handoffFileIndex &&
+      viewer.outputs.size > 0 && !this.#playbackAppliedFor(work.sourceKey, handoffFileIndex));
     if (work.selected && work.statement === "packets" &&
-      work.positions !== this.#positionsFor(work.sourceKey, work.fileIndex, work.ownerId)) return null;
+      work.positions !== this.#positionsFor(work.sourceKey, work.fileIndex, work.ownerId, opening)) return null;
     if (work.role === "subtitle-embedded" && ["packets", "subtitle-cues"].includes(work.statement) &&
       work.positions !== this.#positionsFor(work.sourceKey, work.fileIndex, work.ownerId, true)) return null;
     const owners = this.#viewers.forSource(work.sourceKey).filter(viewer => {
@@ -90,9 +98,9 @@ export class SourcePreparation {
         viewer.subtitle.trackIndex !== work.trackIndex)) return false;
       const selected = viewer.source.selectedFileIndex;
       if (work.ownerFileIndex !== undefined) return selected === work.ownerFileIndex &&
-        (work.role !== "source-rest" || viewer.outputs.size === 0);
+        (work.role !== "source-rest" || viewer.outputs.size === 0 || opening);
       if (work.statement !== "packets") return selected === null || selected === work.fileIndex;
-      if (selected !== null) return selected === work.fileIndex && viewer.outputs.size === 0 && work.selected;
+      if (selected !== null) return selected === work.fileIndex && (viewer.outputs.size === 0 || opening) && work.selected;
       return !work.selected && viewer.source.visibleFileIndices.includes(work.fileIndex);
     });
     if (!owners.length) return null;

package/utils/wait-trace.js

@@ -53,8 +53,9 @@ export class SourceWaitTrace {
         !Number.isSafeInteger(attempt) || attempt < 0) return;
       const context = { wait, attempt, operation, startedAt: this.now() };
       this.requests.set(req, context);
-      const process = typeof statedProcess === "string" && /^[A-Z][0-9]+(?:\.(?:[0-9]+[a-z]?|[va]))?$/.test(statedProcess)
-        ? statedProcess : processForRequest(req.url);
+      const endpointProcess = processForRequest(req.url);
+      const process = endpointProcess ?? (typeof statedProcess === "string" &&
+        /^[A-Z][0-9]+(?:\.(?:[0-9]+[a-z]?|[va]))?$/.test(statedProcess) ? statedProcess : null);
       this.write(context, "http-start", { process, phase: "begin", method: req.method, path: req.url,
         requestId: req.headers["x-ttv-forwarded-request-id"] ?? req.id });
       let finished = false;
@@ -92,11 +93,11 @@ export class SourceWaitTrace {
 }
 
 function processForRequest(path) {
+  if (/^\/api\/transcode-sessions\/[^/?]+\/progress(?:\?|$)/.test(path)) return "P14";
   if (path.startsWith("/api/transcode-sessions")) return "P6.v";
   if (path.startsWith("/api/playback-plan")) return "P3";
   if (/\/transcode\/.*\.m3u8(?:\?|$)/.test(path)) return "P12";
   if (/\/transcode\/.*(?:init|\.mp4)(?:\?|$)/.test(path)) return "P12";
   if (/\/transcode\/.*(?:\.m4s|\.ts)(?:\?|$)/.test(path)) return "P12";
-  if (path.startsWith("/api/session-progress")) return "P14";
   return null;
 }