@torrent-tv/proxy 2.99.0 → 2.99.2

package/package.json

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

package/server.js

@@ -66,6 +66,7 @@ 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";
@@ -626,7 +627,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);
-        played.push({ outputKey: output.outputKey, grid,
+        // 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),
           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

@@ -25,6 +25,7 @@ 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";
 
 
 /**
@@ -599,7 +600,7 @@ export class EncodeRuns {
         timeline?.inSegments?.(
           this.#host.priority.mapForOutput(address),
           Number(timeline?.segmentCount) || 0,
-          { runsPastEnd: Boolean(spec?.audio) && spec?.transcodesAudio !== true }
+          { runsPastEnd: piecesRunPastEnd(spec) }
         ) ?? []
       );
     }

package/services/encode/output/Timeline.js

@@ -42,6 +42,27 @@
  * reveal where the file's cuts really are.
  */
 
+/**
+ * Whether an output's pieces copy a stream, picture or sound, and so may hold
+ * a little past their published end: a copy ends at the first packet 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.
+ *
+ * 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
+ * (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) && spec.transcodesAudio !== true);
+}
+
 export class Timeline {
   /**
    * @param {object} params

package/services/encode/quality/QualityController.js

@@ -496,7 +496,11 @@ export class QualityController {
       bufferedSec: buffer?.bufferedSec ?? 0,
       slope: buffer?.slope ?? null,
       reportGapSec: buffer?.reportGapSec ?? 0,
-      secondsToReady: this.#secondsToReady(session)
+      secondsToReady: this.#secondsToReady(session),
+      // What is left of the film after them: a buffer holding all of it drains
+      // because the film ends.
+      remainingSec: Number.isFinite(buffer?.positionSec) && session.file?.durationSeconds > 0
+        ? Math.max(0, session.file.durationSeconds - buffer.positionSec) : null
     });
     if (!threat) {
       return false;

package/services/encode/quality/drain-threat.js

@@ -20,6 +20,13 @@
  *
  * A time to ready that is not known is not assumed to be short: with nothing to
  * show there is time left, a draining buffer is a threat.
+ *
+ * A BUFFER HOLDING THE REST OF THE FILM IS NO THREAT: it drains because the
+ * film ends, and no output can add to it. Field r43 (Home Assistant,
+ * 2026-10-15): the last two minutes of an AVI were read as a draining buffer,
+ * a faster setting was prepared 53 times and given up each time with nothing
+ * left to give, and the player was asked for 240p eight times
+ * (torrent-tv/meta#178).
  */
 
 /**
@@ -31,14 +38,19 @@
  *   two reports.
  * @param {number | null} params.secondsToReady - How long the new output would
  *   take to close the piece the viewer needs; null when not known.
+ * @param {number | null} [params.remainingSec] - The film left after where the
+ *   viewer stands; null when not known.
  * @returns {{ threat: boolean, secondsToEmpty: number | null }}
  */
-export function drainThreat({ bufferedSec, slope, reportGapSec, secondsToReady }) {
+export function drainThreat({ bufferedSec, slope, reportGapSec, secondsToReady, remainingSec = null }) {
   if (!Number.isFinite(slope) || slope >= 0) {
     return { threat: false, secondsToEmpty: null };
   }
   const held = Number.isFinite(bufferedSec) && bufferedSec > 0 ? bufferedSec : 0;
   const secondsToEmpty = held / -slope;
+  if (Number.isFinite(remainingSec) && held >= remainingSec) {
+    return { threat: false, secondsToEmpty };
+  }
   if (!Number.isFinite(secondsToReady) || secondsToReady < 0) {
     return { threat: true, secondsToEmpty };
   }

package/services/torrent/PlaybackProjection.js

@@ -267,11 +267,18 @@ class RangeEntry {
 
 /** One output segment as the projection holds it. */
 class Segment {
-  constructor(output, index, from, to) {
+  constructor(output, index, from, to, reach = to) {
     this.output = output;
     this.index = index;
     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.
+     */
+    this.reach = reach;
     /** Whether a zone of the map overlaps it. */
     this.demanded = false;
     /** Whether the output has it made. */
@@ -304,13 +311,16 @@ 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) {
+  constructor(outputKey, grid, runsPastEnd = false) {
     this.outputKey = outputKey;
     this.grid = grid;
+    this.runsPastEnd = runsPastEnd;
     /** @type {Segment[]} */
     this.segments = [];
     for (let index = 0; index + 1 < grid.length; index++) {
-      this.segments.push(new Segment(this, index, grid[index], grid[index + 1]));
+      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));
     }
     this.encodeSpeed = undefined;
     this.bytesPerSecond = undefined;
@@ -370,7 +380,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[], encodeSpeed?: number, bytesPerSecond?: number | null,
+   * @param {Array<{ outputKey: string, grid: number[], runsPastEnd?: boolean, 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
@@ -391,13 +401,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) {
+      if (output && (output.grid !== info.grid || output.runsPastEnd !== Boolean(info.runsPastEnd))) {
         this.#dropOutput(output);
         output = undefined;
       }
       const fresh = !output;
       if (fresh) {
-        output = new OutputState(info.outputKey, info.grid);
+        output = new OutputState(info.outputKey, info.grid, Boolean(info.runsPastEnd));
         this.#outputs.set(info.outputKey, output);
       }
       // How long a segment of it takes to make and deliver.
@@ -426,7 +436,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) {
-          for (let index = segmentAt(output.grid, from); index < output.segments.length && output.segments[index].from < to; index++) {
+          // 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));
+            index < output.segments.length && output.segments[index].from < to; index++) {
             if (this.#demand(output.segments[index], zones, ordered, nextBase, false)) reworked++;
           }
         }
@@ -542,7 +554,7 @@ export class PlaybackProjection {
   #demand(segment, zones, ordered, base, leadMoved) {
     // The zones it overlaps, folded as they are met.
     let owner = null, ownerDeadline = Infinity, priority = 0, urgent = false, behind = true, deferred = true;
-    const { from, to } = segment;
+    const { from, reach: to } = segment;
     for (let at = ordered ? firstEndingAfter(zones, from) : 0; at < zones.length; at += 1) {
       const zone = zones[at];
       if (ordered && !(zone.from < to)) break;
@@ -592,8 +604,8 @@ export class PlaybackProjection {
     let owner = null, ownerDeadline = Infinity;
     for (let at = this.#ordered ? firstEndingAfter(zones, segment.from) : 0; at < zones.length; at += 1) {
       const zone = zones[at];
-      if (this.#ordered && !(zone.from < segment.to)) break;
-      if (!(zone.priority > 0) || !(zone.from < segment.to && zone.to > segment.from)) continue;
+      if (this.#ordered && !(zone.from < segment.reach)) break;
+      if (!(zone.priority > 0) || !(zone.from < segment.reach && zone.to > segment.from)) continue;
       const deadline = Number.isFinite(zone.deadlineAt) ? zone.deadlineAt + Math.max(0, segment.from - zone.from) * 1000 : Infinity;
       if (owner === null || deadline < ownerDeadline) { owner = zone; ownerDeadline = deadline; }
     }

package/services/viewer/choices.js

@@ -338,7 +338,8 @@ export function bufferOf(viewers, output, consumerId, spanSec) {
   }
   const trend = viewer.bufferTrend(spanSec);
   const held = Number.isFinite(viewer.bufferedSeconds) ? Math.max(0, viewer.bufferedSeconds) : 0;
-  return { bufferedSec: held, slope: trend?.slope ?? null, reportGapSec: trend?.reportGapSec ?? 0 };
+  return { bufferedSec: held, slope: trend?.slope ?? null, reportGapSec: trend?.reportGapSec ?? 0,
+    positionSec: viewer.positionSeconds() ?? null };
 }
 
 /**