@torrent-tv/proxy 2.89.11 → 2.89.12

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 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.12",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "repository": {

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