@torrent-tv/proxy 2.76.4 → 2.76.5

package/CHANGELOG.md

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

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.4",
+  "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/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
+];