@torrent-tv/proxy 2.89.12 → 2.89.13

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 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.13",
   "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/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}`);
+    }
+  }
+});