@torrent-tv/proxy 2.76.2 → 2.76.4

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 2.76.4
+
+- **Fix**: An encoder was started and killed every five seconds, each one producing 0-2 segments, for as long as anybody watched. Measured on the addon host: a run given no end carries a `to` below its `from` — which is how "no end" is written everywhere here — and two places read that as a number instead. The plan's test for "is anybody waiting for what this run was given" said no, so it was stopped as unwanted; and the stretch it claimed in the coverage map collapsed to a single segment, so the plan saw the rest of the film as free and started another encoder one number along. The two together are the loop. The rule is stated once now (`endOfRun`) and read from that one place, including where a run's own ending is judged.
+- **Fix**: A run with no end holds the look-ahead in front of it, not the rest of the film. It is what actually bounds one — a run is suspended once it is that far in front of the segment its viewer asked for and produces nothing until somebody asks — and claiming further would leave a viewer who opens the same film further in with no encoder at all, waiting for that run to encode its way there. The rule was already applied where a session plans its own interval and not on the path the plan uses.
+
+## 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.4",
   "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

@@ -38,6 +38,8 @@
  * own answer — the look-ahead, which suspends a run rather than bounding it.
  */
 
+import { endOfRun } from "./EncodeRun.js";
+
 /**
  * One encoder that is running now.
  *
@@ -138,7 +140,7 @@ export function planEncoders({
   for (const run of live) {
     // 1. Is anybody waiting for what this run was given? A run whose stretch
     //    touches no window is making material nobody has asked for.
-    const stillWanted = wanted.some((span) => overlaps(run.from, run.to, span.from, span.to));
+    const stillWanted = wanted.some((span) => overlaps(run.from, endOfRun(run), span.from, span.to));
     if (!stillWanted) {
       stops.push({ type: "stop", run, because: "nothing it was given is wanted" });
       continue;
@@ -184,7 +186,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 +221,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 +229,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/encode/EncodeRun.js

@@ -63,6 +63,26 @@ const MICROSECONDS_PER_SECOND = 1_000_000;
  * @property {string} lastError - The last thing ffmpeg said on stderr.
  */
 
+/**
+ * The last number this run was given, or Infinity when it was given no end.
+ *
+ * ONE reading of one convention. "No end" is written as a `to` below `from` —
+ * the session layer returns -1 for it and the log prints `#-1` — and every place
+ * that has to compare against it read that for itself. One place did not: the
+ * coverage map was handed the raw -1, `Math.max(from, -1)` made the claim one
+ * segment long, and the plan then saw the rest of the film as free. Field,
+ * 2026-09-05: an encoder was started and killed every five seconds, each one
+ * producing 0-2 segments, for as long as anybody watched.
+ *
+ * @param {{ from: number, to: number }} run
+ * @returns {number}
+ */
+export function endOfRun(run) {
+  const from = Number(run?.from);
+  const to = Number(run?.to);
+  return Number.isInteger(to) && to >= from ? to : Number.POSITIVE_INFINITY;
+}
+
 export class EncodeRun {
   /** @type {import("node:child_process").ChildProcess | null} */
   #process = null;
@@ -466,7 +486,7 @@ export class EncodeRun {
     // one, and the end of the film where it was not. A run told to make #10..#14
     // that exits cleanly at #11 has not finished, whatever the film's length;
     // and a run with no end has nothing but the film to be measured against.
-    const endOfWork = this.to >= this.from ? this.to : this.lastSegmentIndex();
+    const endOfWork = Number.isFinite(endOfRun(this)) ? this.to : this.lastSegmentIndex();
     const outcome = classifyEncodeExit({
       code,
       producedThrough: this.#produced.size > 0 ? this.reached : null,

package/services/hls-session-manager.js

@@ -68,6 +68,7 @@ import { masterPlaylistText, mediaPlaylistText, segmentIndexForTime } from "./ou
 import { SourceFiles, sourceDecodeCharacteristics } from "./source/SourceFile.js";
 import { ProducedIndex } from "./produced-index.js";
 import { SegmentStore } from "./encode/SegmentStore.js";
+import { endOfRun } from "./encode/EncodeRun.js";
 import {
   buildRunCommand,
   ffmpegSeconds,
@@ -1807,6 +1808,7 @@ export class HlsSessionManager {
       makeRun: ({ address, from }) => this.#makeRunAt(address, from),
       segmentSeconds: this.segmentDurationSec,
       restartCostSec: RUN_RESTART_COST_SEC,
+      lookaheadSegments: Math.ceil(this.lookaheadSeconds / this.segmentDurationSec),
       logger
     });
     // Where each file is cut, held once per file and grid rather than once per
@@ -3856,7 +3858,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 +5469,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.
@@ -5489,7 +5497,7 @@ export class HlsSessionManager {
       // the honest extent of its claim, and it is a measured figure rather than
       // a chosen one — the same allowance the browser sizes its cushion from.
       const willReach = run.head + lookaheadSegments;
-      const allowed = Number.isInteger(run.to) && run.to >= run.from ? run.to : lastIndex;
+      const allowed = Number.isFinite(endOfRun(run)) ? run.to : lastIndex;
       claims.push({ from: run.from, to: Math.min(allowed, willReach) });
     }
     const takenAt = (index) =>
@@ -5692,7 +5700,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/services/orchestrators/EncodeOrchestrator.js

@@ -25,6 +25,7 @@
 
 import { CoverageMap } from "../encode/CoverageMap.js";
 import { firstUnmetWant, planEncoders } from "../encode/EncodePlan.js";
+import { endOfRun } from "../encode/EncodeRun.js";
 import { ENCODE_EXIT } from "../encode/encode-exit.js";
 import { SegmentDemand } from "../encode/SegmentDemand.js";
 
@@ -52,12 +53,17 @@ export class EncodeOrchestrator {
    * @param {{ info: (line: string) => void, warn: (line: string) => void }} params.logger
    * @param {() => number} [params.now]
    */
-  constructor({ maxRunsFor, makeRun, segmentSeconds, restartCostSec, logger, now }) {
+  constructor({ maxRunsFor, makeRun, segmentSeconds, restartCostSec, lookaheadSegments = 0, logger, now }) {
     this.demand = new SegmentDemand();
     this.maxRunsFor = maxRunsFor;
     this.makeRun = makeRun;
     this.segmentSeconds = segmentSeconds;
     this.restartCostSec = restartCostSec;
+    // How far in front of its viewer a run is allowed to get. It is what bounds
+    // the claim of a run that was given no end — see #claimFor.
+    this.lookaheadSegments = Number.isFinite(lookaheadSegments) && lookaheadSegments > 0
+      ? Math.ceil(lookaheadSegments)
+      : 0;
     this.logger = logger;
     this.now = typeof now === "function" ? now : Date.now;
   }
@@ -227,7 +233,7 @@ export class EncodeOrchestrator {
       }
       // A run that stays keeps its claim current: the free stretch ahead of it
       // may have shrunk since it was given one.
-      coverage.claim(action.run, action.from, action.to);
+      this.#claimFor(coverage, action.run, action.from, action.to);
     }
   }
 
@@ -278,7 +284,40 @@ export class EncodeOrchestrator {
     }
     onThisOutput.push(run);
     this.#runs.set(address, onThisOutput);
-    this.coverageOf(address).claim(run, run.from, run.to);
+    this.#claimFor(this.coverageOf(address), run, run.from, run.to);
+  }
+
+  /**
+   * What a run holds, as far as the map is concerned.
+   *
+   * A run given an end holds exactly that stretch. A run given NO end — `to`
+   * below `from`, which is how this is written everywhere here — would hold the
+   * rest of the film, and that is what must not be claimed: a second viewer
+   * opening the same film further in would find every number taken and get no
+   * encoder at all, waiting instead for the first run to encode its way there,
+   * which on a long film is an hour.
+   *
+   * What bounds it in practice is the look-ahead: a run is suspended once it is
+   * that far in front of the segment its viewer last asked for, and past that it
+   * produces nothing until somebody asks. So that is the honest extent of the
+   * claim, and it is a measured figure rather than a chosen one — the same
+   * allowance the browser sizes its cushion from. `planRunInterval` has applied
+   * this rule since runs got intervals; this path did not, which is how an
+   * encoder came to be started and killed every five seconds in the field.
+   *
+   * @param {CoverageMap} coverage
+   * @param {object} run
+   * @param {number} from
+   * @param {number} to
+   */
+  #claimFor(coverage, run, from, to) {
+    const end = endOfRun({ from, to });
+    if (Number.isFinite(end)) {
+      coverage.claim(run, from, end);
+      return;
+    }
+    const head = Number.isFinite(run?.head) ? run.head : from;
+    coverage.claim(run, from, Math.max(from, head + this.lookaheadSegments));
   }
 
   /**

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/encode-orchestrator.test.js

@@ -194,3 +194,34 @@ test("nothing wanted anywhere is said plainly", () => {
   const { made } = orchestrator();
   assert.match(made.describe(), /nothing wanted/);
 });
+
+test("a run adopted with no end holds the look-ahead, not the rest of the film", () => {
+  // A session's own encoder is handed to the plan rather than built by it, and
+  // it carries `to = -1` — no end. Claiming the film from there would leave a
+  // viewer further in with no encoder at all: they would wait for this run to
+  // encode its way to them, which on a long film is an hour. What bounds it is
+  // the look-ahead, because a run is suspended once it is that far in front of
+  // its viewer and produces nothing until somebody asks.
+  const { made } = orchestrator({ maxRuns: 2 });
+  made.lookaheadSegments = 30;
+  const adopted = {
+    from: 0,
+    to: -1,
+    head: 3,
+    isAlive: true,
+    isStopping: false,
+    speedX: 8,
+    stop() {
+      this.isAlive = false;
+    }
+  };
+  made.adopt(PICTURE, adopted);
+
+  made.want({ claimant: "far", address: PICTURE, from: 200, to: 230 });
+  made.reconcile();
+
+  const runs = made.runsOn(PICTURE);
+  assert.equal(runs.length, 2, "the viewer further in got an encoder of their own");
+  assert.ok(adopted.isAlive, "and the adopted run was not stopped to make room");
+  assert.equal(runs.some((run) => run.from === 200), true, "started where that viewer is waiting");
+});

package/test/encode-plan.test.js

@@ -10,6 +10,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { CoverageMap } from "../services/encode/CoverageMap.js";
+import { endOfRun } from "../services/encode/EncodeRun.js";
 import { firstUnmetWant, planEncoders } from "../services/encode/EncodePlan.js";
 
 /** A host that can afford two encoders, four-second segments, a cheap restart. */
@@ -243,3 +244,35 @@ test("the lowest thing a viewer is waiting for is reported, so a stalled plan is
   coverage.markReadyAll([42, 43, 44]);
   assert.equal(firstUnmetWant(coverage, [{ from: 40, to: 44 }]), null);
 });
+
+test("a run with no end is making what the viewers ahead of it are waiting for", () => {
+  // Field, 2026-09-05: an encoder was started and killed every five seconds,
+  // each producing 0-2 segments, for as long as anybody watched. A run given no
+  // end carries `to = -1`, and two places read that as a number instead of as
+  // "no end": the overlap test called its work unwanted, and the claim it made
+  // in the coverage map was one segment long, so the plan saw the rest of the
+  // film as free and started another encoder there.
+  const coverage = new CoverageMap({ segmentCount: 570 });
+  const run = { from: 0, to: -1, head: 3, speedX: 8, isAlive: true };
+  coverage.claim(run, run.from, endOfRun(run));
+
+  const actions = planEncoders({
+    coverage,
+    live: [run],
+    wanted: [{ from: 0, to: 30 }],
+    maxRuns: 2,
+    segmentSeconds: 4,
+    restartCostSec: 0.12
+  });
+
+  assert.deepEqual(
+    actions.filter((action) => action.type === "stop"),
+    [],
+    "nothing is stopped: it is making exactly what is wanted"
+  );
+  assert.deepEqual(
+    actions.filter((action) => action.type === "start"),
+    [],
+    "and nothing new is started over ground it already holds"
+  );
+});

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()