@torrent-tv/proxy 2.99.4 → 2.99.6

package/package.json

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

package/services/media/container/MatroskaContainer.js

@@ -653,10 +653,16 @@ export class MatroskaContainer extends Container {
    * One preceding cluster retains preroll; one following cluster covers demux
    * lookahead beyond the presentation cut. No packet payload is parsed here.
    */
-  async supportsOriginalSourceRanges() {
+  async supportsOriginalSourceRanges(interval = null) {
     const cues = await this.readCues();
     if (!cues?.points.length) return false;
     const video = ContainerTrack.firstUsable(await this.readTracks(), "video");
+    // Sound alone is read from its own packets, as an AVI's is
+    // (`AviContainer`). From the original file it was given whole clusters,
+    // picture included: 260 MB for 23 pieces of a soundtrack, 38 MB for one of
+    // 171 KB, on Home Assistant (r44, r46, torrent-tv/meta#178). Asked of the
+    // file as a whole, the answer is the picture's.
+    if (video && interval?.trackIds?.length && !interval.trackIds.includes(video.trackNumber)) return false;
     return cues.points.some(point => point.positions.some(position => !video || position.track === video.trackNumber));
   }
 

package/services/transport/data-channel-handler.js

@@ -1248,7 +1248,9 @@ export function createDataChannelHandler({
           const loop = eventLoopDelay();
           const mbps = elapsedMs > 0 ? (totalBytes * 8) / (elapsedMs * 1000) : 0;
           log(
-            `[net-debug] sent ${path}${queryInfo} bytes=${totalBytes} fetchMs=${fetchMs} ` +
+            // The request's own id, so the page's line for the same answer can
+            // be read beside this one without comparing two machines' clocks.
+            `[net-debug] sent ${path}${queryInfo} requestId=${requestId} 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.
@@ -1335,54 +1337,86 @@ export function createDataChannelHandler({
   }
 
   /**
-   * Resolve once the channel's outgoing buffer has drained below the low-water
-   * mark. No-op (resolves immediately) when the buffer is already small or the
-   * channel does not expose buffer APIs. The previous implementation resolved
-   * after {@link DC_BUFFER_DRAIN_TIMEOUT_MS} even though the buffer was still
-   * high, so the send loop kept queueing into a wedged channel and the queue
-   * grew to 399 MB (field 2026-09-06). This version waits until the buffer
-   * actually drains, polling as a fallback for a missed low-water event, and
-   * never resolves while the channel is still holding bytes above the low-water
-   * mark.
+   * The send loops waiting on each channel for its library queue to empty. The
+   * native channel has one low-water callback, so it is set once per channel
+   * and wakes every loop waiting on it; each then reads the queue itself.
    *
+   * @type {WeakMap<DataChannel, Set<() => void>>}
+   */
+  const drainWaiters = new WeakMap();
+
+  /**
    * @param {DataChannel} channel
+   * @returns {Set<() => void> | null} Null for a channel that cannot say when its queue empties.
+   */
+  function drainWaitersOf(channel) {
+    let waiters = drainWaiters.get(channel);
+    if (waiters) return waiters;
+    if (typeof channel.onBufferedAmountLow !== "function" || typeof channel.setBufferedAmountLowThreshold !== "function") {
+      return null;
+    }
+    waiters = new Set();
+    drainWaiters.set(channel, waiters);
+    channel.setBufferedAmountLowThreshold(0);
+    channel.onBufferedAmountLow(() => {
+      for (const wake of [...waiters]) wake();
+    });
+    return waiters;
+  }
+
+  /**
+   * Resolve once the library holds nothing of this channel's that usrsctp has
+   * not yet taken, or the request is cancelled.
+   *
+   * WHY EMPTY, AND NOT A HIGH-WATER MARK. libdatachannel keeps ONE queue for
+   * every channel of a connection, first in first out (`SctpTransport::send`,
+   * v0.24.2), and usrsctp's own send buffer sits after it. A control answer —
+   * the forecast a held viewer waits for, a seek's acknowledgement — waits
+   * behind everything handed over before it, on every channel. With the 8 MiB
+   * mark this was, and with usrsctp's buffer sized by the 16 MiB message limit,
+   * probes on all three channels stood 2.8-5.1 s behind on Home Assistant while
+   * copied 1080p pieces of 11-12 MB crossed, and a viewer whose picture was
+   * already buffered was started that much later (r46, torrent-tv/meta#178).
+   * usrsctp's own buffer keeps the wire busy while this loop is away; whether
+   * it is deep enough for the rate and this thread's pauses is read from the
+   * `sent` line's rate and event-loop figures, not assumed.
+   *
+   * Cancellation ends the wait at once; elapsed time alone never resumes
+   * sending, so a wedged channel does not grow a queue (399 MB, field
+   * 2026-09-06).
+   *
+   * @param {DataChannel} channel
+   * @param {AbortSignal} signal
    * @returns {Promise<void>}
    */
   function waitForBufferDrain(channel, signal) {
     return new Promise((resolve) => {
       try {
-        if (signal.aborted || typeof channel.bufferedAmount !== "function" || channel.bufferedAmount() <= DC_BUFFER_HIGH_WATER) {
+        if (signal.aborted || typeof channel.bufferedAmount !== "function" || channel.bufferedAmount() <= 0) {
           resolve();
           return;
         }
-        let poll = null;
+        const waiters = drainWaitersOf(channel);
         let settled = false;
         const done = () => {
           if (settled) return;
           settled = true;
-          if (poll) clearInterval(poll);
+          waiters?.delete(wake);
           signal.removeEventListener("abort", done);
           resolve();
         };
-        signal.addEventListener("abort", done, { once: true });
-        // The native channel exposes one callback for all requests. Sampling
-        // avoids one request replacing another's callback. Cancellation ends
-        // the wait immediately; elapsed time alone never resumes sending.
-        poll = setInterval(() => {
+        const wake = () => {
           try {
-            if (channel.bufferedAmount() <= DC_BUFFER_LOW_WATER) {
-              done();
-            }
+            if (channel.bufferedAmount() <= 0) done();
           } catch {
             done();
           }
-        }, 50);
-        if (typeof poll.unref === "function") poll.unref();
-        // Guard against a race where the buffer drained between the check above
-        // and registering the callback (the low-water event would never fire).
-        if (channel.bufferedAmount() <= DC_BUFFER_LOW_WATER) {
-          done();
-        }
+        };
+        signal.addEventListener("abort", done, { once: true });
+        waiters?.add(wake);
+        // The queue may have emptied between the first reading and the
+        // registration, when no further low-water event would come.
+        wake();
         if (signal.aborted) done();
       } catch {
         resolve();
@@ -1461,6 +1495,3 @@ const TRANSPORT_HEARTBEAT_MS = 5_000;
 // registry does not end a healthy watch.
 const TRANSPORT_UNKNOWN_HEARTBEATS = 3;
 const SEND_QUEUE_STUCK_MS = 5_000;
-const DC_BUFFER_HIGH_WATER = 8 * 1024 * 1024;
-/** Resume sending once the channel buffer drains to this many bytes. */
-const DC_BUFFER_LOW_WATER = 1 * 1024 * 1024;

package/services/transport/webrtc-manager.js

@@ -26,16 +26,20 @@ const ICE_SERVERS = ["stun:stun.l.google.com:19302", "stun:stun.cloudflare.com:3
 const PORT_PREDICTION_WINDOW = 16;
 
 // Max size of a single data-channel message the proxy advertises (SDP
-// `a=max-message-size`) and will accept. The browser caps `channel.send()` at
-// the REMOTE's advertised value, so this is what lets the browser send a large
-// request body in one message — notably registering a source, whose body is
-// the base64-encoded .torrent. A big multi-season pack's .torrent (thousands of
-// piece hashes) can be hundreds of KB (e.g. Poirot: 420 KB → ~560 KB base64),
-// which exceeds libdatachannel's ~256 KB default and made `send()` throw
-// "message larger than max-message-size". 16 MB is a generous ceiling (memory
-// is allocated per actual message, not reserved). Responses (proxy→browser)
-// are already safe — they stream in small reader-sized chunks.
-const MAX_DC_MESSAGE_BYTES = 16 * 1024 * 1024;
+// `a=max-message-size`) and will accept: libdatachannel's own default.
+//
+// It was 16 MiB so that a page could send a large .torrent in one message
+// (Poirot: ~560 KB base64). The page has cut every request body above 128 KiB
+// into 64 KiB frames since server 0.8.58 (`REQUEST_CHUNK_BYTES`), and the
+// proxy's responses go in reader-sized frames, so no message needs more.
+//
+// What 16 MiB also did: libdatachannel sizes usrsctp's send buffer to at least
+// this value (`SctpTransport`, v0.24.2), and its queue is shared by every
+// channel of a connection. A forecast answer or a probe then waited behind up
+// to 16 MiB of video: 2.8-5.1 s on Home Assistant while copied 1080p pieces
+// crossed (r46, torrent-tv/meta#178). At the default the buffer is the 1 MiB
+// libdatachannel gives usrsctp (`SctpTransport::SetSettings`).
+const MAX_DC_MESSAGE_BYTES = 256 * 1024;
 
 /**
  * Build predicted srflx ICE candidates for a symmetric NAT.