@torrent-tv/proxy 2.76.6 → 2.78.0

package/bin/cli.js

@@ -527,7 +527,20 @@ try {
     // Records the wire when a queue stays wedged — how the rare one-way
     // transmit death (roadmap item 10, 2026-08-24) gets its evidence.
     witness: packetWitness,
-    usrsctpState: usrsctpStateReader
+    usrsctpState: usrsctpStateReader,
+    // Presence, from the one thing that knows it. Late-bound for the same
+    // reason as the transport snapshot above: the manager is built inside
+    // `startProxyServer`, with this handler already in hand.
+    onViewerPresent: (consumerId) => {
+      started?.hlsSessionManager?.viewers?.seen?.(consumerId);
+    },
+    onViewerGone: (consumerId, because) => {
+      void started?.hlsSessionManager?.viewerHasGone?.(consumerId, because)
+        ?.catch?.((error) => {
+          const message = error instanceof Error ? error.message : String(error);
+          logger.warn(`could not let go of viewer ${consumerId}: ${message}`);
+        });
+    }
   });
 
   webRtcManager = createWebRtcManager({

package/package.json

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

package/services/data-channel-handler.js

@@ -159,7 +159,7 @@ export function wedgeIsCertain({ queuedBytes, bytesPerSecond, flatForMs, longest
  * @param {DataChannel} channel
  * @returns {() => void} Stops the watch.
  */
-function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState }) {
+function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState, onConnectionGone }) {
   // Every channel of one connection reads the SAME transport counters — the
   // snapshot describes the peer connection, not the channel — so the heartbeat
   // belongs to the connection and is printed once for it. Printed per channel
@@ -291,6 +291,12 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
       // the live one.
       if (connection.channels.size === 0 && connections.get(sessionId) === connection) {
         connections.delete(sessionId);
+        // Every channel of this connection is down, so the person on it is
+        // gone. This is the SECOND way that becomes known, and it exists
+        // because the first does not always come: a peer connection can die
+        // without `onClosed`, which is why this watch was written in the first
+        // place.
+        onConnectionGone?.(sessionId, "the transport stopped answering");
       }
     };
     // Independent of the queue: the transport's own counters, sampled for as
@@ -544,8 +550,52 @@ export function createDataChannelHandler({
   // moment a wedge is declared, from either detector below. Optional: a host
   // without gdb simply never gets a reading, same as the witness without
   // tcpdump.
-  usrsctpState
+  usrsctpState,
+  // Presence, both directions. A viewer is present because their connection
+  // is, and gone because it went — which is a fact about the PERSON and reaches
+  // every output they were watching at once. Before this, nothing anywhere
+  // 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 = () => {}
 }) {
+  /**
+   * Who is on each connection, by WebRTC session id.
+   *
+   * One connection carries one page, and a page holds one name per film it has
+   * open — so this is normally one id, and more than one only where a page has
+   * opened more than one.
+   *
+   * @type {Map<string, Set<string>>}
+   */
+  const viewersOnConnection = new Map();
+
+  /**
+   * Everyone on this connection has gone, because the connection has.
+   *
+   * Said once per connection: a second call after the set is emptied must not
+   * announce departures a second time, and the two detectors below — the close
+   * event and the transport's own counters — can both fire for one death.
+   *
+   * @param {string} sessionId
+   * @param {string} because
+   * @returns {void}
+   */
+  function connectionGone(sessionId, because) {
+    const viewers = viewersOnConnection.get(sessionId);
+    viewersOnConnection.delete(sessionId);
+    if (!viewers || viewers.size === 0) {
+      return;
+    }
+    for (const consumerId of viewers) {
+      onLog?.(`[dc] Session ${sessionId.slice(0, 8)}: viewer ${consumerId} left — ${because}`);
+      try {
+        onViewerGone(consumerId, because);
+      } catch {
+        // A viewer failing to be let go must not stop the others being let go.
+      }
+    }
+  }
   /**
    * Channels currently interested in one file's subtitle cues, keyed by
    * `sourceKey:fileIndex`. Populated the moment a browser asks for an
@@ -630,7 +680,11 @@ export function createDataChannelHandler({
     log: (message) => log(message),
     getTransportSnapshot,
     witness,
-    usrsctpState
+    usrsctpState,
+    // The watcher is where a connection's death is noticed when no close event
+    // arrives, so it is the second door presence leaves by. Given rather than
+    // reached for: it is a module-level function and cannot see this closure.
+    onConnectionGone: connectionGone
   });
   // Numbered probes on every channel, and the browser's echo of what it saw.
   // The proxy's own counters cannot say whether bytes it handed to usrsctp were
@@ -804,6 +858,27 @@ export function createDataChannelHandler({
         return;
       }
 
+      // WHO is on this connection. Sent once when the page opens its control
+      // channel, and it is what lets a closed connection say that a PERSON has
+      // gone rather than that one output lost a request.
+      //
+      // The name is the page's, not this connection's: it is minted once per
+      // film opened in the tab and survives the reconnect ladder swapping the
+      // transport underneath a running player. A name minted here would make
+      // one person two the first time that happened, each with their own
+      // position.
+      if (message.type === "viewer" && typeof message.consumerId === "string" && message.consumerId) {
+        const known = viewersOnConnection.get(sessionId) ?? new Set();
+        const isNew = !known.has(message.consumerId);
+        known.add(message.consumerId);
+        viewersOnConnection.set(sessionId, known);
+        if (isNew) {
+          log(`[dc] Session ${tag}: viewer ${message.consumerId} is on this connection`);
+        }
+        onViewerPresent(message.consumerId);
+        return;
+      }
+
       // The far end's answer to the numbered probes, plus what it can see of
       // its own receiving. It travels browser to proxy, the direction that goes
       // on working through a freeze, so it arrives when nothing else does.
@@ -836,6 +911,11 @@ export function createDataChannelHandler({
       partials.clear();
       unsubscribeSubtitlesAll(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
+      // transport's own counters going quiet — is a backstop for this event
+      // failing to arrive.
+      connectionGone(sessionId, "the connection closed");
     });
 
     channel.onError((err) => {

package/services/encode/DemandMap.js

@@ -0,0 +1,187 @@
+/**
+ * @file What one viewer needs, what all of them need together, and in what
+ * order the work should be taken.
+ *
+ * The shape, stated by the user 2026-09-05:
+ *
+ * > Usually you make a map for each viewer, then merge the maps, then decide
+ * > the best way of filling it given the encoders available, where they are now
+ * > and how many there are.
+ *
+ * Three questions, and this file answers the first two. The third — the filling
+ * — belongs to whoever holds the encoders, and it is handed the merged map
+ * instead of a list of windows.
+ *
+ * **ONE PRIORITISATION, TWO CONSUMERS.** Downloading and encoding keep
+ * different STATES — made / being made / free for one; downloaded / arriving,
+ * and which peers hold it at what speed, for the other — but they must agree
+ * about what matters first, or the swarm fetches what the encoder will not
+ * reach for another twenty minutes. That agreement is this map.
+ *
+ * **THE UNIT IS SECONDS OF FILM.** A map is a set of stretches with sizes and a
+ * length of its own, so it needs a unit, and seconds are the only one every
+ * term of the arithmetic is already stated in: encode speed is a ratio of
+ * seconds to seconds, the measured allowance below which an interruption
+ * reaches a viewer is seconds, the viewer's position is seconds, the film's
+ * length is seconds. Bytes cannot serve — how many a second costs is not known
+ * when a file is opened and is not constant across it, and a soundtrack in a
+ * file of its own has bytes of its own. Segment numbers cannot serve either:
+ * they exist only once a cut grid is read, and two outputs of one film number
+ * differently.
+ *
+ * **What this file must NOT know**, and the boundary is the point: nothing about
+ * containers, cut grids, pieces or bytes. Turning a stretch of seconds into the
+ * bytes of one track is the container's and the track's business, by whatever
+ * means suit that file — a Cues table, a sample table, or a walk when the file
+ * carries neither, which is the same answer they already give in order to play
+ * it at all. Getting those bytes is the downloader's business; making segments
+ * out of them is the encoder's.
+ */
+
+/**
+ * How urgently a stretch of film is wanted. Higher is sooner.
+ *
+ * @typedef {object} DemandZone
+ * @property {number} from - First second of film, inclusive.
+ * @property {number} to - Last second of film, inclusive.
+ * @property {number} priority - Higher is more urgent. Only the ORDER between
+ *   zones is meaningful; the numbers themselves are not a scale.
+ */
+
+/** Where the viewer stands. Nothing outranks it. */
+const AT_THE_VIEWER = 3;
+
+/** In front of them, within reach while they watch what is already made. */
+const IN_FRONT = 2;
+
+/** The rest of the track: wanted, because the file is encoded whole. */
+const THE_REST = 1;
+
+/**
+ * One viewer's map.
+ *
+ * Three zones, and the two boundaries between them are measured rather than
+ * chosen:
+ *
+ * 1. **what must be ready before they set off, so that they never stop.** While
+ *    they watch, film is consumed at one second per second and produced at
+ *    `encodeSpeedX`. Above realtime the encoder gains on them, and all that is
+ *    needed in front is the measured allowance for unevenness in the swarm and
+ *    in production. Below realtime it LOSES `1 - speed` of a second for every
+ *    second played, so over the film in front of them the shortfall is
+ *    `remaining × (1 - speed)` — at 0.5x on twenty minutes ahead, ten minutes
+ *    must exist before they start, or they meet a stall partway through;
+ * 2. **what the machine reaches while they watch zone 1** — in front of a
+ *    moving viewer, so ahead of the rest, and nobody is waiting for it yet, so
+ *    behind zone 1;
+ * 3. **the rest of the track.**
+ *
+ * @param {object} params
+ * @param {number} params.atSeconds - Where they are watching from.
+ * @param {number} params.durationSeconds - How long the film is.
+ * @param {number} params.allowanceSeconds - The measured depth below which an
+ *   interruption reaches this viewer (`minimumBufferSeconds`).
+ * @param {number} params.encodeSpeedX - Measured encode speed against realtime
+ *   for this track on this machine. Zero or less means nothing has measured it
+ *   yet, and then zone 2 is left out rather than invented.
+ * @returns {DemandZone[]} Ascending, without gaps or overlaps, covering
+ *   everything from where they are to the end of the film.
+ */
+export function mapForViewer({ atSeconds, durationSeconds, allowanceSeconds, encodeSpeedX }) {
+  const from = Number.isFinite(atSeconds) && atSeconds > 0 ? atSeconds : 0;
+  const end = Number.isFinite(durationSeconds) ? durationSeconds : 0;
+  if (!(end > from)) {
+    return [];
+  }
+  const remaining = end - from;
+  const allowance = Number.isFinite(allowanceSeconds) && allowanceSeconds > 0 ? allowanceSeconds : 0;
+  const speed = Number.isFinite(encodeSpeedX) && encodeSpeedX > 0 ? encodeSpeedX : 0;
+  const shortfall = speed > 0 && speed < 1 ? remaining * (1 - speed) : 0;
+
+  /** @type {DemandZone[]} */
+  const zones = [];
+  const readyBy = Math.min(end, from + allowance + shortfall);
+  zones.push({ from, to: readyBy, priority: AT_THE_VIEWER });
+
+  if (readyBy < end && speed > 0) {
+    // While they watch what zone 1 holds, the encoder makes `speed` times that
+    // much. Beyond it nobody is waiting yet.
+    const reach = Math.min(end, readyBy + (readyBy - from) * speed);
+    if (reach > readyBy) {
+      zones.push({ from: readyBy, to: reach, priority: IN_FRONT });
+    }
+  }
+
+  const covered = zones[zones.length - 1].to;
+  if (covered < end) {
+    zones.push({ from: covered, to: end, priority: THE_REST });
+  }
+  return zones;
+}
+
+/**
+ * Every viewer's map as one.
+ *
+ * The highest priority per second wins: film two people want is as urgent as
+ * the more urgent of them, and making it once serves both. What comes back has
+ * no overlaps, so the filling can walk it without asking about any individual
+ * viewer — which is the rule this layer exists to keep, that which viewer asked
+ * never reaches the encoders.
+ *
+ * @param {DemandZone[][]} maps
+ * @returns {DemandZone[]} Ascending by position.
+ */
+export function mergeMaps(maps) {
+  /** @type {DemandZone[]} */
+  const all = [];
+  for (const map of maps ?? []) {
+    for (const zone of map ?? []) {
+      if (Number.isFinite(zone?.from) && Number.isFinite(zone?.to) && zone.to > zone.from) {
+        all.push(zone);
+      }
+    }
+  }
+  if (all.length === 0) {
+    return [];
+  }
+  // Walked by BOUNDARIES rather than by second: a film is thousands of them and
+  // this is asked again on every change.
+  const points = [...new Set(all.flatMap((zone) => [zone.from, zone.to]))].sort(
+    (left, right) => left - right
+  );
+  /** @type {DemandZone[]} */
+  const merged = [];
+  for (let index = 0; index < points.length - 1; index += 1) {
+    const from = points[index];
+    const to = points[index + 1];
+    let priority = 0;
+    for (const zone of all) {
+      if (zone.from <= from && to <= zone.to && zone.priority > priority) {
+        priority = zone.priority;
+      }
+    }
+    if (priority <= 0) {
+      continue;
+    }
+    const previous = merged[merged.length - 1];
+    if (previous && previous.priority === priority && previous.to === from) {
+      previous.to = to;
+      continue;
+    }
+    merged.push({ from, to, priority });
+  }
+  return merged;
+}
+
+/**
+ * The merged map in the order the work is taken: most urgent first, and within
+ * one priority the earliest film first — that is where somebody is stopped.
+ *
+ * @param {DemandZone[]} merged
+ * @returns {DemandZone[]}
+ */
+export function inWorkingOrder(merged) {
+  return [...(merged ?? [])].sort(
+    (left, right) => right.priority - left.priority || left.from - right.from
+  );
+}