@torrent-tv/proxy 2.89.11 → 2.89.13

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 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.
+
 ## 2.89.11
 
 - **Fix**: A failed encoder run says what the source holds again. The line `this run asked for …, and the source holds N video, N audio, N subtitle` was meant to tell an output with no stream (the source's fault) from a track index past the end (ours), but every field failure printed `what the source holds was not recorded`: a session takes its media info from the playback planner's cache, and the planner left the stream counts out of it although it parses the same ffmpeg banner. They are cached with the rest now.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.89.11",
+  "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/services/transport/data-channel-handler.js

@@ -761,6 +761,7 @@ export function createDataChannelHandler({
    * @returns {void}
    */
   function connectionGone(sessionId, because) {
+    deliveryProbe.forget(sessionId);
     const viewers = viewersOnConnection.get(sessionId);
     viewersOnConnection.delete(sessionId);
     if (!viewers || viewers.size === 0) {

package/services/transport/delivery-probe.js

@@ -414,6 +414,7 @@ export function readProbeState(state) {
  * @returns {{
  *   attach: (sessionId: string, tag: string, label: string, channel: import('node-datachannel').DataChannel) => void,
  *   detach: (sessionId: string, channel: import('node-datachannel').DataChannel) => void,
+ *   forget: (sessionId: string) => void,
  *   noteEcho: (sessionId: string, echo: object) => void,
  *   dispose: () => void
  * }}
@@ -699,6 +700,24 @@ export function createDeliveryProbe({
       }
     },
 
+    // The connection is gone, whether or not its channels said so. A peer
+    // connection closed moments after its channels opened gives no `onClosed`
+    // (field 2026-10-04: a trial connection closed 70 ms after opening was
+    // still probed hours later), so `detach` alone left a timer per such
+    // connection for the life of the process.
+    forget(sessionId) {
+      const connection = connections.get(sessionId);
+      if (!connection) {
+        return;
+      }
+      if (connection.timer !== null) {
+        clearInterval(connection.timer);
+        connection.timer = null;
+      }
+      connection.channels.clear();
+      connections.delete(sessionId);
+    },
+
     noteEcho(sessionId, echo) {
       const connection = connections.get(sessionId);
       if (!connection || !echo || typeof echo !== "object") {

package/test/data-channel-viewer-lifecycle.test.js

@@ -160,3 +160,34 @@ test("a viewer whose newest channel closed is reached on the older connection",
   assert.equal(cuesOn(old.control), 1);
   assert.deepEqual(gone, [], "the trial connection still has its media channel");
 });
+
+test("a connection the transport no longer knows is not probed any more, though no channel said it closed", (t) => {
+  t.mock.timers.enable({ apis: ["setInterval", "setTimeout", "Date"] });
+  let alive = true;
+  const handler = createDataChannelHandler({
+    proxyPort: 9090,
+    getTransportSnapshot: () => (alive ? { bytesSent: 0, bytesReceived: 0 } : null),
+    onViewerGone: () => {}
+  });
+  const channels = ["proxy", "proxy-control", "proxy-fast"].map((label) => new FakeDataChannel(label));
+  for (const channel of channels) {
+    handler.handleChannel("trial-peer", channel);
+  }
+  const probes = () =>
+    channels.reduce((sum, channel) => sum + channel.messages.filter((message) => message.includes('"probe"')).length, 0);
+  t.mock.timers.tick(2_000);
+  assert.ok(probes() > 0, "an open connection is probed");
+
+  // Field 2026-10-04: the peer connection closed 70 ms after its channels
+  // opened, and none of them reported `onClosed`.
+  alive = false;
+  const advance = (ms) => {
+    // Second by second: the watcher compares the clock between its own ticks,
+    // and one long jump lands every tick on the same instant.
+    for (let elapsed = 0; elapsed < ms; elapsed += 1_000) t.mock.timers.tick(1_000);
+  };
+  advance(30_000);
+  const afterGone = probes();
+  advance(30_000);
+  assert.equal(probes(), afterGone, "nothing is sent on a connection that is gone");
+});

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}`);
+    }
+  }
+});