@torrent-tv/proxy 2.9.120 → 2.9.122

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 2.9.122
+
+- **Fix**: A session created with a start position begins encoding there, instead of at the top of the file. The position was honoured everywhere except the one place that mattered: it went into the session key and into the log line, and then the first run started at index 0 regardless. Measured 2026-08-06 on a Retry after the proxy had restarted — the session was created with `start=1580s`, the encoder began at #0, the player asked for #152, and 45 s later the browser gave up with "no data arrived from the proxy" while the transcode ran happily at 9.9x through the opening credits.
+
+## 2.9.121
+
+- **Fix**: A segment that is short of a track is no longer served, which is what left a seek hanging with the proxy answering every request in 98 ms. A run that is terminated closes its current output file properly — trailing index and all — but the file holds only what had been muxed by then, and after a seek-restart that is routinely one track of two. Nothing about such a file looks unfinished: it exists, the next one exists, so the readiness rule called it done. Measured 2026-08-06 on a stuck session: segment #133 carried one `tfdt` where #131 and #134 carried two, and #132 was zero bytes. The fragments are already walked to stamp their timestamps, so counting the tracks in them costs nothing; a segment missing one is deleted and produced again.
+- **New**: The session-start line says where the browser asked the encoder to begin. A resume that reaches hls.js but not this call makes the player request a segment nobody was told to produce — measured the same day, the session began at #0 while the player asked for #127 and gave up 45.6 s later — and neither side said what it meant.
+
 ## 2.9.120
 
 - **Fix**: The rest of the file is fetched while the viewer needs nothing, instead of the link sitting idle. The background fill was re-evaluated only when a reader window MOVED, so during exactly the state it exists for — the encoder held back by the look-ahead cap, the viewer comfortably ahead, the link free — nothing was fetched at all. It is now owned by the pool's own timer rather than by the reader, because a parked reader cannot act, and parked is the whole point. Priority 0 against the window's 1, and withdrawn the moment any reader window wants something, so it can never take capacity from the picture.

package/package.json

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

package/services/hls-session-manager.js

@@ -8,7 +8,7 @@
  */
 
 import { createReadStream, readdirSync } from "node:fs";
-import { access, mkdir, readdir, readFile, rm, stat } from "node:fs/promises";
+import { access, mkdir, readdir, readFile, rm, stat, unlink } from "node:fs/promises";
 import { Readable } from "node:stream";
 import os from "node:os";
 import path from "node:path";
@@ -1430,6 +1430,12 @@ export class HlsSessionManager {
       // one of these, so "is the host actually running the build I published?"
       // is answered by the log itself instead of a round trip to the machine.
       `transcode ${sessionId} start (proxy ${PROXY_VERSION}) "${logName}" ` +
+        // Where the browser asked the encoder to begin. A resume that reaches
+        // hls.js but not this call makes the player request a segment nobody
+        // was told to produce: measured 2026-08-06, the session began at #0
+        // while the player asked for #127 and gave up 45.6 s later. Neither
+        // side saying what it meant is why that took three attempts to place.
+        `start=${Math.round(normalizedStartPosition)}s ` +
         `video=${transcodeVideo ? `${this.videoEncoder.name}${softwarePreset ? `/${softwarePreset}` : ""}` : "copy"} ` +
         `audio=${transcodeAudio ? "aac" : "copy"} ` +
         // Branch tag for log correlation: A = video re-encode (fixed GOP, grid
@@ -1448,7 +1454,18 @@ export class HlsSessionManager {
         `duration=${hasDuration ? formatSeconds(durationSeconds) : "unknown"} segments=${segmentCount}`
     );
 
-    await this.#startEncodeRun(session, 0);
+    // Begin where the viewer asked, not at the top of the file. The position
+    // was already honoured everywhere EXCEPT here: it went into the session key
+    // and into the log line, and then the first run started at index 0 anyway.
+    // Measured 2026-08-06 on a Retry after the proxy restarted — the session
+    // was created with `start=1580s`, the encoder began at #0, the player
+    // asked for #152, and 45 s later the browser gave up with "no data arrived
+    // from the proxy" while the transcode ran happily at 9.9x through the
+    // opening credits.
+    const firstIndex = normalizedStartPosition > 0
+      ? this.#segmentIndexForTime(session, normalizedStartPosition)
+      : 0;
+    await this.#startEncodeRun(session, firstIndex);
 
     try {
       await this.waitUntilReady(session);
@@ -3388,6 +3405,30 @@ export class HlsSessionManager {
         const bytes = session.usesExplicitCuts && session.segmentFormat.stripInit
           ? session.segmentFormat.stripInit(raw)
           : raw;
+        // A segment that is short of a track is not servable, whatever the
+        // directory says about it. A terminated run closes its current output
+        // file properly — trailing index and all — but with only what had been
+        // muxed by then, and after a seek-restart that is routinely one track
+        // of two. The file exists and so does the next one, so the readiness
+        // rule calls it done. Measured 2026-08-06: segment #133 held one track
+        // where its neighbours held two, the proxy answered every request for
+        // it in 98 ms, and the viewer's seek never completed. Treated as not
+        // ready, so the encoder makes it again.
+        if (
+          typeof session.segmentFormat.hasEveryTrack === "function" &&
+          !session.segmentFormat.hasEveryTrack(bytes, session.initBytes ?? null)
+        ) {
+          logger.warn(
+            `transcode ${session.id} segment #${index} is short of a track — ` +
+            "left behind by a run that was terminated; producing it again"
+          );
+          try {
+            await unlink(filePath);
+          } catch {
+            // Already gone, or being rewritten: either way nothing to do.
+          }
+          return { kind: "warming-up" };
+        }
         const prepared = session.segmentFormat.prepareSegmentBytes(bytes, {
           startSeconds: this.#segmentStartTime(session, index),
           initBytes: session.initBytes ?? null

package/services/segment-formats/fmp4.js

@@ -10,7 +10,23 @@
  * See {@link SegmentFormat} in `./index.js` for the interface contract.
  */
 
-import { readTrackTimescales, stampSegmentStartTime } from "./mp4-boxes.js";
+import { readTrackTimescales, stampSegmentStartTime, walkBoxes } from "./mp4-boxes.js";
+
+/**
+ * How many distinct tracks have a fragment in this segment.
+ *
+ * @param {Buffer} bytes
+ * @returns {number}
+ */
+function countFragmentTracks(bytes) {
+  const tracks = new Set();
+  walkBoxes(bytes, (type, bodyStart) => {
+    if (type === "tfhd" && bodyStart + 8 <= bytes.length) {
+      tracks.add(bytes.readUInt32BE(bodyStart + 4));
+    }
+  });
+  return tracks.size;
+}
 
 /**
  * Where the fragments begin and where the trailing index starts, as offsets of
@@ -185,6 +201,35 @@ export const fmp4Format = {
    */
   needsSegmentRewrite: true,
 
+  /**
+   * Whether a segment carries every track the init promises.
+   *
+   * A run that is TERMINATED closes its current output file properly — trailing
+   * index and all — but the file holds only what had been muxed by then, which
+   * after a seek-restart is routinely one track of two. Nothing about it looks
+   * unfinished: the file exists, the next one exists, so the readiness rule
+   * calls it done and it is served. The player then cannot use it and the seek
+   * never completes. Measured 2026-08-06: segment #133 carried one `tfdt`
+   * where its neighbours carried two, and a viewer sat on a spinner while the
+   * proxy answered every request in 98 ms.
+   *
+   * Cheap to check: the fragments are already walked to stamp them.
+   *
+   * @param {Buffer} bytes - The media segment, init header already removed.
+   * @param {Buffer | null} initBytes
+   * @returns {boolean} False only when a track is provably missing.
+   */
+  hasEveryTrack(bytes, initBytes) {
+    if (!initBytes || initBytes.length === 0) {
+      return true;
+    }
+    const expected = readTrackTimescales(initBytes);
+    if (expected.size === 0) {
+      return true;
+    }
+    return countFragmentTracks(bytes) >= expected.size;
+  },
+
   prepareSegmentBytes(bytes, { startSeconds, initBytes }) {
     if (!initBytes || initBytes.length === 0) {
       // No init cached yet — nothing to read timescales from. The player always

package/test/fmp4-track-completeness.test.js

@@ -0,0 +1,41 @@
+/**
+ * @file A segment that is short of a track must not be served.
+ *
+ * A run that is terminated closes its current output file properly — trailing
+ * index and all — but the file holds only what had been muxed by then, and
+ * after a seek-restart that is routinely one track of two. Nothing about it
+ * looks unfinished, so the readiness rule called it done and served it, and the
+ * player could not complete the seek. Measured 2026-08-06: segment #133 carried
+ * one `tfdt` where its neighbours carried two, every request for it was
+ * answered in 98 ms, and the viewer sat on a spinner.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { fmp4Format } from "../services/segment-formats/fmp4.js";
+// Build a minimal init declaring two tracks, and fragments declaring one/two.
+function box(type, body) {
+  const b = Buffer.alloc(8 + body.length);
+  b.writeUInt32BE(8 + body.length, 0); b.write(type, 4, "latin1"); body.copy(b, 8);
+  return b;
+}
+function mdhd(timescale) { const b = Buffer.alloc(20); b.writeUInt32BE(timescale, 12); return box("mdhd", b); }
+function tkhd(id) { const b = Buffer.alloc(84); b.writeUInt32BE(id, 12); return box("tkhd", b); }
+function trak(id, ts) { return box("trak", Buffer.concat([tkhd(id), box("mdia", mdhd(ts))])); }
+const init = box("moov", Buffer.concat([trak(1, 16000), trak(2, 48000)]));
+function tfhd(id) { const b = Buffer.alloc(8); b.writeUInt32BE(id, 4); return box("tfhd", b); }
+function moof(ids) { return box("moof", Buffer.concat(ids.map((id) => box("traf", tfhd(id))))); }
+
+test("a segment with every track is accepted", () => {
+  assert.equal(fmp4Format.hasEveryTrack(moof([1, 2]), init), true);
+});
+test("a segment left short of a track by a killed run is refused", () => {
+  assert.equal(fmp4Format.hasEveryTrack(moof([1]), init), false,
+    "one track of two is what a terminated run leaves behind, and it looks complete");
+});
+test("an empty file is refused", () => {
+  assert.equal(fmp4Format.hasEveryTrack(Buffer.alloc(0), init), false);
+});
+test("without an init there is nothing to compare against, so it is allowed", () => {
+  assert.equal(fmp4Format.hasEveryTrack(moof([1]), null), true);
+});