@torrent-tv/proxy 2.76.3 → 2.76.5

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 2.76.5
+
+- **Chore**: What encoding costs this machine is a class of its own (`services/quality/EncodeCost.js`), the third part taken out of the session manager. One subject — seconds of work per second of video — asked about a picture being re-encoded, a soundtrack, a copy, everything running beside the rung being judged, and turned into the list of heights the machine can hold. It holds what an encoder taught it, since it is the only thing that reads those figures, and it is given what it cannot work out for itself: which sessions belong to one file, the host's own readings, how many encoders are running, and what the file costs merely by being fetched. The host is asked at the moment of the question rather than copied when the object is made — the share of the machine that is free is re-read every few seconds, and a copy would price every later rung against a machine that has gone. The manager keeps the three methods that LEARN those costs; moving them is the next step.
+- **Fix**: A rung measured running below realtime is withdrawn even on a host whose startup benchmark is missing. That measurement is the strongest evidence there is about a rung — it ran, and it could not keep up — and it was being discarded along with the prediction it does not depend on. Found by a check written while the arithmetic was being moved.
+- **Chore**: What a session's encoding is doing, as one state, is answered where the run states are defined (`encode/encode-run-state.js`) instead of by three functions in the manager. The boundary of the new directory is a lint rule, like every layer before it, and the rule was checked to fire rather than assumed to.
+
+## 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/biome.json

@@ -49,6 +49,38 @@
 				}
 			}
 		},
+		{
+			"includes": ["services/quality/**"],
+			"linter": {
+				"rules": {
+					"style": {
+						"noRestrictedImports": {
+							"level": "error",
+							"options": {
+								"patterns": [
+									{
+										"group": [
+											"../hls-session-manager.js",
+											"../controllers/**",
+											"../orchestrators/**",
+											"../container/**",
+											"../demand/**",
+											"../download/**",
+											"../piece-store/**",
+											"../segment-formats/**",
+											"../torrent-worker/**",
+											"../viewer/**",
+											"../output/**"
+										],
+										"message": "What encoding costs is arithmetic over readings. Which sessions belong to one file, how many encoders run, what a file costs to fetch — all of it is passed in, so this can be asked without a session manager, a torrent or a disk."
+									}
+								]
+							}
+						}
+					}
+				}
+			}
+		},
 		{
 			"includes": ["services/download/**"],
 			"linter": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.76.3",
+  "version": "2.76.5",
   "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/encode/encode-run-state.js

@@ -486,3 +486,70 @@ export function declaredEdges() {
 export function declaredContainment() {
   return Object.entries(PARENT).map(([state, parent]) => ({ state, parent }));
 }
+
+/**
+ * Every run this session has going, earliest first.
+ *
+ * A session holds as many as the machine affords, because one output can be
+ * watched from more than one place: a viewer who jumps back gets a run of their
+ * own rather than dragging the picture away from a viewer watching ahead.
+ *
+ * @param {{ runs?: Set<object> }} session
+ * @returns {object[]}
+ */
+export function runsOf(session) {
+  const runs = session?.runs instanceof Set ? [...session.runs] : [];
+  return runs.sort((left, right) => left.from - right.from);
+}
+
+/**
+ * The runs of this session that still have a process.
+ *
+ * @param {{ runs?: Set<object> }} session
+ * @returns {object[]}
+ */
+export function liveRunsOf(session) {
+  return runsOf(session).filter((run) => run.isAlive);
+}
+
+/**
+ * What this session's encoding is doing, as one state.
+ *
+ * The most advanced state among its live runs: a session with anything
+ * producing IS producing, whatever else it has going. A session that has never
+ * started a run, or whose runs have all ended, is at the table's own initial
+ * state — which is what "nothing is encoding" means.
+ *
+ * @param {{ runs?: Set<object> }} session
+ * @returns {string}
+ */
+export function runStateOf(session) {
+  let answer = INITIAL_RUN_STATE;
+  let rank = -1;
+  for (const run of runsOf(session)) {
+    const at = RUN_STATE_ORDER.indexOf(run.state);
+    if (at > rank) {
+      rank = at;
+      answer = run.state;
+    }
+  }
+  return answer;
+}
+
+/**
+ * How advanced a run state is, for reducing several runs to one answer.
+ *
+ * Producing outranks starting, and both outrank a run that has ended: what a
+ * caller asking "what is this session's encoding doing" wants to know is
+ * whether anything is being made, not what the quietest of them is up to.
+ */
+const RUN_STATE_ORDER = [
+  ENCODE_RUN_STATE.ENDED_FAILED,
+  ENCODE_RUN_STATE.ENDED_COMPLETE,
+  ENCODE_RUN_STATE.STOPPED,
+  ENCODE_RUN_STATE.IDLE,
+  ENCODE_RUN_STATE.RETRY_WAIT,
+  ENCODE_RUN_STATE.SUSPENDED,
+  ENCODE_RUN_STATE.STARTING,
+  ENCODE_RUN_STATE.PRODUCING
+];