@torrent-tv/proxy 2.80.5 → 2.80.6

package/services/data-channel-handler.js

@@ -119,10 +119,10 @@ import { createDeliveryProbe, PROBE_INTERVAL_MS } from "./delivery-probe.js";
  * @returns {{ certain: boolean, needMs: number | null }}
  */
 export function wedgeIsCertain({ queuedBytes, bytesPerSecond, flatForMs, longestHealthyFlatMs = 0 }) {
-  if (!(queuedBytes > 0) || !(bytesPerSecond > 0)) {
+  if (!(bytesPerSecond > 0)) {
     return { certain: false, needMs: null };
   }
-  const drainMs = (queuedBytes / bytesPerSecond) * 1000;
+  const drainMs = (Math.max(queuedBytes, 0) / bytesPerSecond) * 1000;
   const needMs = Math.max(drainMs, longestHealthyFlatMs, PROBE_INTERVAL_MS);
   return { certain: flatForMs >= needMs, needMs };
 }
@@ -221,6 +221,37 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
     };
   };
 
+  /**
+   * Update the browser-side channel byte counter for a session.
+   *
+   * The transport's `bytesReceived` advances on SACKs (140 B/s on a wedged
+   * association) even though every data channel is flat — so it gives a false
+   * "peer still sending" through every other tick (field 2026-09-06: 6 h 50 min
+   * wedge, `flowing`/`association-stopped` alternating every 500 ms). Channel
+   * counters are in the same `probe-echo` report and are flat on a wedge.
+   *
+   * @param {string} sessionId
+   * @param {object} report - The `report` object from `probe-echo`.
+   * @returns {void}
+   */
+  const noteBrowserReport = (sessionId, report) => {
+    const connection = connections.get(sessionId);
+    if (!connection || !report || typeof report !== "object") return;
+    const channels = report.channels;
+    if (!channels || typeof channels !== "object") return;
+    let total = 0;
+    let hasBytes = false;
+    for (const v of Object.values(channels)) {
+      if (v && typeof v.bytes === "number" && Number.isFinite(v.bytes)) {
+        total += v.bytes;
+        hasBytes = true;
+      }
+    }
+    if (hasBytes) {
+      connection.browserChannelBytes = total;
+    }
+  };
+
   /**
    * @param {string} sessionId
    * @param {string} tag
@@ -228,7 +259,7 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
    * @param {DataChannel} channel
    * @returns {() => void} Stops the watch.
    */
-  const watchSendQueue = (sessionId, tag, label, channel) => {
+   const watchSendQueue = (sessionId, tag, label, channel) => {
     let lowestSinceDrain = Number.POSITIVE_INFINITY;
     let stuckSince = 0;
     let previous = null;
@@ -243,6 +274,7 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
     // would be cleared a second after the wedged channel set it and the line
     // would print for every second of a 54-minute episode.
     let wedgeSaid = false;
+    let lastStuckLogAt = 0;
     let connection = connections.get(sessionId);
     if (!connection) {
       connection = {
@@ -257,7 +289,12 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
         sentAt: 0,
         sentBytes: 0,
         bytesPerSecond: 0,
-        longestHealthyFlatMs: 0
+        longestHealthyFlatMs: 0,
+        // Browser-side channel bytes (sum of report.channels[].bytes). Transport's
+        // bytesReceived advances on SACKs (140 B/s on a wedge) and gives a false
+        // "peer still sending" every other tick — channel bytes are flat on a wedge.
+        browserChannelBytes: 0,
+        browserChannelBytesAtStuck: -1
       };
       connections.set(sessionId, connection);
     }
@@ -395,6 +432,7 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
         stuckSince = 0;
         previous = null;
         receivedWhenStuck = -1;
+        connection.browserChannelBytesAtStuck = -1;
         wedgeSaid = false;
         // The queue moved, so whatever was called a wedge has cleared. Let a
         // later one be recorded too: one mistaken call must not spend the
@@ -409,7 +447,8 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
       }
       const snapshot = getTransportSnapshot?.(sessionId) ?? null;
       if (!snapshot) {
-        if (now - stuckSince >= SEND_QUEUE_STUCK_MS) {
+        if (now - stuckSince >= SEND_QUEUE_STUCK_MS && now - lastStuckLogAt >= 30_000) {
+          lastStuckLogAt = now;
           log(`[dc] Session ${tag} "${label}": send queue stuck at ${queued}B for ` +
             `${Math.round((now - stuckSince) / 1000)}s — no transport to ask`);
         }
@@ -421,6 +460,9 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
       if (receivedWhenStuck < 0) {
         receivedWhenStuck = snapshot.bytesReceived;
       }
+      if (connection.browserChannelBytesAtStuck < 0) {
+        connection.browserChannelBytesAtStuck = connection.browserChannelBytes;
+      }
       // The periodic line waits for {@link SEND_QUEUE_STUCK_MS}, because a
       // queue that has merely not fallen for a second is ordinary and a line a
       // second for it is noise. The WEDGE below does not wait for it: its own
@@ -428,15 +470,18 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
       // on a fast link that is under a second. Holding the evidence back for a
       // fixed five seconds would repeat, in miniature, the mistake that left
       // both field captures without an onset in them.
-      if (now - stuckSince >= SEND_QUEUE_STUCK_MS) {
+      // Rate-limit to 30 s — field 2026-09-06 printed 49 295 lines (31 % of log)
+      // for one 6 h 50 min wedge, one line per second per channel.
+      if (now - stuckSince >= SEND_QUEUE_STUCK_MS && now - lastStuckLogAt >= 30_000) {
+        lastStuckLogAt = now;
         log(
           `[dc] Session ${tag} "${label}": send queue stuck at ${queued}B for ` +
-          `${Math.round((now - stuckSince) / 1000)}s — transport ` +
-          `sent=${snapshot.bytesSent}${sentDelta === null ? "" : ` (+${sentDelta})`} ` +
-          `received=${snapshot.bytesReceived}${recvDelta === null ? "" : ` (+${recvDelta})`} ` +
-          `rtt=${snapshot.rtt}ms pc=${snapshot.state} ice=${snapshot.iceState} pair=${snapshot.pair}`
+            `${Math.round((now - stuckSince) / 1000)}s — transport ` +
+            `sent=${snapshot.bytesSent}${sentDelta === null ? "" : ` (+${sentDelta})`} ` +
+            `received=${snapshot.bytesReceived}${recvDelta === null ? "" : ` (+${recvDelta})`} ` +
+            `rtt=${snapshot.rtt}ms pc=${snapshot.state} ice=${snapshot.iceState} pair=${snapshot.pair}`
         );
-      }
+      }
       // Roadmap item 11: ask for the packet-level truth the moment the wedge is
       // CERTAIN, not after a chosen delay. The three facts below are not
       // ambiguous together — the queue has not fallen, the accepted-byte
@@ -452,7 +497,10 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
         flatForMs,
         longestHealthyFlatMs: connection.longestHealthyFlatMs
       });
-      const peerStillSending = snapshot.bytesReceived > receivedWhenStuck;
+      const hasBrowserBytes = Number.isFinite(connection.browserChannelBytes) && connection.browserChannelBytesAtStuck >= 0;
+      const peerStillSending = hasBrowserBytes
+        ? connection.browserChannelBytes > connection.browserChannelBytesAtStuck
+        : snapshot.bytesReceived > receivedWhenStuck;
       if (verdict.certain && peerStillSending && !wedgeSaid) {
         wedgeSaid = true;
         log(
@@ -470,7 +518,7 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
         peerStillSending
       ) {
         connection.captureStarted = true;
-        const started = witness.maybeCapture({
+        witness.maybeCapture({
           sessionId,
           tag,
           label,
@@ -478,12 +526,6 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
           queuedBytes: queued,
           stuckForMs: now - stuckSince
         });
-        if (!started) {
-          // Refused for now (no remote endpoint yet, capture already running
-          // elsewhere, cooldown): let the next tick try again rather than
-          // spending the one attempt per wedge on a refusal.
-          connection.captureStarted = false;
-        }
       }
       if (usrsctpState && verdict.certain && peerStillSending) {
         // Its own single-flight and cooldown, independent of the witness's —
@@ -501,7 +543,7 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
     return stop;
   };
 
-  return { watchSendQueue, readDelivery };
+  return { watchSendQueue, readDelivery, noteBrowserReport };
 }
 
 /**
@@ -676,7 +718,7 @@ export function createDataChannelHandler({
   /** Request id → its ASCII bytes; see {@link requestIdBytes}. */
   const requestIdCache = new Map();
 
-  const { watchSendQueue, readDelivery } = makeSendQueueWatcher({
+  const { watchSendQueue, readDelivery, noteBrowserReport } = makeSendQueueWatcher({
     log: (message) => log(message),
     getTransportSnapshot,
     witness,
@@ -884,6 +926,7 @@ export function createDataChannelHandler({
       // on working through a freeze, so it arrives when nothing else does.
       if (message.type === "probe-echo") {
         deliveryProbe.noteEcho(sessionId, message);
+        noteBrowserReport(sessionId, message.report);
         if (message.report && typeof message.report === "object") {
           const report = message.report;
           const channels = report.channels && typeof report.channels === "object"
@@ -1142,8 +1185,13 @@ 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. A timeout fallback guards against a
-   * missed low-water event so the send loop can never deadlock.
+   * 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.
    *
    * @param {DataChannel} channel
    * @returns {Promise<void>}
@@ -1155,21 +1203,35 @@ export function createDataChannelHandler({
           resolve();
           return;
         }
+        let poll = null;
         let settled = false;
         const done = () => {
           if (settled) return;
           settled = true;
+          if (poll) clearInterval(poll);
+          try { channel.onBufferedAmountLow(() => {}); } catch {}
           resolve();
         };
         channel.setBufferedAmountLowThreshold(DC_BUFFER_LOW_WATER);
         channel.onBufferedAmountLow(done);
+        // Poll as a fallback for a missed low-water event — the previous
+        // 5 s timeout resolved while the buffer was still high, which is the
+        // defect. Polling waits until the condition is actually met.
+        poll = setInterval(() => {
+          try {
+            if (channel.bufferedAmount() <= DC_BUFFER_LOW_WATER) {
+              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();
-          return;
         }
-        setTimeout(done, DC_BUFFER_DRAIN_TIMEOUT_MS);
       } catch {
         resolve();
       }

package/services/delivery-probe.js

@@ -372,11 +372,22 @@ export function createDeliveryProbe({
       0
     );
     // Advancing SINCE THE PREVIOUS TICK, not since the connection began: the
-    // question is whether bytes are crossing now.
-    const peerBytesAdvancing = connection.peerBytes === null
-      ? null
-      : connection.peerBytesAtTick === null || connection.peerBytes > connection.peerBytesAtTick;
-    connection.peerBytesAtTick = connection.peerBytes;
+    // question is whether bytes are crossing now. Prefer channel bytes —
+    // transport's bytesReceived advances on SACKs (140 B/s on a wedge) and
+    // gives a false "advancing" every other tick, while channel bytes are flat.
+    let peerBytesAdvancing = null;
+    if (connection.peerChannelBytes !== null) {
+      peerBytesAdvancing =
+        connection.peerChannelBytesAtTick === null ||
+        connection.peerChannelBytes > connection.peerChannelBytesAtTick;
+      connection.peerChannelBytesAtTick = connection.peerChannelBytes;
+      // keep transport's tick in sync for fallback logging
+      connection.peerBytesAtTick = connection.peerBytes;
+    } else if (connection.peerBytes !== null) {
+      peerBytesAdvancing =
+        connection.peerBytesAtTick === null || connection.peerBytes > connection.peerBytesAtTick;
+      connection.peerBytesAtTick = connection.peerBytes;
+    }
     const { verdict, detail } = readProbeState({
       seq: connection.seq,
       seen: connection.seen,
@@ -468,6 +479,13 @@ export function createDeliveryProbe({
           peerBytes: null,
           /** @type {number | null} */
           peerBytesAtTick: null,
+          // Sum of per-channel bytes (report.channels[].bytes). Transport's
+          // bytesReceived advances on SACKs (140 B/s on a wedge) and gives a
+          // false "advancing" every other tick — channel bytes are flat on a wedge.
+          /** @type {number | null} */
+          peerChannelBytes: null,
+          /** @type {number | null} */
+          peerChannelBytesAtTick: null,
           // The far end's own event-loop delay and tab state, as last reported.
           // The lag is a term in every allowance below; the tab state is only
           // printed, so that a wide allowance can be read back to its cause.
@@ -554,6 +572,21 @@ export function createDeliveryProbe({
       if (Number.isFinite(peerBytes) && peerBytes >= 0) {
         connection.peerBytes = peerBytes;
       }
+      // Sum of per-channel bytes. Transport's bytesReceived advances on SACKs
+      // (140 B/s on a wedge) and gives a false "advancing" every other tick —
+      // channel bytes are flat on a wedge, so they are the correct signal.
+      const ch = echo?.report?.channels;
+      if (ch && typeof ch === "object") {
+        let total = 0;
+        let has = false;
+        for (const v of Object.values(ch)) {
+          if (v && typeof v.bytes === "number" && Number.isFinite(v.bytes)) {
+            total += v.bytes;
+            has = true;
+          }
+        }
+        if (has) connection.peerChannelBytes = total;
+      }
       // How far behind the far end's own event loop is running. A browser that
       // cannot run its timers cannot answer a probe, and every allowance here
       // is a wait the answer has to fit inside — so this is a term in the

package/services/encode/CoverageMap.js

@@ -135,6 +135,31 @@ export class CoverageMap {
     this.#claims.delete(run);
   }
 
+  /**
+   * How many numbers between two are already made.
+   *
+   * What an encoder driving from one to the other would produce a SECOND time,
+   * and therefore what the swarm would be asked to fetch a second time. It is a
+   * term of when that encoder arrives, not a separate question about whether to
+   * move it: an encoder that has to re-make three hundred pieces on its way is
+   * simply slower to get there, and the model compares arrivals.
+   *
+   * @param {number} from - Inclusive.
+   * @param {number} to - Inclusive.
+   * @returns {number}
+   */
+  madeBetween(from, to) {
+    const first = Number.isInteger(from) && from > 0 ? from : 0;
+    const last = Number.isInteger(to) ? to : -1;
+    let count = 0;
+    for (let index = first; index <= last; index += 1) {
+      if (this.isReady(index)) {
+        count += 1;
+      }
+    }
+    return count;
+  }
+
   /**
    * @param {number} index
    * @returns {boolean}
@@ -195,7 +220,7 @@ export class CoverageMap {
         continue;
       }
       const maker = this.makerOf(at);
-      if (maker === null || maker === exceptRun) {
+      if (maker === null || CoverageMap.#isExcepted(maker, exceptRun)) {
         return at;
       }
     }
@@ -226,7 +251,7 @@ export class CoverageMap {
         continue;
       }
       const maker = this.makerOf(at);
-      if (maker !== null && maker !== exceptRun) {
+      if (maker !== null && !CoverageMap.#isExcepted(maker, exceptRun)) {
         at += 1;
         continue;
       }
@@ -235,6 +260,36 @@ export class CoverageMap {
     return at - start;
   }
 
+  /**
+   * How many numbers from `index` onward have NOT been made, claims ignored.
+   *
+   * The stretch an encoder placed here could work through before it would be
+   * re-making something that exists. Claims are deliberately left out: a claim
+   * says another encoder MEANS to make it, and where two encoders are being
+   * placed in one pass the claims of the moment are about to be re-cut — so
+   * asking about them here gives an answer that was true a step ago. Where one
+   * encoder's road ends because another begins is decided once, over all the
+   * placements together, after they are known.
+   *
+   * @param {number} index
+   * @returns {number} Zero when `index` is already made; the rest of the track
+   *   when nothing ahead is; `Infinity` when the length is not yet known.
+   */
+  unmadeRunFrom(index) {
+    const start = Number.isInteger(index) && index > 0 ? index : 0;
+    if (this.isReady(start)) {
+      return 0;
+    }
+    if (this.#segmentCount <= 0) {
+      return Number.POSITIVE_INFINITY;
+    }
+    let end = start;
+    while (end < this.#segmentCount && !this.isReady(end)) {
+      end += 1;
+    }
+    return end - start;
+  }
+
   /**
    * How many numbers from `index` onwards are free — nobody has made them and
    * nobody is making them.
@@ -273,7 +328,7 @@ export class CoverageMap {
         break;
       }
       const maker = this.makerOf(at);
-      if (maker !== null && maker !== exceptRun) {
+      if (maker !== null && !CoverageMap.#isExcepted(maker, exceptRun)) {
         break;
       }
       at += 1;
@@ -293,6 +348,24 @@ export class CoverageMap {
    * @param {object | null} exceptRun
    * @returns {number | null}
    */
+  /**
+   * Is this claim one of the runs the caller is setting aside?
+   *
+   * A single run or a set of them: a pass that re-cuts several roads at once has
+   * to ask about all of them together, and asking once per run gave an answer
+   * true of no moment.
+   *
+   * @param {object} maker
+   * @param {object | Set<object> | null} except
+   * @returns {boolean}
+   */
+  static #isExcepted(maker, except) {
+    if (except === null || except === undefined) {
+      return false;
+    }
+    return except instanceof Set ? except.has(maker) : maker === except;
+  }
+
   #firstCoveredFrom(index, exceptRun) {
     let lowest = null;
     for (const ready of this.#ready) {
@@ -301,7 +374,7 @@ export class CoverageMap {
       }
     }
     for (const [run, span] of this.#claims) {
-      if (run === exceptRun) {
+      if (CoverageMap.#isExcepted(run, exceptRun)) {
         continue;
       }
       // A claim that has already begun covers `index` itself.