@torrent-tv/proxy 2.107.35 → 2.107.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.107.35",
+  "version": "2.107.37",
   "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/viewer/DownloadMaps.js

@@ -286,19 +286,30 @@ export class DownloadMaps {
   viewersChanged() {
     const sent = [];
     for (const file of this.#files.values()) {
-      const own = [...file.metadata].filter(([, metadata]) => metadata.owner === "file");
-      if (own.length === 0) continue;
-      const wanted = this.#fileWanted(file.sourceKey, file.fileIndex) === true;
-      if (file.ownReadsWanted === wanted) continue;
-      file.ownReadsWanted = wanted;
-      this.#log?.(`download map ${file.sourceKey}:${file.fileIndex}: ${own.length} read(s) of the file itself ` +
-        `${wanted ? "stated again — a viewer holds the file" : "withheld — no present viewer holds the file"} ` +
-        `[${own.map(([statement]) => statement).join(", ")}]`);
+      if (![...file.metadata.values()].some(metadata => metadata.owner === "file")) continue;
+      if (file.ownReadsWanted === (this.#fileWanted(file.sourceKey, file.fileIndex) === true)) continue;
       sent.push(this.#emit(file));
     }
     return Promise.all(sent);
   }
 
+  /**
+   * Whether a present viewer holds this file, decided where the map is built
+   * and said when it changes for a file that has reads of its own.
+   *
+   * @returns {boolean}
+   */
+  #ownReadsWanted(file) {
+    const wanted = this.#fileWanted(file.sourceKey, file.fileIndex) === true;
+    const own = [...file.metadata].filter(([, metadata]) => metadata.owner === "file").map(([statement]) => statement);
+    if (own.length && wanted !== file.ownReadsWanted && (file.ownReadsWanted !== undefined || !wanted)) {
+      this.#log?.(`download map ${file.sourceKey}:${file.fileIndex}: ${own.length} read(s) of the file itself ` +
+        `${wanted ? "stated again — a viewer holds the file" : "withheld — no present viewer holds the file"} [${own.join(", ")}]`);
+    }
+    file.ownReadsWanted = wanted;
+    return wanted;
+  }
+
   forget(sourceKey, fileIndex, { keepPreparation = false } = {}) {
     const file = this.#file(sourceKey, fileIndex);
     this.#setZones(file, []);
@@ -347,8 +358,7 @@ export class DownloadMaps {
     // Compared and sent as the torrent is to act on it: the playback zones
     // packed into as few windows as say the same (`coalescedZones`).
     const zones = [...this.#packedPlayback(file)];
-    const ownReadsWanted = this.#fileWanted(file.sourceKey, file.fileIndex) === true;
-    file.ownReadsWanted = ownReadsWanted;
+    const ownReadsWanted = this.#ownReadsWanted(file);
     for (const { ranges, requestId, priority, urgent, deadlineAt, order, owner } of file.metadata.values()) {
       if (owner === "file" && !ownReadsWanted) continue;
       for (const [byteStart, byteEnd] of ranges) {