@torrent-tv/proxy 2.89.12 → 2.89.14

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 2.89.14
+
+- **Fix**: A failed run counts only the source's own streams. The planner probes with an output, so ffmpeg's banner goes on to list the streams it maps and writes, and those were counted too: a file with one picture, one soundtrack, one subtitle and one font read as `2 video, 2 audio, 1 subtitle, 3 other` in the field — enough to make a second soundtrack look present when it is not.
+
+## 2.89.13
+
+- **Fix**: The proxy no longer stops answering everybody when one output is priced near zero. Asking how many encoders an output may run counted them one at a time until the machine was full, so the number of steps grew as the price shrank. On the stand on 2026-10-04 a soundtrack priced at 5.4e-14 s of machine per second of film held the main thread in that count for minutes, past 3.3 billion steps: no data channel was served, `/healthz` did not answer, and every viewer stopped. The count is now found by doubling and halving, in at most a few hundred steps whatever the price. The price itself is wrong and is not corrected here.
+
 ## 2.89.12
 
 - **Fix**: A connection that is gone is no longer probed. The delivery probe stopped only when a data channel reported `onClosed`, and a peer connection closed moments after its channels opened reports nothing: on the stand on 2026-10-04 a trial connection the page closed 70 ms after opening was still sent probes twice a second hours later, one timer left behind per such connection. When the transport watcher finds the connection gone, its probes now end with it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.89.12",
+  "version": "2.89.14",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "repository": {

package/services/encode/EncodeAdmission.js

@@ -356,17 +356,37 @@ export class EncodeAdmission {
       return { runs: Number.POSITIVE_INFINITY, because: "the output is not priced" };
     }
     const others = this.#occupied(address);
+    const fits = (count) => this.#speedAt(others.costSec + EncodeAdmission.#added(load, others.files, count)) >= 1;
     let runs = 0;
-    for (;;) {
-      const next = runs + 1;
-      if (this.#speedAt(others.costSec + EncodeAdmission.#added(load, others.files, next)) < 1) {
-        break;
-      }
-      runs = next;
+    if (fits(1)) {
       if (!(load.costSec > 0)) {
         // Free to run: the per-output limit is the only bound.
         return { runs: Number.POSITIVE_INFINITY, because: "it costs nothing measurable" };
       }
+      // The largest count that still fits, found by doubling and halving: the
+      // speed only falls as encoders are added. Counting up one at a time took
+      // as many steps as the price is small — field 2026-10-04, a soundtrack
+      // priced at 5.4e-14 s per film second kept the main thread in this loop
+      // for minutes, past 3.3 billion steps, and every viewer of the proxy
+      // stopped receiving.
+      let low = 1;
+      let high = 2;
+      while (fits(high)) {
+        low = high;
+        high *= 2;
+      }
+      for (;;) {
+        const middle = Math.floor((low + high) / 2);
+        if (middle === low || middle === high) {
+          break;
+        }
+        if (fits(middle)) {
+          low = middle;
+        } else {
+          high = middle;
+        }
+      }
+      runs = low;
     }
     if (runs >= floor) {
       return { runs, because: "the machine" };

package/services/media/ffmpeg-banner.js

@@ -141,7 +141,13 @@ export function parseFfmpegStreamCounts(stderrText) {
   if (typeof stderrText !== "string" || stderrText.length === 0) {
     return null;
   }
-  const lines = stderrText.match(/^\s*Stream #\d+:\d+.*$/gim);
+  // The source's streams only. A probe that writes somewhere — the planner's
+  // `-f null -` does — goes on to print `Stream mapping:` and `Output #0` with
+  // stream lines of their own, and counting those doubled the picture and the
+  // sound (field 2026-10-04: one soundtrack read as two).
+  const end = stderrText.search(/^(?:Stream mapping:|Output #\d+)/m);
+  const inputText = end >= 0 ? stderrText.slice(0, end) : stderrText;
+  const lines = inputText.match(/^\s*Stream #\d+:\d+.*$/gim);
   if (!lines || lines.length === 0) {
     return null;
   }

package/test/encode-admission.test.js

@@ -144,3 +144,27 @@ test("unpriced occupied work is neither spare pool headroom nor capacity for ano
   assert.equal(answer.admitted, false);
   assert.match(answer.reason, /capacity is unknown/);
 });
+
+test("a near-free output is answered at once, whatever its price", () => {
+  // Field 2026-10-04: a soundtrack priced at 5.4e-14 s per film second kept
+  // the main thread counting encoders one at a time for minutes.
+  const { admission } = machine({ costs: { sound: 5.36680075607109e-14 }, share: 0.6 });
+  const started = Date.now();
+  const { runs } = admission.placesFor("sound", 0);
+  assert.ok(Date.now() - started < 1_000, "answered without counting one at a time");
+  assert.ok(runs > 1e12 && Number.isFinite(runs), `as many as fit: ${runs}`);
+});
+
+test("the count is the largest that keeps every output at realtime", () => {
+  for (const cost of [0.5, 0.1, 0.03, 0.007, 0.0011]) {
+    for (const share of [null, 1, 0.37]) {
+      const { admission } = machine({ costs: { a: cost, b: PICTURE_1080 / 4 }, running: { b: 1 }, share });
+      const usable = share ?? 1;
+      let expected = 0;
+      while (usable / (PICTURE_1080 / 4 + (expected + 1) * cost) >= 1) {
+        expected += 1;
+      }
+      assert.equal(admission.placesFor("a", 0).runs, Math.max(expected, 0), `cost ${cost}, share ${share}`);
+    }
+  }
+});

package/test/ffmpeg-stream-counts.test.js

@@ -76,3 +76,26 @@ test("a stream carrying metadata in brackets is still read", () => {
   `);
   assert.deepEqual(counts, { video: 1, audio: 1, subtitle: 0, other: 0 });
 });
+
+test("only the input's streams are counted, not the output ffmpeg describes after them", () => {
+  // The planner probes with `-i <file> -t 0.1 -f null -`, so the banner goes on
+  // to describe what it maps and the null output it writes. Counted whole, this
+  // field file (one picture, one soundtrack, one subtitle, one font) read as
+  // "2 video, 2 audio, 1 subtitle, 3 other" on 2026-10-04 — which would make a
+  // second soundtrack look present when it is not.
+  const banner = `
+Input #0, matroska,webm, from 'http://127.0.0.1:9090/stream?sourceKey=torrent%3A84acab5f&fileIndex=35':
+  Duration: 00:23:41.44, start: 0.000000, bitrate: 3195 kb/s
+  Stream #0:0: Video: h264 (High), yuv420p(progressive), 1920x1080 [SAR 1:1 DAR 16:9], 23.81 fps, 23.81 tbr, 1k tbn (default)
+  Stream #0:1(jpn): Audio: aac (LC), 44100 Hz, stereo, fltp (default)
+  Stream #0:2(eng): Subtitle: ass (ssa) (default)
+  Stream #0:3: Attachment: ttf
+Stream mapping:
+  Stream #0:0 -> #0:0 (h264 (native) -> wrapped_avframe (native))
+  Stream #0:1 -> #0:1 (aac (native) -> pcm_s16le (native))
+Output #0, null, to 'pipe:':
+  Stream #0:0: Video: wrapped_avframe, yuv420p(progressive), 1920x1080 [SAR 1:1 DAR 16:9], q=2-31, 200 kb/s, 23.81 fps, 23.81 tbn (default)
+  Stream #0:1(jpn): Audio: pcm_s16le, 44100 Hz, stereo, s16, 1411 kb/s (default)
+`;
+  assert.deepEqual(parseFfmpegStreamCounts(banner), { video: 1, audio: 1, subtitle: 1, other: 1 });
+});