@torrent-tv/proxy 2.83.6 → 2.83.7

package/server.js

@@ -354,7 +354,8 @@ export async function startProxyServer({
       sourceRegistry,
       torrentPool,
       ffmpegBin,
-      localBaseUrl: hlsSessionManager.localBaseUrl
+      localBaseUrl: hlsSessionManager.localBaseUrl,
+      viewers: hlsSessionManager.viewers
     })
   );
   app.get("/stream", async (req, reply) =>

package/services/data-channel-handler.js

@@ -45,7 +45,6 @@
 
 /** @import { DataChannel } from 'node-datachannel' */
 
-import { deriveSourceKey } from "./torrent-source-key.js";
 import { createDeliveryProbe, PROBE_INTERVAL_MS } from "./delivery-probe.js";
 
 /**
@@ -582,11 +581,79 @@ export function encodeFrame(idBytes, bytes, done) {
   return frame;
 }
 
+/**
+ * Reshapes a body into messages of `sizeBytes` each, handing every finished one
+ * to `sendOne`. A size of zero passes each body read through untouched, which
+ * is what the field does today — 10 657 210 bytes over 163 messages, so 65 382
+ * each, measured 2026-09-12.
+ *
+ * Only the SIZE changes: the same bytes reach the far end in the same order,
+ * over the same channel. That is what makes a comparison between two sizes a
+ * comparison of one thing, and it is why the wedge's dependence on the size can
+ * be measured at all — the wedge of 2026-09-12 arrived in the middle of one
+ * message, with 63 % of a segment on the wire and then nothing.
+ *
+ * @param {(bytes: Uint8Array) => void} sendOne - Given each finished message.
+ * @param {number}                      sizeBytes - 0 to leave reads as they are.
+ * @returns {{ push: (bytes: Uint8Array) => number, flush: () => number }}
+ *   Both answer how many messages they sent, so a caller counting messages
+ *   counts messages rather than body reads.
+ */
+export function bodySender(sendOne, sizeBytes) {
+  if (!(sizeBytes > 0)) {
+    return {
+      push(bytes) {
+        sendOne(bytes);
+        return 1;
+      },
+      flush() {
+        return 0;
+      }
+    };
+  }
+  /** @type {Uint8Array[]} */
+  let held = [];
+  let heldBytes = 0;
+  const release = () => {
+    const message = held.length === 1 ? held[0] : Buffer.concat(held);
+    held = [];
+    heldBytes = 0;
+    sendOne(message);
+  };
+  return {
+    push(bytes) {
+      let sent = 0;
+      let offset = 0;
+      while (offset < bytes.length) {
+        const take = Math.min(sizeBytes - heldBytes, bytes.length - offset);
+        held.push(bytes.subarray(offset, offset + take));
+        heldBytes += take;
+        offset += take;
+        if (heldBytes === sizeBytes) {
+          release();
+          sent += 1;
+        }
+      }
+      return sent;
+    },
+    flush() {
+      if (heldBytes === 0) return 0;
+      release();
+      return 1;
+    }
+  };
+}
+
 export function createDataChannelHandler({
   proxyPort,
   onLog,
   getTransportSnapshot,
-  sourceRegistry,
+  // Who wants pushed subtitle cues for a file, BY NAME. A plain function
+  // returning opaque ids: this layer never learns what a viewer is, and the
+  // subscription it used to hold against a channel — and had to sniff
+  // `/api/subtitles` to build — now belongs to the person and outlives the
+  // channel, a reconnect and a deliberate rotation alike.
+  viewersWantingCues = () => [],
   witness,
   // Reads usrsctp's own association state (services/usrsctp-state.js) the
   // moment a wedge is declared, from either detector below. Optional: a host
@@ -599,7 +666,14 @@ export function createDataChannelHandler({
   // released a viewer when their connection closed: the only exits were the
   // browser's own `release` and a silence long enough to be called an absence.
   onViewerPresent = () => {},
-  onViewerGone = () => {}
+  onViewerGone = () => {},
+  // The size of one data-channel message carrying body bytes. Zero keeps
+  // whatever the body read hands over, which in the field is 65 382 bytes —
+  // 10 657 210 over 163 chunks, measured 2026-09-12. It is settable because
+  // that day's wedge arrived in the MIDDLE of one message (63 % of a segment
+  // on the wire, then nothing), and whether the fault depends on the size is
+  // the one branch no capture has been able to close.
+  sendChunkBytes = 0
 }) {
   /**
    * Who is on each connection, by WebRTC session id.
@@ -639,40 +713,30 @@ export function createDataChannelHandler({
     }
   }
   /**
-   * Channels currently interested in one file's subtitle cues, keyed by
-   * `sourceKey:fileIndex`. Populated the moment a browser asks for an
-   * embedded track — there is no separate subscribe message on the wire, the
-   * existing `/api/subtitles` request already says which file a viewer opened
-   * subtitles for. Pruned on channel close and, defensively, on a failed send.
+   * The channel each viewer is reachable on right now, by the name the far end
+   * presented when it opened.
    *
-   * @type {Map<string, Set<DataChannel>>}
+   * The transport knows a NAME and nothing else about a viewer: what it means,
+   * who holds it and what they are watching are somebody else's facts. Keeping
+   * only "this name is reachable here" is what lets a subscription made once
+   * outlive the channel it was made on — a reconnect, and a rotation done on
+   * purpose, both just rewrite this entry.
+   *
+   * @type {Map<string, DataChannel>}
    */
-  const subtitleSubscribers = new Map();
+  const channelOfViewer = new Map();
 
   /**
-   * @param {string} sourceKey
-   * @param {number} fileIndex
+   * Forget every name that was reachable on this channel.
+   *
    * @param {DataChannel} channel
    * @returns {void}
    */
-  function subscribeSubtitles(sourceKey, fileIndex, channel) {
-    const key = `${sourceKey}:${fileIndex}`;
-    let set = subtitleSubscribers.get(key);
-    if (!set) {
-      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 */
-  function unsubscribeSubtitlesAll(channel) {
-    for (const set of subtitleSubscribers.values()) {
-      set.delete(channel);
+  function forgetChannel(channel) {
+    for (const [consumerId, on] of channelOfViewer) {
+      if (on === channel) {
+        channelOfViewer.delete(consumerId);
+      }
     }
   }
 
@@ -688,30 +752,37 @@ export function createDataChannelHandler({
    * @returns {void}
    */
   function publishSubtitleCues({ sourceKey, fileIndex, trackIndex, cues, language, detectedLanguage, cursor }) {
-    const set = subtitleSubscribers.get(`${sourceKey}:${fileIndex}`);
-    if (!set || set.size === 0) {
+    const names = viewersWantingCues(sourceKey, fileIndex);
+    if (names.length === 0) {
       log(
         `[dc] subtitle push: ${cues.length} cue(s) for ${sourceKey.slice(0, 8)}:${fileIndex} track ${trackIndex} ` +
-        "found no subscribed channel"
+        "found nobody who wants them"
       );
       return;
     }
-    const message = { type: "subtitle-cues", fileIndex, trackIndex, cues, language, detectedLanguage, cursor };
-    const total = set.size;
+    const message = JSON.stringify({
+      type: "subtitle-cues", fileIndex, trackIndex, cues, language, detectedLanguage, cursor
+    });
     let sent = 0;
-    for (const channel of set) {
+    for (const consumerId of names) {
+      const channel = channelOfViewer.get(consumerId);
+      if (!channel) {
+        // Subscribed but not reachable this instant — between connections, or
+        // rotating. Nothing is dropped: they are still subscribed, and the walk
+        // keeps a per-viewer cursor, so what they missed comes on the next ask.
+        continue;
+      }
       try {
-        channel.sendMessage(JSON.stringify(message));
+        channel.sendMessage(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);
+        // Closed between the lookup and the send. The subscription belongs to
+        // the person and stays; only this delivery is lost.
       }
     }
     log(
       `[dc] subtitle push: sent ${cues.length} cue(s) for ${sourceKey.slice(0, 8)}:${fileIndex} track ${trackIndex} ` +
-      `to ${sent}/${total} channel(s)`
+      `to ${sent}/${names.length} viewer(s)`
     );
   }
 
@@ -914,6 +985,7 @@ export function createDataChannelHandler({
         const isNew = !known.has(message.consumerId);
         known.add(message.consumerId);
         viewersOnConnection.set(sessionId, known);
+        channelOfViewer.set(message.consumerId, channel);
         if (isNew) {
           log(`[dc] Session ${tag}: viewer ${message.consumerId} is on this connection`);
         }
@@ -952,7 +1024,7 @@ export function createDataChannelHandler({
         clearTimeout(entry.timer);
       }
       partials.clear();
-      unsubscribeSubtitlesAll(channel);
+      forgetChannel(channel);
       log(`[dc] Session ${tag}: channel closed`);
       // The ordinary way a viewer leaves, and the only one that is immediate.
       // Everything else — a silence long enough to be called an absence, the
@@ -988,45 +1060,6 @@ export function createDataChannelHandler({
       return;
     }
 
-    // Piggy-backs on the browser's own request for an EMBEDDED track — no
-    // separate subscribe message. `trackIndex` is what tells the two request
-    // shapes apart: an external subtitle FILE (no trackIndex) names a
-    // different file's own index in `fileIndex` — the subtitle file's, not the
-    // video's — and subscribing under that would just be a key nothing ever
-    // publishes to (an external file is one whole-file read, not something
-    // 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 registrySourceKey = params.get("sourceKey");
-      const fileIndex = Number(params.get("fileIndex"));
-      const hasTrackIndex = params.get("trackIndex") !== null && params.get("trackIndex") !== "";
-      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}`);
-          }
-        }
-      }
-    }
 
     const queryInfo = query ? `?${query}` : "";
     const bodyInfo =
@@ -1092,12 +1125,14 @@ export function createDataChannelHandler({
       let readMs = 0;
       let sendMs2 = 0;
       let drainMs = 0;
+      const body = bodySender((bytes) => sendChunk(channel, requestId, bytes, false), sendChunkBytes);
       resetEventLoopDelay();
       while (true) {
         const readStartedAt = performance.now();
         const { done, value } = await reader.read();
         readMs += performance.now() - readStartedAt;
         if (done) {
+          chunks += body.flush();
           sendChunk(channel, requestId, null, true);
           const elapsedMs = Date.now() - sendStartedAt;
           let bufferedNow = 0;
@@ -1107,6 +1142,9 @@ export function createDataChannelHandler({
           log(
             `[net-debug] sent ${path}${queryInfo} bytes=${totalBytes} fetchMs=${fetchMs} ` +
               `ttfbMs=${firstByteMs} sendMs=${elapsedMs} chunks=${chunks} ` +
+              // The size of one message, so a reading can be attributed to the
+              // size it was taken at rather than to the run it came from.
+              `msgBytes=${sendChunkBytes > 0 ? sendChunkBytes : "asread"} ` +
               `maxBuffered=${maxBuffered} bufferedAtEnd=${bufferedNow} ` +
               // Where the time went: reading the body from the local route,
               // handing chunks to the channel, or waiting for its queue. Plus
@@ -1120,14 +1158,13 @@ export function createDataChannelHandler({
           break;
         }
         if (firstByteMs < 0) firstByteMs = Date.now() - sendStartedAt;
-        chunks += 1;
         totalBytes += value.length;
         try {
           const b = typeof channel.bufferedAmount === "function" ? channel.bufferedAmount() : 0;
           if (b > maxBuffered) maxBuffered = b;
         } catch { /* ignore */ }
         const sendStepAt = performance.now();
-        sendChunk(channel, requestId, value, false);
+        chunks += body.push(value);
         sendMs2 += performance.now() - sendStepAt;
         // Backpressure: do not keep queuing chunks once the channel's outgoing
         // buffer is large — wait for it to drain. Prevents the SCTP send buffer