@torrent-tv/proxy 2.76.2 → 2.76.3

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2.76.3
+
+- **Fix**: The proxy stopped answering anything — playback, health, its own log — a few seconds after a viewer opened a film, and burned a whole processor doing it. Measured on the addon host with the stack read out of the live process: the look-ahead timer asked the plan where a new encoder could start, and the walk that answers that walked one segment number at a time towards nine quadrillion, scanning every claim at each step. It did that because the map had no length, and the map had no length because the field naming it moved onto the timeline in 2.76.0 while three readers were left on the old name, where every session answers `undefined`. Those three are the whole defect: with them wrong, no run was ever given an end either, so the feature that lets two encoders share one output was inert as well.
+- **Fix**: That walk can no longer do this whatever the length says. With no length known there is nothing to walk towards, and the answer — where the free stretch ends — is read off what the map already holds: the segments made and the stretches claimed, both finite however long the film is. A run then gets no end, which is what "the length is unknown" honestly means.
+- **Chore**: Three test fixtures stated the moved field on the session, so the checks went on passing over code that could not work. They state the timeline now, which is where the product reads it.
+
 ## 2.76.2
 
 - **Fix**: How long a session waits for a film's keyframe table is bounded, and the bound is one the read already had rather than a new number. That table decides which branch a picture takes — with it the picture is passed through untouched, without it the whole picture is re-encoded — and nothing limited the wait, while the file comes off a torrent and the bytes the table lives in may still be arriving. Measured on the addon host over seventeen files from four containers, pieces from 0.25 to 16 MB (`research/keyframe-table-read-2026-09-04.md`): every table that arrived did so within 24.8 s and most within half a second, while two files answered nothing for 120.9 s and 120.5 s — which is exactly TWO of the sixty-second bound the read already has, one for the wait on the file's edges and one for the read, in series. A session now waits for one of them. The read is not cancelled: it goes on, is remembered on the file, and the next session of that file gets the copy.

package/package.json

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

package/services/encode/CoverageMap.js

@@ -251,7 +251,22 @@ export class CoverageMap {
    */
   freeRunFrom(index, exceptRun = null) {
     const start = Number.isInteger(index) && index > 0 ? index : 0;
-    const last = this.#segmentCount > 0 ? this.#segmentCount - 1 : Number.MAX_SAFE_INTEGER;
+    if (this.#segmentCount <= 0) {
+      // The length is not known, so how far the free stretch reaches is not
+      // known either, and the honest answer is "as far as there is film" — the
+      // caller turns that into a run with no end.
+      //
+      // Never walked one number at a time to find that out. It used to be, up to
+      // MAX_SAFE_INTEGER, with a scan of every claim at each step: on the addon
+      // host, 2026-09-05, the main thread spun at 100% from the look-ahead timer
+      // and the proxy stopped answering anything at all, its own log included.
+      // The length was missing because the field naming it had moved and three
+      // readers were left on the old name — but a walk whose end depends on a
+      // field being present must not be able to do this even then.
+      const covered = this.#firstCoveredFrom(start, exceptRun);
+      return covered === null ? Number.POSITIVE_INFINITY : covered - start;
+    }
+    const last = this.#segmentCount - 1;
     let at = start;
     while (at <= last) {
       if (this.#ready.has(at)) {
@@ -266,6 +281,38 @@ export class CoverageMap {
     return at - start;
   }
 
+  /**
+   * The first number at or after `index` that somebody has made or is making,
+   * or null when nobody has touched anything from there on.
+   *
+   * Asked of what the map HOLDS rather than by walking the numbers, so it can be
+   * answered without a length: the map knows every ready number and every claim,
+   * and both are finite however long the film is.
+   *
+   * @param {number} index
+   * @param {object | null} exceptRun
+   * @returns {number | null}
+   */
+  #firstCoveredFrom(index, exceptRun) {
+    let lowest = null;
+    for (const ready of this.#ready) {
+      if (ready >= index && (lowest === null || ready < lowest)) {
+        lowest = ready;
+      }
+    }
+    for (const [run, span] of this.#claims) {
+      if (run === exceptRun) {
+        continue;
+      }
+      // A claim that has already begun covers `index` itself.
+      const covers = span.from <= index && index <= span.to ? index : span.from;
+      if (covers >= index && (lowest === null || covers < lowest)) {
+        lowest = covers;
+      }
+    }
+    return lowest;
+  }
+
   /**
    * What this map holds, for a log line.
    *

package/services/encode/EncodePlan.js

@@ -184,7 +184,7 @@ export function planEncoders({
       type: "move",
       run,
       from: gap,
-      to: gap + Math.max(1, free) - 1,
+      to: endOfStretch(gap, free),
       because: driveSec === null
         ? `${coveredAhead} segment(s) ahead are already covered and its speed is not measured`
         : `driving through ${coveredAhead} covered segment(s) costs ${driveSec.toFixed(2)}s ` +
@@ -219,7 +219,7 @@ export function planEncoders({
     starts.push({
       type: "start",
       from: gap,
-      to: gap + free - 1,
+      to: endOfStretch(gap, free),
       because: `#${gap} is wanted and nobody is making it`
     });
   }
@@ -227,6 +227,21 @@ export function planEncoders({
   return [...stops, ...moves, ...starts, ...keeps];
 }
 
+/**
+ * The last number of a stretch that begins at `from` and is `length` long.
+ *
+ * `-1` when the length is not finite, which is this layer's word for a run with
+ * no end: the film's length is not known, so there is nothing to stop it at, and
+ * a number invented here would be an end nobody measured.
+ *
+ * @param {number} from
+ * @param {number} length
+ * @returns {number}
+ */
+function endOfStretch(from, length) {
+  return Number.isFinite(length) ? from + Math.max(1, length) - 1 : -1;
+}
+
 /**
  * The lowest number a viewer is waiting for that is not ready — what the plan
  * is judged by.

package/services/hls-session-manager.js

@@ -3856,7 +3856,13 @@ export class HlsSessionManager {
     const now = Date.now();
     for (const [address, sessions] of byOutput) {
       const coverage = this.encodeOrchestrator.coverageOf(address);
-      const segmentCount = Number(sessions[0].segmentCount) || 0;
+      // From the TIMELINE, which is where how a file is cut has lived since
+      // 2.76.0. Read off the session it left, this was `undefined` on every
+      // session ever made: the map then held no length, and the walk that
+      // gives a run its end ran to MAX_SAFE_INTEGER — the main thread spun at
+      // 100% and the proxy answered nothing, measured on the addon host
+      // 2026-09-05 with the stack read out of the live process.
+      const segmentCount = Number(sessions[0].timeline?.segmentCount) || 0;
       if (segmentCount > 0) {
         coverage.setSegmentCount(segmentCount);
       }
@@ -5461,7 +5467,7 @@ export class HlsSessionManager {
 
   planRunInterval(session, startIndex, exceptRun = null) {
     const key = session.outputKey ?? "";
-    const lastIndex = (Number(session.segmentCount) || 0) - 1;
+    const lastIndex = (Number(session.timeline?.segmentCount) || 0) - 1;
     if (!key || lastIndex < 0) {
       // Nothing to plan against: no address, or no playlist yet. The run keeps
       // the shape it has always had — start here, no end.
@@ -5692,7 +5698,8 @@ export class HlsSessionManager {
       // The film's last segment number, which is what tells "it reached the
       // end" from "its input dried up": ffmpeg exits zero for both and over a
       // torrent cannot tell them apart.
-      lastSegmentIndex: () => (session.segmentCount > 0 ? session.segmentCount - 1 : null),
+      lastSegmentIndex: () =>
+        session.timeline?.segmentCount > 0 ? session.timeline.segmentCount - 1 : null,
       inputUnavailable: (message) => isInputUnavailable(message),
       onProgress: (report) => this.#noteRunProgress(session, run, report),
       onEnded: (ended) => this.#onRunEnded(session, run, ended)

package/test/auto-quality-step.test.js

@@ -99,7 +99,6 @@ function fakeSession({ dirPath, transcodeVideo = true, cutGrid = transcodeVideo
     usesExplicitCuts: false,
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
-    segmentCount: 100,
     progress: { state: "running", processedSeconds: 40, startPositionSeconds: 0, speed: "1.0x" }
   };
 }

package/test/behind-head-repair.test.js

@@ -65,7 +65,6 @@ async function managerWithRunAhead() {
     transcodeVideo: true,
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
-    segmentCount: 1936,
     lastRestartAt: 0,
     seekFailureTarget: -1,
     seekFailureCount: 0,

package/test/coverage-map.test.js

@@ -151,3 +151,28 @@ test("with the length unknown, a gap search needs its own bound", () => {
   assert.equal(map.firstGapFrom(0), null, "no length and no bound answers nothing");
   assert.equal(map.firstGapFrom(0, 3), 0);
 });
+
+test("with the length unknown, the free stretch is answered without walking to it", () => {
+  // What this pins: on the addon host, 2026-09-05, a map with no length walked
+  // one number at a time to MAX_SAFE_INTEGER, scanning every claim at each step.
+  // The main thread spun at 100% from the look-ahead timer and the proxy stopped
+  // answering anything, its own log included. The length was missing because the
+  // field naming it had moved to the timeline and three readers were left on the
+  // old name — but this walk must not be able to do that even when it is.
+  //
+  // This check cannot FAIL against the old code — a synchronous walk cannot be
+  // interrupted by the runner, so it would hang the whole run instead, which is
+  // worse than no check. What it pins is the contract that replaced the walk:
+  // the answer comes from what the map holds.
+  const map = new CoverageMap();
+
+  assert.equal(map.freeRunFrom(0), Number.POSITIVE_INFINITY, "nothing is covered, so nothing bounds it");
+
+  const run = aRun();
+  map.claim(run, 500, 900);
+  assert.equal(map.freeRunFrom(0), 500, "and a claim ahead is where the free stretch ends");
+  assert.equal(map.freeRunFrom(0, run), Number.POSITIVE_INFINITY, "its own claim does not bound it");
+
+  map.markReady(200);
+  assert.equal(map.freeRunFrom(0), 200, "so is a segment somebody has already made");
+});

package/test/run-intervals.test.js

@@ -61,7 +61,14 @@ function sessionOn({ id, dirPath, segmentCount = 100, runState = null, encodeSta
     get inputFile() { return this.file; },
     get audioFile() { return this.file; },
     segmentFormat: fmp4Format,
-    segmentCount,
+    // How the file is cut, held by the TIMELINE. A fixture that stated it on the
+    // session was describing a shape the product had left, and it kept a defect
+    // alive for a release: `session.segmentCount` is undefined on every real
+    // session, so runs were given no end and the coverage map had no length.
+    timeline: new Timeline({
+      boundaries: Array.from({ length: segmentCount + 1 }, (_, index) => index * 4),
+      cutGrid: "uniform"
+    }),
     runs: new Set(),
     consumers: new Set(),
     lastAccessedAt: Date.now()