@torrent-tv/proxy 2.76.4 → 2.76.6

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 2.76.6
+
+- **New**: The proxy says which films it is already downloading, in the same health poll the browser makes before it picks one. A viewer sent to the proxy that has their film costs it the encode and nothing else — the torrent is there, its pieces are there, and where the output is identical they share that too — while the same viewer sent anywhere else starts the download from nothing. Answered from the torrent thread, which is the only truthful record: the main thread keeps stand-ins that are cleared on shutdown alone, so they name films this proxy let go of hours ago. A proxy that cannot answer is scored on its machine as before.
+- **Chore**: Two doc comments in the torrent pool's interface described methods that had been moved or renamed out from under them, leaving the methods below without one. Each is back over its own.
+
+## 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/bin/cli.js

@@ -473,8 +473,20 @@ try {
     onSignal(sessionId, signal) {
       webRtcManager?.handleSignal(sessionId, signal);
     },
-    onHealthRequest() {
-      return collectHealthMetrics();
+    async onHealthRequest() {
+      // Which films this proxy holds travels with the health poll the browser
+      // already makes before it picks one: a viewer sent to a proxy that is
+      // downloading their film costs it the encode and nothing else, while the
+      // same viewer sent anywhere else starts the download from nothing. Asked
+      // of the worker, so a film this proxy let go of is not claimed.
+      let holds = [];
+      try {
+        holds = (await started?.torrentPool?.heldTorrents?.()) ?? [];
+      } catch {
+        // silent-ok: a proxy that cannot say what it holds is scored on its
+        // machine alone, which is what every proxy was scored on until now.
+      }
+      return { metrics: collectHealthMetrics(), holds };
     },
     // Whether this host could sustain a file it has only been told about. The
     // same arithmetic the first offer uses, against this host's own startup

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.6",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

package/server.js

@@ -378,6 +378,10 @@ export async function startProxyServer({
     // recorded from a browser request and published from the pool's side, so
     // resolving one into the other is what lets the two ends agree on what
     // they are both calling "sourceKey".
-    sourceRegistry
+    sourceRegistry,
+    // Which films this host holds, for the health poll the browser makes before
+    // it picks a proxy. The pool is on the worker thread and this is the way to
+    // it from the process that answers that poll.
+    torrentPool
   };
 }

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
+];