@torrent-tv/proxy 2.89.10 → 2.89.12

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 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.
+
 ## 2.89.10
 
 - **Fix**: An audio track warm-up that is still being made answers `503` with `warming: true`. That answer means the track and how it is produced are recorded for the viewer; a `503` without it is a preparation that failed and recorded nothing. Until now the two were the same status, so a page restating its soundtrack after a reconnect could not tell whether the proxy had kept it.

package/package.json

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

package/services/media/playback-planner.js

@@ -16,7 +16,8 @@ import {
   parseFfmpegBitDepth,
   parseFfmpegBitrateKbps,
   parseFfmpegVideoFps,
-  parseFfmpegHdr
+  parseFfmpegHdr,
+  parseFfmpegStreamCounts
 } from "./ffmpeg-banner.js";
 
 /** Audio codecs that browsers can decode natively without transcoding. */
@@ -912,7 +913,12 @@ export function createPlaybackPlanner({
           fps: videoFacts.fps,
           startTime: parseFfmpegStartTimeSeconds(probe.stderr),
           isHdr: videoFacts.isHdr,
-          bitDepth: videoFacts.bitDepth
+          bitDepth: videoFacts.bitDepth,
+          // What the source holds, from this same banner. A failed run reads it
+          // to say whose fault an output with no stream is, and a session takes
+          // its media info from this cache without probing again — so a field
+          // left out here was "not recorded" on every failure (field 2026-09-29).
+          streamCounts: parseFfmpegStreamCounts(probe.stderr)
         });
         // Warm the file-body start for the transcode session that follows.
         // Fire-and-forget: never delays the plan response.

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