@torrent-tv/proxy 2.9.135 → 2.9.136

package/CHANGELOG.md

@@ -1,4 +1,8 @@
-## 2.9.132
+## 2.9.136
+
+- **Fix**: What a complete init segment must describe is now taken from what the proxy DECLARES it will output, not from a count. 2.9.135 required two tracks, which is a guess — wrong for a film with no soundtrack, and meaningless for a source carrying several dubs, subtitles or a cover-art video stream. The output does not inherit the source's track list: the command maps at most one video and at most one audio, each optional, and subtitles never enter the HLS output at all. So the proxy knows the output's set exactly, because it chose it — the probe says which kinds exist, the mapping says how many are taken. Deriving the figure from produced pieces instead reads correctly only once a piece carrying every track exists, and the moment that matters is the one before that: an early piece written before the video was muxed sets the requirement to one and waves through precisely the header this exists to reject. Pieces remain as a floor, since a piece carrying more than declared is evidence, and evidence outranks a declaration.
+
+## 2.9.135
 
 - **Fix**: A session no longer plays sound with no picture at all. The init segment — the header that tells the browser which tracks exist — is lifted out of the first self-contained piece and then cached for the WHOLE session, because the player fetches `#EXT-X-MAP` once and never again. A piece written before the video track had been muxed declares audio alone, and the browser then has no video source buffer for the rest of the session however much video arrives afterwards. Measured 2026-08-10 from the browser's own counters: sixty-five seconds of playing sound with `videoWidth=0`, `totalVideoFrames=0` and `readyState=4` — an element perfectly satisfied, with no picture in it. A header short of a track is now passed over and the next piece tried; if no piece carries the full set the richest one found is served and the shortfall is logged, so a source that genuinely lacks a stream still plays while the other possibility stays visible.
 

package/package.json

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

package/services/hls-session-manager.js

@@ -1528,13 +1528,35 @@ export class HlsSessionManager {
     if (typeof session.segmentFormat.extractInit !== "function") {
       return null;
     }
-    // Both streams are mapped (`-map 0:v:0? -map 0:a:0?`), so a complete header
-    // declares two tracks. A source genuinely missing one is legitimate, and
-    // must not be left without an init for ever — hence the fallback below to
-    // the richest header found rather than a hard requirement.
-    const expectedTracks = 2;
+    // How many tracks a complete header must declare is ANSWERED, not assumed.
+    //
+    // The probe already knows the source's stream list, and the output maps at
+    // most one of each (`-map 0:v:0? -map 0:a:0?`), so the count follows from
+    // what the source actually has. A film with no soundtrack expects one; an
+    // ordinary file expects two; neither is a convention.
+    //
+    // Deriving it from the produced pieces instead — the first version of this
+    // — reads correctly only once a piece carrying every track exists, and the
+    // whole point is the moment BEFORE that: early pieces written before the
+    // video was muxed would set the requirement to one and wave through exactly
+    // the header this exists to reject. The pieces are still consulted, but
+    // only as a floor: a piece carrying more than the probe led us to expect is
+    // evidence, and evidence outranks the probe.
+    const probed = this.getCachedMediaInfo?.({
+      sourceKey: session.sourceKey,
+      fileIndex: session.fileIndex
+    }) ?? null;
+    let expectedTracks = probed
+      ? (probed.videoCodec ? 1 : 0) + (probed.audioCodec ? 1 : 0)
+      : 0;
+    if (expectedTracks === 0) {
+      // No probe to consult. Fall back to the evidence, with its known lag.
+      expectedTracks = 1;
+    }
     let best = null;
     let bestTracks = 0;
+    /** @type {Map<string, Buffer>} Pieces read once and used for both passes. */
+    const pieces = new Map();
     let names;
     try {
       names = (this.#runDirs(session).flatMap((dir) => {
@@ -1545,13 +1567,32 @@ export class HlsSessionManager {
     } catch {
       return null;
     }
+    // First pass: what do the produced pieces actually carry? The answer is the
+    // requirement — no assumption about the source is involved.
+    if (typeof session.segmentFormat.countSegmentTracks === "function") {
+      for (const name of names) {
+        try {
+          const found = await this.#findProducedFile(session, name);
+          if (!found) {
+            continue;
+          }
+          const bytes = await readFile(found);
+          pieces.set(name, bytes);
+          expectedTracks = Math.max(expectedTracks, session.segmentFormat.countSegmentTracks(bytes));
+        } catch {
+          // Being written right now — it says nothing about the others.
+        }
+      }
+    }
+
     for (const name of names) {
       try {
-        const found = await this.#findProducedFile(session, name);
+        const cached = pieces.get(name);
+        const found = cached ? name : await this.#findProducedFile(session, name);
         if (!found) {
           continue;
         }
-        const init = session.segmentFormat.extractInit(await readFile(found));
+        const init = session.segmentFormat.extractInit(cached ?? await readFile(found));
         if (init && init.length > 0) {
           return init;
         }

package/services/segment-formats/fmp4.js

@@ -265,6 +265,22 @@ export const fmp4Format = {
    * @param {Buffer} initBytes
    * @returns {number}
    */
+  /**
+   * How many distinct tracks this piece's own fragments carry.
+   *
+   * Needs no knowledge of the source: whatever a produced piece contains, it
+   * contains. Comparing the richest piece against a candidate header is what
+   * lets an init be judged without assuming how many tracks a file "should"
+   * have — a film with no soundtrack and a file with two audio tracks are both
+   * answered correctly, and neither is guessed at.
+   *
+   * @param {Buffer} bytes
+   * @returns {number}
+   */
+  countSegmentTracks(bytes) {
+    return countFragmentTracks(bytes);
+  },
+
   countInitTracks(initBytes) {
     if (!initBytes || initBytes.length === 0) {
       return 0;