@torrent-tv/proxy 2.76.3 → 2.76.4

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.76.3",
+  "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/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;

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
@@ -5495,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) =>

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/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"
+  );
+});