@torrent-tv/proxy 2.83.5 → 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

package/services/orchestrators/EncodeOrchestrator.js

@@ -63,7 +63,8 @@ export class EncodeOrchestrator {
 
   /**
    * How many times in a row an output's run has died because its input was not
-   * there. Cleared by any other ending, which is the input answering.
+   * there. Cleared only by a run that PRODUCED something, which is the only
+   * proof that the input can be read — see `#noteInputAvailability`.
    *
    * @type {Map<string, number>}
    */
@@ -307,6 +308,14 @@ export class EncodeOrchestrator {
    */
   notePriorityMap(address, zones) {
     this.demand.state(address, zones);
+    // NOBODY IS COMING HERE, so what was remembered about this output's input
+    // is about nobody. Kept, those three entries would stay for the life of the
+    // process, and the wait they describe would greet whoever opens this output
+    // next — a viewer arriving is new information, and one attempt for them is
+    // right whatever the last one met.
+    if (!Array.isArray(zones) || zones.length === 0) {
+      this.#forgetInputState(address);
+    }
   }
 
   /**
@@ -408,8 +417,7 @@ export class EncodeOrchestrator {
     // AND ONLY WHILE NOTHING IS PRODUCING THERE. A run still alive on this
     // output is proof the input can be read, whatever a run beside it met, so
     // the wait must not silence an output that is working.
-    const quietMs = this.#quietFor(address);
-    if (quietMs > 0 && this.runsOn(address).every((run) => !run.isAlive)) {
+    if (this.#isQuiet(address) && this.runsOn(address).every((run) => !run.isAlive)) {
       return;
     }
     // ONE MAP, NOT ONE WINDOW PER VIEWER PER ZONE.
@@ -812,23 +820,45 @@ export class EncodeOrchestrator {
   }
 
   /**
-   * How long this output still has to wait before anything is placed on it, in
-   * milliseconds; zero when it may be planned now.
+   * Whether this output is still waiting before anything may be placed on it.
+   *
+   * A boolean rather than the milliseconds left: the figure had one reader and
+   * that reader only asked whether it was above zero, so it was a number
+   * computed and thrown away. How long the wait is was said when it began.
    *
    * @param {string} address
-   * @returns {number}
+   * @returns {boolean}
    */
-  #quietFor(address) {
+  #isQuiet(address) {
     const until = this.#quietUntil.get(address);
     if (!Number.isFinite(until)) {
-      return 0;
+      return false;
     }
-    const left = until - this.now();
-    if (left <= 0) {
+    if (until - this.now() <= 0) {
       this.#quietUntil.delete(address);
-      return 0;
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Forget everything remembered about an output nobody is producing for.
+   *
+   * Three maps are keyed by address, and an output that goes away leaves an
+   * entry in each for the life of the process. Small, and exactly the shape of
+   * accumulation this layer was built to remove from the session.
+   *
+   * @param {string} address
+   * @returns {void}
+   */
+  #forgetInputState(address) {
+    this.#inputLostAttempts.delete(address);
+    this.#quietUntil.delete(address);
+    const timer = this.#quietTimers.get(address);
+    if (timer) {
+      clearTimeout(timer);
+      this.#quietTimers.delete(address);
     }
-    return left;
   }
 
   /**

package/services/torrent-pool.js

@@ -1067,6 +1067,9 @@ export class TorrentPool {
    */
   #wholeSources = new Set();
 
+  /** How many claims this pool has withdrawn, over its whole life. */
+  #claimsWithdrawn = 0;
+
   /**
    * Say that every file of a source is held whole.
    *
@@ -1165,9 +1168,6 @@ export class TorrentPool {
     }
   }
 
-  /** How many claims this pool has withdrawn, over its whole life. */
-  #claimsWithdrawn = 0;
-
   get claimsWithdrawn() {
     return this.#claimsWithdrawn;
   }

package/services/torrent-worker/client.js

@@ -17,7 +17,7 @@
 import { Worker } from "node:worker_threads";
 import { Readable } from "node:stream";
 import { fileURLToPath } from "node:url";
-import { logger } from "../../utils/logger.js";
+import { logger, writeAlreadyDecided } from "../../utils/logger.js";
 import { createCaller, createReceiveStream } from "./channel.js";
 import { Command, Event } from "./protocol.js";
 
@@ -218,7 +218,10 @@ export class TorrentWorkerClient {
           this.#fragmentReaders.delete(message.id);
           break;
         case Event.LOG:
-          logger.info(`torrent-worker: ${message.message}`);
+          // Written as it is: the worker holds the same repeat rule and has
+          // already applied it, and deciding again here would be one decision
+          // taken twice on two different histories.
+          writeAlreadyDecided(message.level ?? "info", `torrent-worker: ${message.message}`);
           break;
         case Event.FILE_COMPLETE:
           // Recorded here so the stream route can answer from the file without

package/services/torrent-worker/worker.js

@@ -56,8 +56,12 @@ import { forwardLogsTo, logger } from "../../utils/logger.js";
  * copy of the logger that had no file, and every one of their lines was lost:
  * measured over a whole 49 938-line file, not one of them was in it.
  */
-forwardLogsTo((_level, message) => {
-  parentPort.postMessage({ type: Event.LOG, message });
+forwardLogsTo((level, message) => {
+  // THE LEVEL TRAVELS TOO. It was dropped here, so every line this thread wrote
+  // — a warning about a spill that failed, an error about a torrent that went
+  // away — arrived on the other side as information and was coloured and
+  // recorded as such.
+  parentPort.postMessage({ type: Event.LOG, level, message });
 });
 
 // Imported dynamically, and that is load-bearing: static imports are RESOLVED
@@ -658,6 +662,7 @@ startMemoryReport({
 const STORE_REPORT_INTERVAL_MS = 60_000;
 
 /** Last reported reserve, so an unchanged one stays silent. */
+let lastClaimsWithdrawn = 0;
 let lastReserveBytes = 0;
 
 /** Last reported figures per store, so unchanged ones stay silent. */
@@ -695,6 +700,20 @@ setInterval(() => {
       );
     }
   }
+  // WHAT THE ANNOUNCEMENTS ACTUALLY DID. The stores count every piece they
+  // stopped being able to produce; this counts the ones where the library did
+  // still hold a claim and it was taken back. The GAP between the two is the
+  // reading: announcements far above withdrawals mean the stores are mostly
+  // dropping pieces that were never completed, and a withdrawal count stuck at
+  // zero while announcements climb means the mechanism is not reaching the
+  // torrent at all.
+  if (pool.claimsWithdrawn !== lastClaimsWithdrawn) {
+    lastClaimsWithdrawn = pool.claimsWithdrawn;
+    log(
+      `torrent-pool: ${pool.claimsWithdrawn} piece claim(s) withdrawn — pieces this proxy ` +
+      "had dropped and has now told the swarm it needs again"
+    );
+  }
   const reserveNow = machineReserveBytes();
   if (reserveNow !== reserveBefore || reserveNow !== lastReserveBytes) {
     lastReserveBytes = reserveNow;