@torrent-tv/proxy 2.9.135 → 2.9.137

package/CHANGELOG.md

@@ -1,4 +1,12 @@
-## 2.9.132
+## 2.9.137
+
+- **New**: A session states the track set its output will carry, and sends it to the browser. The proxy knows the set exactly — it chose it: the command maps at most one video and at most one audio, each optional, and subtitles never enter the HLS output. That statement is now used twice, which is the point of making it: the init segment is checked against it here, and the browser checks what it actually received against the same statement (server 0.8.161). A track lost between the encoder and the element was previously noticed only by its absence, minutes later, as a black picture with working sound.
+
+## 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.137",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

package/routes/api/transcode-sessions/post.js

@@ -1,134 +1,139 @@
-/**
- * Create or return an existing HLS transcode session for a torrent file.
- *
- * POST /api/transcode-sessions
- *
- * @param {import("fastify").FastifyRequest} req
- * @param {import("fastify").FastifyReply} reply
- * @param {{ hlsSessionManager: import("../../../services/hls-session-manager.js").HlsSessionManager, sourceRegistry: object, torrentPool: object }} deps
- * @returns {Promise<void>}
- */
-
-import { logger } from "../../../utils/logger.js";
-
-/**
- * Extract a plain object from the request body, guarding against
- * non-object payloads (arrays, primitives, null).
- *
- * @param {unknown} body
- * @returns {Record<string, unknown>}
- */
-function getPayload(body) {
-  if (body && typeof body === "object" && !Array.isArray(body)) {
-    return body;
-  }
-  return {};
-}
-
-/**
- * Claim the source's file so the pool cannot clean it up under a live session.
- *
- * Asynchronous underneath — the torrent lives on another thread — but the
- * caller needs a release function immediately, so the claim is chased and the
- * release waits for it.
- *
- * @param {{ sourceRegistry: object, torrentPool: object, sourceKey: string, fileIndex: number }} params
- * @returns {() => void}
- */
-function holdSource({ sourceRegistry, torrentPool, sourceKey, fileIndex }) {
-  let release = null;
-  let releasedEarly = false;
-  const record = sourceRegistry?.get?.(sourceKey);
-  if (!record) {
-    return () => {};
-  }
-  void Promise.resolve(torrentPool.getTorrent(record.sourceType, record.source))
-    .then((torrent) => {
-      release = torrentPool.acquireFile(torrent, fileIndex);
-      if (releasedEarly) {
-        release();
-      }
-    })
-    .catch(() => {});
-  return () => {
-    releasedEarly = true;
-    if (typeof release === "function") {
-      release();
-      release = null;
-    }
-  };
-}
-
-export async function handleApiTranscodeSessionsPost(req, reply, { hlsSessionManager, sourceRegistry, torrentPool }) {
-  const payload = getPayload(req.body);
-  const sourceKey = typeof payload.sourceKey === "string" ? payload.sourceKey.trim() : "";
-  const fileIndex = Number(payload.fileIndex);
-  const transcodeVideo = payload.transcodeVideo === true;
-  const transcodeAudio = payload.transcodeAudio === true;
-  const consumerId = typeof payload.consumerId === "string" ? payload.consumerId.trim() : "";
-  const fileName = typeof payload.fileName === "string" ? payload.fileName.trim() : "";
-  const targetWidth = Number(payload.targetWidth);
-  const targetHeight = Number(payload.targetHeight);
-  // Manual quality: the target box is a user-forced resolution, encoded exactly
-  // (capped to source), with the realtime budget's auto-downscale + runtime
-  // downswitch disabled for the session.
-  const manualQuality = payload.manualQuality === true;
-  const startPositionSeconds = Number(payload.startPositionSeconds);
-  const audioTrackIndex = Number(payload.audioTrackIndex);
-  // Which container to produce. The browser knows what its media stack will
-  // accept for the tracks it asked to be copied; an absent or unknown value
-  // leaves the proxy's own `--segment-format` in charge.
-  const segmentFormatId =
-    typeof payload.segmentFormat === "string" ? payload.segmentFormat.trim() : "";
-
-  if (!sourceKey || !Number.isInteger(fileIndex) || fileIndex < 0) {
-    return reply.code(400).send({ error: "sourceKey and valid fileIndex are required." });
-  }
-
-  try {
-    const session = await hlsSessionManager.createOrGetSession({
-      sourceKey,
-      fileIndex,
-      transcodeVideo,
-      transcodeAudio,
-      consumerId,
-      fileName,
-      targetWidth: Number.isInteger(targetWidth) && targetWidth > 0 ? targetWidth : 0,
-      targetHeight: Number.isInteger(targetHeight) && targetHeight > 0 ? targetHeight : 0,
-      manualQuality,
-      startPositionSeconds:
-        Number.isFinite(startPositionSeconds) && startPositionSeconds > 0
-          ? startPositionSeconds
-          : 0,
-      audioTrackIndex:
-        Number.isInteger(audioTrackIndex) && audioTrackIndex > 0 ? audioTrackIndex : 0,
-      segmentFormatId,
-      // Hold the torrent for as long as this session lives. Reads take a claim
-      // only while they run, and a seek leaves a gap with no read at all — the
-      // disk sweep caught that gap on 2026-08-06 and deleted the film being
-      // watched.
-      acquireSource: () => holdSource({ sourceRegistry, torrentPool, sourceKey, fileIndex })
-    });
-    return reply.send({
-      sessionId: session.id,
-      playlistPath: `/transcode/${session.id}/index.m3u8`
-    });
-  } catch (error) {
-    if (error instanceof Error && error.code === "TRANSCODE_DISABLED") {
-      return reply.code(409).send({ error: error.message });
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    // Say why on the proxy's own log, not only in the answer. This route
-    // answered 500 for every viewer of proxy 2.9.101-2.9.102 (an undeclared
-    // constant) and the addon log carried nothing but the data-channel layer's
-    // bare "→ 500": the cause had to be recovered by replaying the request
-    // against the live proxy. The stack is worth the two lines it costs — a
-    // programming error here is invisible to the viewer, who only sees that
-    // nothing plays.
-    logger.error(
-      `transcode-sessions: ${sourceKey}:${fileIndex} failed to prepare: ${message}\n` +
-        `${error instanceof Error ? (error.stack ?? "") : ""}`
-    );
-    return reply.code(500).send({ error: `Failed to prepare transcode session: ${message}` });
-  }
-}
+/**
+ * Create or return an existing HLS transcode session for a torrent file.
+ *
+ * POST /api/transcode-sessions
+ *
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ hlsSessionManager: import("../../../services/hls-session-manager.js").HlsSessionManager, sourceRegistry: object, torrentPool: object }} deps
+ * @returns {Promise<void>}
+ */
+
+import { logger } from "../../../utils/logger.js";
+
+/**
+ * Extract a plain object from the request body, guarding against
+ * non-object payloads (arrays, primitives, null).
+ *
+ * @param {unknown} body
+ * @returns {Record<string, unknown>}
+ */
+function getPayload(body) {
+  if (body && typeof body === "object" && !Array.isArray(body)) {
+    return body;
+  }
+  return {};
+}
+
+/**
+ * Claim the source's file so the pool cannot clean it up under a live session.
+ *
+ * Asynchronous underneath — the torrent lives on another thread — but the
+ * caller needs a release function immediately, so the claim is chased and the
+ * release waits for it.
+ *
+ * @param {{ sourceRegistry: object, torrentPool: object, sourceKey: string, fileIndex: number }} params
+ * @returns {() => void}
+ */
+function holdSource({ sourceRegistry, torrentPool, sourceKey, fileIndex }) {
+  let release = null;
+  let releasedEarly = false;
+  const record = sourceRegistry?.get?.(sourceKey);
+  if (!record) {
+    return () => {};
+  }
+  void Promise.resolve(torrentPool.getTorrent(record.sourceType, record.source))
+    .then((torrent) => {
+      release = torrentPool.acquireFile(torrent, fileIndex);
+      if (releasedEarly) {
+        release();
+      }
+    })
+    .catch(() => {});
+  return () => {
+    releasedEarly = true;
+    if (typeof release === "function") {
+      release();
+      release = null;
+    }
+  };
+}
+
+export async function handleApiTranscodeSessionsPost(req, reply, { hlsSessionManager, sourceRegistry, torrentPool }) {
+  const payload = getPayload(req.body);
+  const sourceKey = typeof payload.sourceKey === "string" ? payload.sourceKey.trim() : "";
+  const fileIndex = Number(payload.fileIndex);
+  const transcodeVideo = payload.transcodeVideo === true;
+  const transcodeAudio = payload.transcodeAudio === true;
+  const consumerId = typeof payload.consumerId === "string" ? payload.consumerId.trim() : "";
+  const fileName = typeof payload.fileName === "string" ? payload.fileName.trim() : "";
+  const targetWidth = Number(payload.targetWidth);
+  const targetHeight = Number(payload.targetHeight);
+  // Manual quality: the target box is a user-forced resolution, encoded exactly
+  // (capped to source), with the realtime budget's auto-downscale + runtime
+  // downswitch disabled for the session.
+  const manualQuality = payload.manualQuality === true;
+  const startPositionSeconds = Number(payload.startPositionSeconds);
+  const audioTrackIndex = Number(payload.audioTrackIndex);
+  // Which container to produce. The browser knows what its media stack will
+  // accept for the tracks it asked to be copied; an absent or unknown value
+  // leaves the proxy's own `--segment-format` in charge.
+  const segmentFormatId =
+    typeof payload.segmentFormat === "string" ? payload.segmentFormat.trim() : "";
+
+  if (!sourceKey || !Number.isInteger(fileIndex) || fileIndex < 0) {
+    return reply.code(400).send({ error: "sourceKey and valid fileIndex are required." });
+  }
+
+  try {
+    const session = await hlsSessionManager.createOrGetSession({
+      sourceKey,
+      fileIndex,
+      transcodeVideo,
+      transcodeAudio,
+      consumerId,
+      fileName,
+      targetWidth: Number.isInteger(targetWidth) && targetWidth > 0 ? targetWidth : 0,
+      targetHeight: Number.isInteger(targetHeight) && targetHeight > 0 ? targetHeight : 0,
+      manualQuality,
+      startPositionSeconds:
+        Number.isFinite(startPositionSeconds) && startPositionSeconds > 0
+          ? startPositionSeconds
+          : 0,
+      audioTrackIndex:
+        Number.isInteger(audioTrackIndex) && audioTrackIndex > 0 ? audioTrackIndex : 0,
+      segmentFormatId,
+      // Hold the torrent for as long as this session lives. Reads take a claim
+      // only while they run, and a seek leaves a gap with no read at all — the
+      // disk sweep caught that gap on 2026-08-06 and deleted the film being
+      // watched.
+      acquireSource: () => holdSource({ sourceRegistry, torrentPool, sourceKey, fileIndex })
+    });
+    return reply.send({
+      sessionId: session.id,
+      playlistPath: `/transcode/${session.id}/index.m3u8`,
+      // What this session's output will carry, stated rather than left to be
+      // discovered. The browser checks what it actually got against this: a
+      // track that never arrives is otherwise noticed only by its absence,
+      // minutes later, as a black picture with working sound.
+      tracks: hlsSessionManager.declaredTracks(session)
+    });
+  } catch (error) {
+    if (error instanceof Error && error.code === "TRANSCODE_DISABLED") {
+      return reply.code(409).send({ error: error.message });
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    // Say why on the proxy's own log, not only in the answer. This route
+    // answered 500 for every viewer of proxy 2.9.101-2.9.102 (an undeclared
+    // constant) and the addon log carried nothing but the data-channel layer's
+    // bare "→ 500": the cause had to be recovered by replaying the request
+    // against the live proxy. The stack is worth the two lines it costs — a
+    // programming error here is invisible to the viewer, who only sees that
+    // nothing plays.
+    logger.error(
+      `transcode-sessions: ${sourceKey}:${fileIndex} failed to prepare: ${message}\n` +
+        `${error instanceof Error ? (error.stack ?? "") : ""}`
+    );
+    return reply.code(500).send({ error: `Failed to prepare transcode session: ${message}` });
+  }
+}

package/services/hls-session-manager.js

@@ -1524,17 +1524,65 @@ export class HlsSessionManager {
    * @param {HlsSession} session
    * @returns {Promise<Buffer | null>}
    */
+  /**
+   * The track set this session's output will carry — what the proxy DECLARES,
+   * and the one answer both sides must agree on.
+   *
+   * The source may hold any number of tracks: several dubs, subtitles, even a
+   * cover-art video stream. The output does not inherit that list — the command
+   * maps at most one video and at most one audio, each optional, and subtitles
+   * never enter the HLS output at all (they are served separately as WebVTT).
+   * So this is not an inference about the file; it is the proxy stating what it
+   * chose to produce.
+   *
+   * Used in two places, and that is the point: the init segment is checked
+   * against it here, and it is sent to the browser so the browser can check
+   * what it actually received against the same statement. Without the second
+   * check a missing track is only noticed by its absence, minutes later, as a
+   * black picture with working sound.
+   *
+   * @param {HlsSession} session
+   * @returns {{ video: boolean, audio: boolean }}
+   */
+  declaredTracks(session) {
+    const probed = this.getCachedMediaInfo?.({
+      sourceKey: session.sourceKey,
+      fileIndex: session.fileIndex
+    }) ?? null;
+    return {
+      video: Boolean(probed?.videoCodec),
+      audio: Boolean(probed?.audioCodec)
+    };
+  }
+
   async #initFromFirstSegment(session) {
     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 declared = this.declaredTracks(session);
+    let expectedTracks = (declared.video ? 1 : 0) + (declared.audio ? 1 : 0);
+    if (expectedTracks === 0) {
+      // Nothing 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 +1593,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;