@torrent-tv/proxy 2.107.23 → 2.107.25

package/package.json

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

package/server.js

@@ -73,7 +73,6 @@ import { nativeSourceMap, nativeOriginalSourceMap } from "./services/viewer/Nati
 import { MediaReadRequests } from "./services/media/MediaReadRequests.js";
 import { SegmentInputs } from "./services/media/SegmentInputs.js";
 import { directSegmentInput } from "./services/media/direct-segment-input.js";
-import { piecesRunPastEnd } from "./services/encode/output/Timeline.js";
 import { ContainerTrack } from "./services/media/tracks/ContainerTrack.js";
 import { pauseCoefficient, viewerStartsOn } from "./services/viewer/PriorityMap.js";
 import { coalescing } from "./utils/coalesce.js";
@@ -717,9 +716,9 @@ export async function startProxyServer({
         const revision = outputParts.segmentStore.revisionOf(output.outputKey);
         const links = consumers.map(viewer => viewer.linkReading()?.linkMbps)
           .filter(value => Number.isFinite(value) && value > 0);
-        // A piece copying a stream answers for the second its end falls in,
-        // as the encode plan reads it (`piecesRunPastEnd`).
-        played.push({ outputKey: output.outputKey, grid, runsPastEnd: piecesRunPastEnd(output.spec),
+        // Every piece answers for its exact ending boundary, as the encode
+        // plan reads it: the player may request the preceding piece there.
+        played.push({ outputKey: output.outputKey, grid,
           encodeSpeed: outputParts.encodeCost.latestSpeedReadingOf(output)?.speed,
           bytesPerSecond: bytesPerSecondOf(output, revision), linkMbps: links.length ? Math.min(...links) : null,
           readyRevision: revision, ready: () => outputParts.segmentStore.sizesOf(output.outputKey),

package/services/encode/EncodeRuns.js

@@ -26,7 +26,6 @@ import { cutOf, cutShiftOf, judgeNeighbors, judgePiece, leadingSecondsOf, lacksO
 import { leadingPictures, presentationSegment } from "./segment-formats/presentation-segment.js";
 import { InputFailures, failedAdmittedInput } from "./InputFailures.js";
 import { readProcessCpuSeconds } from "./host-load.js";
-import { piecesRunPastEnd } from "./output/Timeline.js";
 
 
 /**
@@ -616,13 +615,11 @@ export class EncodeRuns {
     // each: 454 pieces against 401 on the field file.
     for (const [address, sessions] of byOutput) {
       const timeline = sessions[0].timeline;
-      const spec = sessions[0].spec;
       this.#host.encodeOrchestrator.notePriorityMap(
         address,
         timeline?.inSegments?.(
           this.#host.priority.mapForOutput(address),
-          Number(timeline?.segmentCount) || 0,
-          { runsPastEnd: piecesRunPastEnd(spec) }
+          Number(timeline?.segmentCount) || 0
         ) ?? []
       );
     }

package/services/encode/output/Timeline.js

@@ -42,32 +42,6 @@
  * reveal where the file's cuts really are.
  */
 
-/**
- * Whether an output's pieces may hold a little past their published end: a
- * piece ends at the first frame boundary at or after it, and the player places
- * the next piece where this one truly ends (hls.js `updateFragPTSDTS`). A
- * viewer standing at a published edge is then asked for by the piece BEFORE
- * it. True of a copied picture, whose pieces end at a packet, and of sound
- * however it is made: copied sound ends at a packet, and encoded sound at a
- * frame of the encoder — 1024 samples of AAC, 21.3 ms at 48 kHz. Only a
- * re-encoded picture, given a keyframe at every cut, ends where it is published.
- *
- * Field 2026-10-09, MP3 copied out of an AVI: a seek to 4000 s asked for the
- * piece ending at 4000 s. Field r43 (Home Assistant, 2026-10-15), a copied
- * Matroska picture: a seek to 1000.000 s, the published start of #96, asked for
- * #95 on both tracks; the picture's pieces were not counted as copies, nothing
- * made #95, and the picture stood 131 s until the viewer moved. With the
- * picture counted (r44), its #95 was made in 6.4 s and the soundtrack's, AAC
- * encoded from the film (`its muxer counts cuts -0.021333s`), was still not
- * made (torrent-tv/meta#178).
- *
- * @param {{ video?: object | null, audio?: object | null, transcodesVideo?: boolean, transcodesAudio?: boolean } | null | undefined} spec
- * @returns {boolean}
- */
-export function piecesRunPastEnd(spec) {
-  return (Boolean(spec?.video) && spec.transcodesVideo !== true) || Boolean(spec?.audio);
-}
-
 export class Timeline {
   /**
    * @param {object} params
@@ -185,13 +159,10 @@ export class Timeline {
    * @param {import("../../viewer/PriorityMap.js").PriorityMap} map - What every
    *   viewer of this output wants, in seconds of film.
    * @param {number} segmentCount - How many pieces this output has.
-   * @param {{ runsPastEnd?: boolean }} [shape] - `runsPastEnd`: the output's
-   *   pieces copy a stream, which is cut where its packets end, so a piece
-   *   holds sound past its published end by up to one packet.
    * @returns {import("../../viewer/PriorityMap.js").DemandZone[]} Runs of pieces
    *   that agree. Empty where nothing is stated, which says nobody is coming.
    */
-  inSegments(map, segmentCount, { runsPastEnd = false } = {}) {
+  inSegments(map, segmentCount) {
     if (!(segmentCount > 0) || !map || !(map.durationSeconds > 0)) {
       return [];
     }
@@ -202,17 +173,16 @@ export class Timeline {
       // whole, so it is wanted as soon as the soonest second inside it is
       // wanted — and the piece a viewer is standing in the middle of is wanted
       // exactly as much as the second under their feet.
-      // A COPIED PIECE ALSO HOLDS THE SECOND ITS END FALLS IN. A copy ends at
-      // the first packet boundary at or after its published end, and the
-      // player places the next piece where this one truly ends (hls.js
-      // `updateFragPTSDTS` carries a parsed piece's end to every later one).
-      // Field 2026-10-09, MP3 copied out of an AVI on a 4 s grid: pieces ended
-      // up to 24 ms late, and a seek to 4000 s asked for the piece ending at
-      // 4000 s, which nothing made because second 4000 belonged to the next.
+      // A PIECE ALSO HOLDS THE SECOND ITS END FALLS IN. At an exact playlist
+      // boundary hls.js may request the fragment ending there before it asks
+      // for the one beginning there. Excluding that second from this piece can
+      // leave the request waiting while the plan starts at the following one.
+      // Copied streams also run past their published end by up to one packet,
+      // and hls.js carries that parsed end to every later piece.
       const from = Math.max(0, Math.floor(this.publishedStartOf(index)));
       const end = this.publishedStartOf(index + 1);
       const until = index + 1 < segmentCount
-        ? Math.max(from + 1, runsPastEnd ? Math.floor(end) + 1 : Math.ceil(end))
+        ? Math.max(from + 1, Math.floor(end) + 1)
         : map.durationSeconds;
       // Asked of the map for the piece's seconds as a whole, not second by
       // second: a walk of every second of the film for every output on every

package/services/server/ViewerRequests.js

@@ -1282,8 +1282,11 @@ export class ViewerRequests {
       const ranges = inventory.has(index) ? this.#host.encodeRuns.finishedMediaRangesOf(output, index) : undefined;
       const mediaRanges = ranges && output.segmentFormat?.servedMediaRanges ?
         output.segmentFormat.servedMediaRanges(ranges, { initBytes: sessionInit }) : undefined;
+      // At a playlist boundary the player can request the fragment ending
+      // exactly at its seek target. It is work needed to reach the target,
+      // even though it adds no media after the viewer's position.
       if (index !== 0 && mediaRanges === undefined && !inventory.has(index) &&
-        Number.isFinite(endSeconds) && Number.isFinite(positionSeconds) && endSeconds <= positionSeconds) {
+        Number.isFinite(endSeconds) && Number.isFinite(positionSeconds) && endSeconds < positionSeconds) {
         continue;
       }
       const startSeconds = timeline.publishedStartOf(index);

package/services/torrent/PlaybackProjection.js

@@ -273,10 +273,9 @@ class Segment {
     this.from = from;
     this.to = to;
     /**
-     * Up to which second the map's zones are read for it: its end, and for a
-     * piece that copies a stream the second its end falls in as well, as the
-     * encode plan reads it (`Timeline.inSegments`): the player asks a viewer
-     * standing at its end for this piece, and its bytes are fetched for them.
+     * Up to which second the map's zones are read for it: its end and the exact
+     * end boundary. The encode plan includes that boundary for every output,
+     * since the player may request the piece ending there before the next one.
      */
     this.reach = reach;
     /** Whether a zone of the map overlaps it. */
@@ -311,16 +310,15 @@ class Segment {
 
 /** One output: its grid, how long its segments take to make and deliver, what is made, and its next input. */
 class OutputState {
-  constructor(outputKey, grid, runsPastEnd = false) {
+  constructor(outputKey, grid) {
     this.outputKey = outputKey;
     this.grid = grid;
-    this.runsPastEnd = runsPastEnd;
     /** @type {Segment[]} */
     this.segments = [];
     for (let index = 0; index + 1 < grid.length; index++) {
       const end = grid[index + 1];
       this.segments.push(new Segment(this, index, grid[index], end,
-        runsPastEnd && index + 2 < grid.length ? Math.max(end, Math.floor(end) + 1) : end));
+        index + 2 < grid.length ? Math.max(end, Math.floor(end) + 1) : end));
     }
     this.encodeSpeed = undefined;
     this.bytesPerSecond = undefined;
@@ -380,7 +378,7 @@ export class PlaybackProjection {
    * @param {object} params
    * @param {Array<{ from: number, to: number, priority: number, urgent?: boolean, behind?: boolean, deferred?: boolean,
    *   deadlineAt?: number }>} params.zones - The file's map zones, deadlines as instants.
-   * @param {Array<{ outputKey: string, grid: number[], runsPastEnd?: boolean, encodeSpeed?: number, bytesPerSecond?: number | null,
+   * @param {Array<{ outputKey: string, grid: number[], encodeSpeed?: number, bytesPerSecond?: number | null,
    *   linkMbps?: number | null, readyRevision: unknown, ready: () => Map<number, number>,
    *   target: number | null }>} params.outputs - Every output of the file somebody is watching, with
    *   what decides how long its segments take to make and deliver (`sourceDeadline`), what it has made
@@ -401,13 +399,13 @@ export class PlaybackProjection {
     for (const info of outputs) {
       seen.add(info.outputKey);
       let output = this.#outputs.get(info.outputKey);
-      if (output && (output.grid !== info.grid || output.runsPastEnd !== Boolean(info.runsPastEnd))) {
+      if (output && output.grid !== info.grid) {
         this.#dropOutput(output);
         output = undefined;
       }
       const fresh = !output;
       if (fresh) {
-        output = new OutputState(info.outputKey, info.grid, Boolean(info.runsPastEnd));
+        output = new OutputState(info.outputKey, info.grid);
         this.#outputs.set(info.outputKey, output);
       }
       // How long a segment of it takes to make and deliver.
@@ -436,8 +434,9 @@ export class PlaybackProjection {
         for (const segment of output.segments) if (this.#demand(segment, zones, ordered, nextBase, leadMoved)) reworked++;
       } else {
         for (const { from, to } of stretches) {
-          // A piece reaching past its end is read for the stretch after it too.
-          for (let index = Math.max(0, segmentAt(output.grid, from) - (output.runsPastEnd ? 1 : 0));
+          // A viewer at an exact playlist boundary may request the piece
+          // ending there before requesting the one that starts there.
+          for (let index = Math.max(0, segmentAt(output.grid, from) - 1);
             index < output.segments.length && output.segments[index].from < to; index++) {
             if (this.#demand(output.segments[index], zones, ordered, nextBase, false)) reworked++;
           }

package/services/viewer/playback-readiness.js

@@ -223,7 +223,7 @@ export function predictPlaybackReadiness(input = {}) {
     bitsPerMediaSecond: averageBitsPerMediaSecond(track, track.segments,
       new Set(Array.isArray(track.readySegmentIndices) ? track.readySegmentIndices : [])),
     segments: segmentsOf[trackIndex]
-      .filter((segment) => isPiece(segment) && segment.endSeconds > position && segment.startSeconds < horizonEnd)
+      .filter((segment) => isPiece(segment) && segment.endSeconds >= position && segment.startSeconds < horizonEnd)
       .sort((left, right) => left.startSeconds - right.startSeconds || left.index - right.index),
     // The pieces after the near window, as the playlist cuts them, and the
     // offset the page's player placed them by.
@@ -290,9 +290,12 @@ export function predictPlaybackReadiness(input = {}) {
     for (const segment of segments) {
       // Media the page already holds is not transferred again: every range of
       // the piece still ahead of the viewer lies inside what the page holds.
+      const exactBoundaryPrerequisite = segment.endSeconds === position;
       let held = segment.ranges.length > 0;
       for (const range of segment.ranges) {
-        if (compare(range.end, at) > 0 && !contains(state.clientRanges, latest(range.start, at), range.end)) {
+        const requiredStart = exactBoundaryPrerequisite ? range.start : latest(range.start, at);
+        if ((exactBoundaryPrerequisite || compare(range.end, at) > 0) &&
+          !contains(state.clientRanges, requiredStart, range.end)) {
           held = false;
           break;
         }
@@ -876,8 +879,10 @@ function withSeekStartTolerance(ranges, position, unit) {
 
 /**
  * The pieces of a track this forecast places in exact time: those still to
- * play (ending after `position`) that start before `horizonEnd`, the first
- * piece, every piece that has been read and every piece that is made. A piece
+ * play (ending at or after `position`) that start before `horizonEnd`, the first
+ * piece, every piece that has been read and every piece that is made. The piece
+ * ending exactly at a seek position is kept as a prerequisite: the playlist
+ * player can request it before the piece starting at that position. A piece
  * that is none of these changes no exact answer: after the near window it is
  * scheduled in seconds, it is not where the track starts, no unread piece is
  * placed by it (only read pieces are), it lends no frame to what the page
@@ -891,7 +896,7 @@ function withSeekStartTolerance(ranges, position, unit) {
 function piecesThatMatter(track, position, horizonEnd = Number.POSITIVE_INFINITY) {
   const made = new Set(Array.isArray(track.readySegmentIndices) ? track.readySegmentIndices : []);
   const kept = track.segments.filter((segment) => segment?.index === 0 || segment?.mediaRanges !== undefined ||
-    made.has(segment?.index) || (!(Number.isFinite(segment?.endSeconds) && segment.endSeconds <= position) &&
+    made.has(segment?.index) || (!(Number.isFinite(segment?.endSeconds) && segment.endSeconds < position) &&
       !(Number.isFinite(segment?.startSeconds) && segment.startSeconds >= horizonEnd)));
   return kept.length === track.segments.length ? track.segments : kept;
 }