@torrent-tv/proxy 2.55.5 → 2.55.7

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 2.55.7
+
+- **Fix**: The subtitle push subscription is now recorded under the torrent pool's own key, not the browser's registry key — the two are different strings whenever a source was added by a `.torrent` file (a `.torrent` and a magnet for the same film are different request bytes, hashed into different registry keys, but the SAME infohash) and were silently different in every other case too: a registry key is `sha1(sourceType:source)`, one per API session; the pool's key is `torrent:<infohash>`, deliberately shared across a magnet and a `.torrent` for the same content (item 10). The diagnostic logging added in 2.55.6 caught it directly, field case 2026-08-22: cues were found and logged repeatedly, and every push answered `found no subscribed channel` — the subscription and the publish had never been able to agree on a key, for any torrent, since the push feature shipped in 2.55.5. `data-channel-handler.js` now resolves the browser's registry key through `sourceRegistry` to `(sourceType, source)` and runs it through the same `deriveSourceKey` the pool itself uses, at the one point both keys are in hand — the subscribe intercept, before the request is even forwarded.
+
+## 2.55.6
+
+- **Chore**: Every step of the subtitle push chain now logs on success, not only on failure. Field report 2026-08-22, playing `Minions.and.Monsters.1080p.mkv`: a track was switched on over a minute after the seed fetch found nothing (`bytes=7`, an empty `WEBVTT` — expected, the torrent had barely started), and no cues appeared. The proxy log carried no evidence either way — `warmActiveFiles` posted `Event.SUBTITLE_CUES_READY` silently, `publishSubtitleCues` sent (or found no subscriber for) a push silently, and `subscribeSubtitles` registered a channel silently. Confirmed separately by reading WebTorrent's own source that `verified` fires on every live piece completion (`_markVerified` inside `store.put`'s callback in `torrent.js`, not only at startup), so the event source itself is real; what could not be told apart without these lines is subscription, discovery, and delivery. Logs now name each: `subtitle push: channel subscribed to …`, `… cue(s) found, posting to main thread`, `… sent N cue(s) … to M/T channel(s)` (or `found no subscribed channel`).
+
 ## 2.55.5
 
 - **New**: Subtitle cues are now PUSHED to the browser the moment they are read, over the WebRTC data channel — not fetched by the browser on a timer. Every declared track was already being warmed off the piece-`verified` event (2.55.4); what changed is that the result now travels to the browser unprompted instead of sitting on the proxy until the next poll asked for it. `data-channel-handler.js` remembers which channel last asked about a file's subtitles (piggy-backing on the browser's own first `/api/subtitles?trackIndex=` request — no separate subscribe message) and sends new cues there directly (`{ type: "subtitle-cues", fileIndex, trackIndex, cues, language }`), for every track the container declares, not only the one on screen. Rides the existing `proxy-control` data channel — the same one the request itself used, which is never the one carrying segment bytes, so a push cannot queue behind video. `finalizeCues` (end-time synthesis + ASS-dialogue stripping) is factored out of the HTTP route into `services/torrent-worker/subtitle-cues.js` so a pushed cue and a pulled one are built the same way. A browser's one-off seed fetch per track (for whatever is already read at the moment a file opens) and the external-subtitle-FILE path (`.srt`/`.ass` beside the video — a single whole-file read, no incremental delivery to begin with) are unchanged.

package/bin/cli.js

@@ -300,6 +300,7 @@ try {
   });
   app = started.app;
   actualPort = started.port;
+  const sourceRegistry = started.sourceRegistry;
   const directBaseUrl = explicitBaseUrl || `http://${bindHost}:${actualPort}`;
 
   // A native fault writes the whole address space out — 4.18 GB each on the
@@ -421,6 +422,10 @@ try {
   dataChannelHandler = createDataChannelHandler({
     proxyPort: actualPort,
     onLog: (message) => logger.info(message),
+    // Resolves a browser's registry sourceKey to the torrent pool's own key
+    // (the content's infohash) so the subtitle push subscription and the
+    // pool's own publish agree on what a source is called. See server.js.
+    sourceRegistry,
     // Lets a stuck send queue ask the transport what it is doing. Late-bound:
     // the manager is created below, with this handler already in hand.
     getTransportSnapshot: (sessionId) => webRtcManager?.getTransportSnapshot(sessionId) ?? null

package/package.json

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

package/server.js

@@ -290,6 +290,14 @@ export async function startProxyServer({
   await app.listen({ host, port: selectedPort });
   return {
     app,
-    port: selectedPort
+    port: selectedPort,
+    // The browser only ever knows a source by its REGISTRY key (a hash of the
+    // raw request bytes, scoped to one API session) — never the torrent
+    // pool's own key (the content's infohash, shared across a magnet and a
+    // `.torrent` naming the same film). The subtitle push subscription is
+    // recorded from a browser request and published from the pool's side, so
+    // resolving one into the other is what lets the two ends agree on what
+    // they are both calling "sourceKey".
+    sourceRegistry
   };
 }

package/services/data-channel-handler.js

@@ -43,6 +43,8 @@
 
 /** @import { DataChannel } from 'node-datachannel' */
 
+import { deriveSourceKey } from "./torrent-source-key.js";
+
 /**
  * Configuration for the data channel handler.
  *
@@ -299,7 +301,7 @@ export function encodeFrame(idBytes, bytes, done) {
   return frame;
 }
 
-export function createDataChannelHandler({ proxyPort, onLog, getTransportSnapshot }) {
+export function createDataChannelHandler({ proxyPort, onLog, getTransportSnapshot, sourceRegistry }) {
   /**
    * Channels currently interested in one file's subtitle cues, keyed by
    * `sourceKey:fileIndex`. Populated the moment a browser asks for an
@@ -324,7 +326,11 @@ export function createDataChannelHandler({ proxyPort, onLog, getTransportSnapsho
       set = new Set();
       subtitleSubscribers.set(key, set);
     }
+    const isNew = !set.has(channel);
     set.add(channel);
+    if (isNew) {
+      log(`[dc] subtitle push: channel subscribed to ${key} (${set.size} channel(s) now)`);
+    }
   }
 
   /** @param {DataChannel} channel */
@@ -346,18 +352,29 @@ export function createDataChannelHandler({ proxyPort, onLog, getTransportSnapsho
   function publishSubtitleCues({ sourceKey, fileIndex, trackIndex, cues, language }) {
     const set = subtitleSubscribers.get(`${sourceKey}:${fileIndex}`);
     if (!set || set.size === 0) {
+      log(
+        `[dc] subtitle push: ${cues.length} cue(s) for ${sourceKey.slice(0, 8)}:${fileIndex} track ${trackIndex} ` +
+        "found no subscribed channel"
+      );
       return;
     }
     const message = { type: "subtitle-cues", fileIndex, trackIndex, cues, language };
+    const total = set.size;
+    let sent = 0;
     for (const channel of set) {
       try {
         channel.sendMessage(JSON.stringify(message));
+        sent += 1;
       } catch {
         // Closed between the subscription and this send; onClosed will not
         // fire for a channel that is already gone, so drop it here too.
         set.delete(channel);
       }
     }
+    log(
+      `[dc] subtitle push: sent ${cues.length} cue(s) for ${sourceKey.slice(0, 8)}:${fileIndex} track ${trackIndex} ` +
+      `to ${sent}/${total} channel(s)`
+    );
   }
 
   /** Request id → its ASCII bytes; see {@link requestIdBytes}. */
@@ -564,13 +581,34 @@ export function createDataChannelHandler({ proxyPort, onLog, getTransportSnapsho
     // this walks incrementally). `fileIndex` alone would also scope this to
     // the wrong grain for the real case — a torrent can carry several playable
     // files — so the pair is what a push is ever addressed to.
+    //
+    // The browser's `sourceKey` is a REGISTRY key — a hash of the raw request
+    // bytes, one per (magnet-or-.torrent, this API session). The torrent pool
+    // publishes under its OWN key — the content's infohash, deliberately the
+    // SAME for a magnet and a `.torrent` naming the same film, so the two
+    // share one swarm (item 10). The two are different strings for the same
+    // torrent whenever a source was added by its `.torrent` file (a `.torrent`
+    // and a magnet are different request bytes, same infohash) — subscribing
+    // under the registry key found no publisher for that reason, not because
+    // nothing was ever read: field case 2026-08-22, cues were found and
+    // logged, every push answered "found no subscribed channel". Resolved to
+    // the pool's key here, the one place both are in hand.
     if (path === "/api/subtitles" && typeof query === "string") {
       const params = new URLSearchParams(query);
-      const sourceKey = params.get("sourceKey");
+      const registrySourceKey = params.get("sourceKey");
       const fileIndex = Number(params.get("fileIndex"));
       const hasTrackIndex = params.get("trackIndex") !== null && params.get("trackIndex") !== "";
-      if (sourceKey && Number.isInteger(fileIndex) && hasTrackIndex) {
-        subscribeSubtitles(sourceKey, fileIndex, channel);
+      if (registrySourceKey && Number.isInteger(fileIndex) && hasTrackIndex) {
+        const record = sourceRegistry?.get(registrySourceKey);
+        if (record) {
+          try {
+            const poolSourceKey = await deriveSourceKey(record.sourceType, record.source);
+            subscribeSubtitles(poolSourceKey, fileIndex, channel);
+          } catch (error) {
+            log(`[dc] subtitle push: could not resolve ${registrySourceKey.slice(0, 8)} to a pool key: ` +
+              `${error instanceof Error ? error.message : error}`);
+          }
+        }
       }
     }
 

package/services/torrent-worker/worker.js

@@ -525,6 +525,10 @@ function warmActiveFiles(sourceKey, torrent) {
     warmSubtitleCues(torrent, fileIndex, sourceKey)
       .then((fresh) => {
         for (const entry of fresh) {
+          log(
+            `subtitle push ${sourceKey.slice(0, 8)}:${fileIndex} track ${entry.trackIndex}: ` +
+            `${entry.cues.length} new cue(s) found, posting to main thread`
+          );
           parentPort.postMessage({
             type: Event.SUBTITLE_CUES_READY,
             sourceKey,