@torrent-tv/proxy 2.107.36 → 2.107.38

package/package.json

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

package/services/encode/output/Timeline.js

@@ -125,7 +125,10 @@ export class Timeline {
     const shift = sourceStartTime - (base ?? 0);
     return {
       from: from === null ? this.publishedStartOf(fromIndex) + sourceStartTime : from + shift,
-      to: to === null ? this.publishedStartOf(toIndex + 1) + sourceStartTime : to + shift
+      to: to === null ? this.publishedStartOf(toIndex + 1) + sourceStartTime : to + shift,
+      // The last piece ends where the source does, wherever its declared
+      // duration lands against the frames (`PacketIndex.inputFor`).
+      ...(toIndex === this.segmentCount - 1 ? { endsWithSource: true } : {})
     };
   }
 

package/services/media/SegmentInputs.js

@@ -11,12 +11,13 @@ export class SegmentInputs {
     this.#tracks = tracks;
   }
 
-  forInterval({ from, to, tracks = this.#tracks, mode = "transcode" }) {
+  forInterval({ from, to, tracks = this.#tracks, mode = "transcode", endsWithSource = false }) {
     const packets = [];
     const ranges = [];
     for (const track of tracks) {
       if (!["audio", "video"].includes(track.type)) continue;
-      const input = this.#index.inputFor({ trackId: track.trackNumber, from, to, mode: typeof mode === "function" ? mode(track) : mode });
+      const input = this.#index.inputFor({ trackId: track.trackNumber, from, to,
+        mode: typeof mode === "function" ? mode(track) : mode, endsWithSource });
       if (input.kind !== "result") return { ...input, trackId: track.trackNumber };
       packets.push({ track, ...input });
       ranges.push(...input.ranges);

package/services/media/container/PacketIndex.js

@@ -175,8 +175,20 @@ export class PacketIndex {
     track.coveredThrough = seconds;
   }
 
-  /** The same calculation is used to order source bytes and admit an encode. */
-  inputFor({ trackId, from, to, mode = "transcode" }) {
+  /**
+   * The same calculation is used to order source bytes and admit an encode.
+   *
+   * `endsWithSource` says this is the output's last piece: it ends where the
+   * source ends, and a copy of it needs no keyframe at `to`. Its `to` is the
+   * file's declared duration, and the track's end, its last frame's start plus
+   * that frame's duration added in floating point, can land past it: 314.96 s
+   * declared, 314.88 + 0.04 = 314.96000000000004 indexed. Compared with that
+   * end, the last piece of a copied MP4 was refused, the viewer got HTTP 500 at
+   * the end of the film and reopening near the end was refused at once (Home
+   * Assistant 2026-10-26, `2026-08-03 QUICK RELIEF 0364 BY KARA_C.mp4`,
+   * torrent-tv/meta#239).
+   */
+  inputFor({ trackId, from, to, mode = "transcode", endsWithSource = false }) {
     this.flushPending();
     if (!["copy", "transcode"].includes(mode)) throw new TypeError("Unknown segment input mode.");
     if (!Number.isFinite(from) || !Number.isFinite(to) || from < 0 || to <= from) {
@@ -223,9 +235,13 @@ export class PacketIndex {
         : { kind: "needs-index", trackId, from: startAt, to };
       let endsAtKeyframe = false;
       if (mode === "copy") endsAtKeyframe = packets.someAtTime(to, index => packets.keyframeAt(index));
-      if (mode === "copy" && (packets.ptsAt(first) !== from ||
-        (!endsAtKeyframe && (!track.complete || to < this.boundsOf(trackId).end)))) {
-        return { kind: "terminal", reason: "video-copy-cut-is-not-a-keyframe" };
+      const reachesEnd = track.complete && (endsWithSource || to >= this.boundsOf(trackId).end);
+      if (mode === "copy" && (packets.ptsAt(first) !== from || (!endsAtKeyframe && !reachesEnd))) {
+        const bounds = track.complete ? this.boundsOf(trackId) : null;
+        return { kind: "terminal", reason: "video-copy-cut-is-not-a-keyframe",
+          message: `copy of ${from}..${to}${endsWithSource ? " (the last piece)" : ""} begins at the keyframe of ` +
+            `${packets.ptsAt(first)}, ${endsAtKeyframe ? "ends at a keyframe" : "ends at no keyframe"}; ` +
+            (bounds ? `the track ends at ${bounds.end}` : "the track is not indexed to its end yet") };
       }
     }
     // A transcoder needs the first audio packet at or after the cut to flush
@@ -248,7 +264,7 @@ export class PacketIndex {
       decodeFrom: packets.ptsAt(first),
       from,
       to,
-      ...(track.complete && to >= this.boundsOf(trackId).end ? { sourceEndSeconds: this.boundsOf(trackId).end } : {}),
+      ...(track.complete && (endsWithSource || to >= this.boundsOf(trackId).end) ? { sourceEndSeconds: this.boundsOf(trackId).end } : {}),
       packets: input
     };
   }

package/services/server/ViewerRequests.js

@@ -229,7 +229,18 @@ export class ViewerRequests {
       sourceObserved: true, waitElapsedMs });
     const featuresChanged = this.#recordEarlyWaitSnapshot(context, context.features);
     const elapsedMs = waitElapsedSince(context, waitElapsedMs);
-    const measuredWorkSeconds = processing.firstRequiredSegmentsSeconds;
+    // The wait ends when the start forecast lets the picture start, and the
+    // first required pieces being there is only part of that: a source
+    // supplied slower than the film plays is held until the cushion carries
+    // it to the end. Counted to the first pieces alone, the estimate reached
+    // zero with seven minutes still to wait, and the page had no time to show
+    // (Home Assistant 2026-10-26, Despicable Me 3 BDRemux at 0.53x,
+    // torrent-tv/meta#239).
+    const firstRequiredSeconds = processing.firstRequiredSegmentsSeconds;
+    const startGateSeconds = processing.startGateSeconds;
+    const measuredWorkSeconds = Number.isFinite(startGateSeconds) && startGateSeconds >= 0
+      ? Math.max(startGateSeconds, Number.isFinite(firstRequiredSeconds) ? firstRequiredSeconds : 0)
+      : firstRequiredSeconds;
     const hasActiveEstimate = Number.isFinite(measuredWorkSeconds) && measuredWorkSeconds >= 0;
     const stagesChanged = Array.isArray(processing.firstRequiredStages) &&
       JSON.stringify(processing.firstRequiredStages) !== JSON.stringify(context.activeFirstRequiredStages);
@@ -258,7 +269,8 @@ export class ViewerRequests {
     const seconds = earlyWaitRemainingSeconds(totalSeconds, elapsedMs);
     if (!Number.isFinite(seconds) || seconds < 0) return null;
     this.#logEarlyForecast(context, { elapsedMs, seconds, totalSeconds, historical,
-      firstRequiredSegmentsSeconds: hasActiveEstimate ? measuredWorkSeconds : context.activeFirstRequiredSegmentsSeconds,
+      firstRequiredSegmentsSeconds: hasActiveEstimate ? firstRequiredSeconds ?? null : context.activeFirstRequiredSegmentsSeconds,
+      startGateSeconds: hasActiveEstimate && Number.isFinite(startGateSeconds) ? startGateSeconds : null,
       firstRequiredStages: context.activeFirstRequiredStages });
     return { version: 1, waitId, revision: context.revision, remainingSeconds: seconds, ageMs: 0 };
   }
@@ -269,11 +281,14 @@ export class ViewerRequests {
   }
 
   #logEarlyForecast(context, { elapsedMs, seconds, totalSeconds, historical, firstRequiredSegmentsSeconds,
-    firstRequiredStages }) {
+    startGateSeconds = null, firstRequiredStages }) {
     if (context.loggedForecastRevision === context.revision) return;
-    const basis = Number.isFinite(firstRequiredSegmentsSeconds) ? "first-required" : "historical-stages";
-    const estimate = basis === "first-required"
-      ? { firstRequiredSegmentsSeconds, ...(Array.isArray(firstRequiredStages) ? { firstRequiredStages } : {}) }
+    const gated = Number.isFinite(startGateSeconds) &&
+      !(Number.isFinite(firstRequiredSegmentsSeconds) && firstRequiredSegmentsSeconds >= startGateSeconds);
+    const basis = gated ? "start-gate" : Number.isFinite(firstRequiredSegmentsSeconds) ? "first-required" : "historical-stages";
+    const estimate = basis !== "historical-stages"
+      ? { firstRequiredSegmentsSeconds, ...(Number.isFinite(startGateSeconds) ? { startGateSeconds } : {}),
+        ...(Array.isArray(firstRequiredStages) ? { firstRequiredStages } : {}) }
       : { stagesMs: historical?.stagesMs ?? null, observations: historical?.observations ?? null };
     logger.info(`early wait forecast ${JSON.stringify({ waitId: context.waitId, consumer: context.consumerId,
       generation: context.generation, features: context.features, elapsedMs, revision: context.revision,
@@ -1121,6 +1136,10 @@ export class ViewerRequests {
           videoSpeedX: videoOperation?.speed,
           audioSpeedX: audioOperation?.speed,
           firstRequiredSegmentsSeconds: forecast.firstRequiredSegmentsSeconds,
+          // When the start forecast lets the picture start: its delay while
+          // it holds the start, and nothing to add once it does not.
+          ...(forecast.ready !== true && Number.isFinite(forecast.delaySeconds)
+            ? { startGateSeconds: forecast.delaySeconds } : {}),
           firstRequiredStages: forecast.firstRequiredStages
         } });
       if (waitEstimate) forecast.waitEstimate = waitEstimate;