@torrent-tv/proxy 2.106.0 → 2.107.0

package/package.json

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

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 => {

package/services/encode/Renditions.js

@@ -2219,60 +2219,78 @@ export class Renditions {
       this.#host.outputs.touch(already);
       return already;
     }
-    const rendition = await this.#host.createOrGetSession({
-      sourceKey: base.file.sourceKey,
-      fileIndex: base.file.fileIndex,
-      // No picture at all: the video flag says what to do with a video stream
-      // this output does not carry.
-      transcodeVideo: false,
-      transcodeAudio,
-      fileName: base.file.name,
-      // Opened by nobody in particular, as a step is.
-      consumerId: "",
-      audioTrackIndex: trackIndex,
-      audioOnly: true,
-      // Where the viewer is, so the rendition starts with the picture rather
-      // than at the beginning of the file. Read the same way a quality variant
-      // reads it: the base's own field is only written by a seek or by a
-      // segment IT served, so on a resume-from-position open it is still unset
-      // while the player is asking for segment #537 — and the audio would begin
-      // at zero and never catch up, since nothing treats a far request as a
-      // seek. The accessor falls back to the last segment actually requested.
-      // Where the PICTURE is, not where it has been read to.
-      //
-      // The position this class keeps is written by the segments a session
-      // serves, so it is the READ head, and the viewer's picture sits behind it
-      // by everything the player has buffered. Started at the read head, the
-      // audio run begins AHEAD of the viewer, and every request they then make
-      // is behind a run that only moves forward — field 2026-08-15, placed at
-      // #16 while the player asked for #10, and the audio arrived only after
-      // the encoder was dragged back.
-      //
-      // The distance is measured, not assumed: the browser reports how many
-      // seconds it holds ahead of the picture with every link report, so the
-      // playhead is one subtraction away. A stale report is no use — a viewer
-      // who seeked since then is somewhere else entirely — so an old one is
-      // ignored and the whole look-ahead is subtracted instead, which cannot
-      // leave the run ahead of them.
-      startPositionSeconds: this.#host.audioStartSecondsFor({
-        family: this.#host.outputs.familyOf(base),
-        openedAtSeconds: this.#host.encodeRuns.progressOf(base)?.startPositionSeconds,
-        segmentSeconds: this.#host.segmentDurationSec
-      }),
-      segmentFormatId: base.segmentFormat.id,
-      // Cut where the picture is cut. Two streams meant to be played together
-      // have to be divided at the same times, and the grid is the base's — the
-      // table as it stands now, corrections included. A base on the uniform
-      // grid passes nothing: the rendition computes the same even grid from the
-      // same duration.
-      inheritedGrid: base.timeline.cutGrid === "keyframe"
-        ? {
-            boundaries: base.timeline.boundaries,
-            published: base.timeline.published
-          }
-        : null
-    });
-    return rendition ?? null;
+    const waitStartedAt = performance.now();
+    const waitFields = {
+      process: "P6.a",
+      baseSessionId: base.id,
+      trackIndex,
+      consumerId,
+      audioMode: transcodeAudio ? "transcode" : "copy"
+    };
+    this.#host.observeWait?.(base.file.sourceKey, "process", { ...waitFields, phase: "begin", at: waitStartedAt });
+    let waitOutcome = "error";
+    try {
+      const rendition = await this.#host.createOrGetSession({
+        sourceKey: base.file.sourceKey,
+        fileIndex: base.file.fileIndex,
+        // No picture at all: the video flag says what to do with a video stream
+        // this output does not carry.
+        transcodeVideo: false,
+        transcodeAudio,
+        fileName: base.file.name,
+        // Opened by nobody in particular, as a step is.
+        consumerId: "",
+        audioTrackIndex: trackIndex,
+        audioOnly: true,
+        // Where the viewer is, so the rendition starts with the picture rather
+        // than at the beginning of the file. Read the same way a quality variant
+        // reads it: the base's own field is only written by a seek or by a
+        // segment IT served, so on a resume-from-position open it is still unset
+        // while the player is asking for segment #537 — and the audio would begin
+        // at zero and never catch up, since nothing treats a far request as a
+        // seek. The accessor falls back to the last segment actually requested.
+        // Where the PICTURE is, not where it has been read to.
+        //
+        // The position this class keeps is written by the segments a session
+        // serves, so it is the READ head, and the viewer's picture sits behind it
+        // by everything the player has buffered. Started at the read head, the
+        // audio run begins AHEAD of the viewer, and every request they then make
+        // is behind a run that only moves forward — field 2026-08-15, placed at
+        // #16 while the player asked for #10, and the audio arrived only after
+        // the encoder was dragged back.
+        //
+        // The distance is measured, not assumed: the browser reports how many
+        // seconds it holds ahead of the picture with every link report, so the
+        // playhead is one subtraction away. A stale report is no use — a viewer
+        // who seeked since then is somewhere else entirely — so an old one is
+        // ignored and the whole look-ahead is subtracted instead, which cannot
+        // leave the run ahead of them.
+        startPositionSeconds: this.#host.audioStartSecondsFor({
+          family: this.#host.outputs.familyOf(base),
+          openedAtSeconds: this.#host.encodeRuns.progressOf(base)?.startPositionSeconds,
+          segmentSeconds: this.#host.segmentDurationSec
+        }),
+        segmentFormatId: base.segmentFormat.id,
+        // Cut where the picture is cut. Two streams meant to be played together
+        // have to be divided at the same times, and the grid is the base's — the
+        // table as it stands now, corrections included. A base on the uniform
+        // grid passes nothing: the rendition computes the same even grid from the
+        // same duration.
+        inheritedGrid: base.timeline.cutGrid === "keyframe"
+          ? {
+              boundaries: base.timeline.boundaries,
+              published: base.timeline.published
+            }
+          : null
+      });
+      waitOutcome = rendition ? "opened" : "unavailable";
+      return rendition ?? null;
+    } finally {
+      const waitEndedAt = performance.now();
+      this.#host.observeWait?.(base.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;