@torrent-tv/proxy 2.99.3 → 2.99.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.99.3",
+  "version": "2.99.5",
   "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

@@ -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.

package/services/viewer/playback-readiness.js

@@ -251,11 +251,18 @@ export function predictPlaybackReadiness(input = {}) {
     const processingCoverage = numericCoverage((Array.isArray(track.processingRanges) ? track.processingRanges : [])
       .filter(range => Number.isFinite(range?.start) && Number.isFinite(range?.end) && range.end > range.start));
     const measuredBitsPerMediaSecond = state.bitsPerMediaSecond;
+    const trackSources = Array.isArray(track.sourceIds) ? track.sourceIds : [];
     for (const segment of segments) {
-      // Media the page already holds is not transferred again.
-      const needed = segment.ranges.filter((range) => compare(range.end, at) > 0);
-      if (segment.ranges.length > 0 && needed.every((range) =>
-        contains(state.clientRanges, latest(range.start, at), range.end))) {
+      // Media the page already holds is not transferred again: every range of
+      // the piece still ahead of the viewer lies inside what the page holds.
+      let held = segment.ranges.length > 0;
+      for (const range of segment.ranges) {
+        if (compare(range.end, at) > 0 && !contains(state.clientRanges, latest(range.start, at), range.end)) {
+          held = false;
+          break;
+        }
+      }
+      if (held) {
         continue;
       }
       const exactBytes = sizeOf(track.segmentSizesBytes, segment.index);
@@ -275,28 +282,30 @@ export function predictPlaybackReadiness(input = {}) {
       const remainingProcessing = uncoveredIntervals({ start: workStart, end: segment.endSeconds }, processingCoverage);
       const encodeWork = produced ? 0 : remainingProcessing.reduce((sum, part) => sum + part.end - part.start, 0);
 
-      const sourceByteIntervals = new Map();
+      let sourceByteIntervals = NO_SOURCE_BYTES;
       if (!produced && encodeWork > 0) {
+        // Each source the piece reads, in order and once: the track's own, then
+        // those its inputs name. Gathered with loops and no copies, because
+        // this runs for every piece still to play on every poll of a waiting
+        // viewer, and the sets and filtered lists it built were a quarter of
+        // the forecast's time on a two-hour film (torrent-tv/meta#178).
         const exactInputs = Array.isArray(segment.sourceInputs) ? segment.sourceInputs : null;
-        const requiredSources = new Set([
-          ...(Array.isArray(track.sourceIds) ? track.sourceIds : []),
-          ...(exactInputs ?? []).map(input => input?.sourceId)
-        ]);
-        for (const sourceId of requiredSources) {
+        const count = trackSources.length + (exactInputs?.length ?? 0);
+        for (let place = 0; place < count; place += 1) {
+          const sourceId = place < trackSources.length ? trackSources[place]
+            : exactInputs[place - trackSources.length]?.sourceId;
+          if (namedBefore(sourceId, place, trackSources, exactInputs)) continue;
           const source = sourceState.get(sourceId);
           if (!source) {
             unknownReason ??= "source-measurement-unavailable";
           } else if (source.source.complete !== true) {
-            if (exactInputs) {
-              const inputs = exactInputs.filter(input => input?.sourceId === sourceId);
-              const ranges = inputs.flatMap(input => Array.isArray(input.ranges) ? input.ranges : []);
-              if (!ranges.length || inputs.some(input => !Array.isArray(input.ranges) || !input.ranges.length) ||
-                  ranges.some(range => !range || !Number.isSafeInteger(range.start) || !Number.isSafeInteger(range.end) || range.start < 0 || range.end <= range.start)) {
-                unknownReason ??= "source-input-ranges-unavailable";
-              } else sourceByteIntervals.set(sourceId, ranges);
-              continue;
+            const ranges = exactInputs ? inputRangesOf(exactInputs, sourceId) : null;
+            if (ranges === null) {
+              unknownReason ??= "source-input-ranges-unavailable";
+            } else {
+              if (sourceByteIntervals === NO_SOURCE_BYTES) sourceByteIntervals = new Map();
+              sourceByteIntervals.set(sourceId, ranges);
             }
-            unknownReason ??= "source-input-ranges-unavailable";
           }
         }
       }
@@ -456,10 +465,14 @@ export function predictPlaybackReadiness(input = {}) {
     const prepared = state.clientRanges.map((range) => ({ ...range }));
     const lastRange = state.segments.at(-1).ranges.at(-1);
     const trackEnd = lastRange ? earliest(end, lastRange.end) : end;
+    // What the page holds without a gap from the viewer only changes when a
+    // piece is added to it, so the end after one piece is the end before the
+    // next.
+    let after = contiguousEnd(delivered, at);
     for (const completion of completions.filter((item) => item.trackIndex === trackIndex)) {
-      const before = contiguousEnd(delivered, at);
+      const before = after;
       for (const range of completion.segment.ranges) addMediaRange(delivered, range);
-      const after = contiguousEnd(delivered, at);
+      after = contiguousEnd(delivered, at);
       const ahead = secondsAhead(earliest(before, trackEnd), at);
       constrain(completion.at - ahead, "delivery", trackIndex, completion.segment.index, completion.at, ahead, false);
       if (compare(after, before) <= 0 && completion.segment.ranges.some(({ start }) => compare(start, before) > 0)) {
@@ -468,7 +481,7 @@ export function predictPlaybackReadiness(input = {}) {
         return result(false, null, buffered, reserve, null, 'media-continuity-unavailable', preparedSegments);
       }
     }
-    if (compare(contiguousEnd(delivered, at), trackEnd) < 0) {
+    if (compare(after, trackEnd) < 0) {
       // Everything this track still needs has been delivered in the schedule
       // and its media still stops short of the end: a hole between ranges
       // already held, which no arrival crosses.
@@ -807,6 +820,41 @@ function latestArrival(interval, ranges = []) {
   return finish;
 }
 
+/** A piece that reads no source byte still to arrive; never written to. */
+const NO_SOURCE_BYTES = new Map();
+
+/**
+ * Whether the source named at `place` of a piece's sources — the track's own,
+ * then those its inputs name — was named at an earlier place.
+ */
+function namedBefore(sourceId, place, trackSources, exactInputs) {
+  for (let earlier = 0; earlier < place; earlier += 1) {
+    const named = earlier < trackSources.length ? trackSources[earlier]
+      : exactInputs[earlier - trackSources.length]?.sourceId;
+    if (named === sourceId) return true;
+  }
+  return false;
+}
+
+/**
+ * The byte ranges a piece reads of one source, in the order its inputs state
+ * them, or null when an input of that source states none or one that is not a
+ * non-empty run of whole bytes.
+ */
+function inputRangesOf(exactInputs, sourceId) {
+  let ranges = null;
+  for (const input of exactInputs) {
+    if (input?.sourceId !== sourceId) continue;
+    if (!Array.isArray(input.ranges) || input.ranges.length === 0) return null;
+    for (const range of input.ranges) {
+      if (!range || !Number.isSafeInteger(range.start) || !Number.isSafeInteger(range.end) ||
+          range.start < 0 || range.end <= range.start) return null;
+    }
+    ranges = ranges === null ? input.ranges : ranges.concat(input.ranges);
+  }
+  return ranges;
+}
+
 /** Exact gaps in sorted disjoint numeric coverage, without per-range splitting. */
 function uncoveredIntervals(interval, served) {
   let low = 0, high = served.length;