@torrent-tv/proxy 2.49.0 → 2.50.0

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 2.50.0
+
+- **Fix**: An AVI seek is asked for late enough to survive the container's own arithmetic. AVI names a keyframe by its frame NUMBER, and `services/container-index/avi.js` turned that into a time by multiplying by the frame duration the header declares — which lands 10-44 ms from the presentation time the demuxer computes, always under one frame (measured 2026-08-21 against the files themselves: 1196 index entries against 1196 real keyframes and 901 against 901, the frames exactly right and only their names off). A name sitting just BELOW its real keyframe seeks to before it and lands on the one before that, which is the same fault the landing offset already exists for. The reader now declares how far its times may be, and the request carries that on top. Matroska and MP4 declare nothing, because they state instants outright — nine files and 11 665 keyframes with not one disagreement.
+- **Fix**: A container with no keyframe index is re-encoded rather than copied against a grid nobody knows. MPEG-TS carries no index of any kind — measured the same day, 669 real keyframes and nothing to read them from without walking the file — and a copied picture can only be cut at the source's own keyframes, so declaring an even grid is a falsehood the player punishes: it walks the whole file to rebuild the timeline, or presents audio with no picture because a segment begins with nothing decodable, both field-observed 2026-08-02. Re-encoding PLACES keyframes on our own cuts, so the grid is right by construction whatever the container. A container whose index could not be read inside the budget lands here too, for the same reason. It costs an encoder, and the alternative was a broken playlist.
+
 ## 2.49.0
 
 - **Fix**: The torrent worker is allowed to END rather than being torn down under itself. A core dump read on 2026-08-21 named the fault the proxy has been dying of: `SIGSEGV` in `v8::Value::IsArrayBufferView` reached through `napi_get_buffer_info` from utp-native's `on_utp_accept`, called from its UDP read — all of it inside `node::Environment::CleanupHandles`, under `FreeEnvironment`, on `Worker::Run`. That is a teardown race, not a data fault, which is why neither patch our forked library already carries touched it: a datagram arriving while the environment is being freed walks into an isolate that no longer exists. `destroyAll` called `Worker.terminate()` immediately after destroying the client inside, and `terminate()` frees the environment with libuv's handle callbacks still queued. It now waits for the thread to exit by itself — once the client is destroyed nothing holds its loop open — with `terminate()` kept as a five-second fallback, because a shutdown that hangs is worse than one that is forced.

package/package.json

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

package/services/container-index/avi.js

@@ -152,5 +152,16 @@ export async function readAviKeyframeTimes(readRange, fileSize) {
     }
     videoFrame += 1;
   }
-  return times.length > 0 ? times : null;
+  if (times.length === 0) {
+    return null;
+  }
+  // AVI names a keyframe by its FRAME NUMBER, and the time above is that number
+  // multiplied by the frame duration the header declares. The frames are the
+  // right ones — measured 2026-08-21 against the files themselves, 1196 index
+  // entries against 1196 real keyframes and 901 against 901, exactly — but the
+  // names are 10-44 ms away from the presentation times the demuxer computes,
+  // always under one frame. So the caller is told how far a time here may be
+  // from the instant it refers to, and can ask for a seek late enough that it
+  // still lands on the frame rather than on the one before it.
+  return { times, tolerance: secondsPerFrame };
 }

package/services/container-index/index.js

@@ -62,7 +62,7 @@ const READERS = [
  * @param {ReadRange} params.readRange
  * @param {number} params.fileSize
  * @param {string} [params.label] - For logging only.
- * @returns {Promise<{ times: number[] | null, format: string }>} Ascending
+ * @returns {Promise<{ times: number[] | null, format: string, tolerance: number }>} Ascending
  *   seconds, or null times when this file has no readable index — the caller
  *   must then not claim to know the grid. The format is which reader matched,
  *   reported whether or not it produced anything: how often an index disagrees
@@ -71,27 +71,39 @@ const READERS = [
  */
 export async function readKeyframeIndex({ readRange, fileSize, label = "" }) {
   if (typeof readRange !== "function" || !Number.isFinite(fileSize) || fileSize <= 0) {
-    return { times: null, format: "unknown" };
+    return { times: null, format: "unknown", tolerance: 0 };
   }
 
   const startedAt = Date.now();
   let times = null;
   let format = "unrecognised";
+  // How far a time in `times` may be from the instant it names. Zero wherever
+  // the container states instants outright, which Matroska and MP4 both do.
+  let tolerance = 0;
   try {
     const sniff = await readRange(0, Math.min(SNIFF_BYTES - 1, fileSize - 1));
     if (!sniff) {
-      return { times: null, format: "unread" };
+      return { times: null, format: "unread", tolerance: 0 };
     }
     const reader = READERS.find((candidate) => candidate.matches(sniff));
     if (reader) {
       format = reader.name;
-      times = await reader.read(readRange, fileSize);
+      const read = await reader.read(readRange, fileSize);
+      // A reader may answer with the times alone, or with how far those times
+      // may sit from the instants they name — which only AVI has to say,
+      // because only AVI computes them from frame numbers.
+      if (Array.isArray(read)) {
+        times = read;
+      } else if (read && Array.isArray(read.times)) {
+        times = read.times;
+        tolerance = Number.isFinite(read.tolerance) ? read.tolerance : 0;
+      }
     }
   } catch (error) {
     // A malformed or partially-downloaded index must never take playback down —
     // it only means the grid is unknown, which the caller already handles.
     logger.warn(`container-index: failed to read index for "${label}": ${error?.message ?? error}`);
-    return { times: null, format };
+    return { times: null, format, tolerance: 0 };
   }
 
   const elapsedMs = Date.now() - startedAt;
@@ -102,5 +114,5 @@ export async function readKeyframeIndex({ readRange, fileSize, label = "" }) {
   } else {
     logger.info(`container-index: no usable index for "${label}" (${format}, ${elapsedMs}ms)`);
   }
-  return { times, format };
+  return { times, format, tolerance };
 }

package/services/hls-session-manager.js

@@ -1196,12 +1196,17 @@ export function seekLandingOffsetFor(session, keyframe) {
   if (session?.transcodeVideo === true) {
     return 0;
   }
+  // A grid whose times are approximate needs that error added on top, or a name
+  // sitting just below its real keyframe seeks to before it and lands on the
+  // one before that. Only AVI declares one.
+  const tolerance = Number.isFinite(session?.keyframeTolerance) ? Math.max(0, session.keyframeTolerance) : 0;
+  const wanted = SEEK_LANDING_OFFSET_SEC + tolerance;
   const times = Array.isArray(session?.keyframeTimes) ? session.keyframeTimes : [];
   const next = times.find((time) => time > keyframe + 0.001);
   if (next === undefined) {
-    return SEEK_LANDING_OFFSET_SEC;
+    return wanted;
   }
-  return Math.min(SEEK_LANDING_OFFSET_SEC, (next - keyframe) / 2);
+  return Math.min(wanted, (next - keyframe) / 2);
 }
 
 /**
@@ -1746,6 +1751,13 @@ export class HlsSessionManager {
     // branches; on failure both fall back to their current behaviour (uniform
     // grid for boundaries, raw target for seeking) — no regression.
     let keyframeTimes = null;
+    // How far a time in `keyframeTimes` may sit from the instant it names. Only
+    // AVI has anything to declare here: it stores frame NUMBERS and the time is
+    // that number times the frame duration, which lands 10-44 ms from the
+    // presentation time the demuxer computes (measured 2026-08-21). A seek made
+    // at such a name can fall just BELOW the real keyframe and land on the one
+    // before it, which is the same fault the landing offset exists for.
+    let keyframeTolerance = 0;
     let keyframeMs = -1; // -1 = not run (skipped), -2 = running in the background
     // Which container supplied the index, carried so the accuracy summary can
     // say what it is a summary OF.
@@ -1758,6 +1770,9 @@ export class HlsSessionManager {
     if (inheritedGrid) {
       keyframeTimes = inheritedGrid.keyframeTimes;
       containerFormat = inheritedGrid.containerFormat ?? "";
+      keyframeTolerance = Number.isFinite(inheritedGrid.keyframeTolerance)
+        ? inheritedGrid.keyframeTolerance
+        : 0;
     } else if (hasDuration && !transcodeVideo && !audioOnly) {
       // Video-COPY path: keyframeTimes are REQUIRED to build correct segment
       // boundaries (the playlist itself), so this MUST block session creation —
@@ -1779,11 +1794,28 @@ export class HlsSessionManager {
       const index = await this.#readContainerKeyframes({ sourceKey, fileIndex, inputUrl, logName });
       keyframeTimes = index.times;
       containerFormat = index.format;
+      keyframeTolerance = Number.isFinite(index.tolerance) ? index.tolerance : 0;
       keyframeMs = Date.now() - keyframeStartMs;
       if (!keyframeTimes) {
+        // No index, so there is no honest grid for a COPY: a copied picture can
+        // only be cut at the source's own keyframes, and we do not know where
+        // they are. Declaring an even grid instead is a falsehood the player
+        // punishes — it walks the whole file to rebuild the timeline, or shows
+        // audio with no picture because a segment begins with nothing
+        // decodable (both field-observed 2026-08-02).
+        //
+        // Re-encoding is the honest answer and costs an encoder: keyframes are
+        // then PLACED at our own cut times rather than found, so the grid is
+        // correct by construction whatever the container. MPEG-TS is the case
+        // this exists for — measured 2026-08-21, 669 real keyframes and no
+        // index of any kind to read them from — and a container whose index
+        // could not be read in the budget lands here too, which is right for
+        // the same reason.
+        transcodeVideo = true;
         logger.warn(
-          `transcode ${sessionId}: no container keyframe index for "${logName}"; ` +
-            `falling back to a uniform grid — segment boundaries will not match the media`
+          `transcode ${sessionId}: no keyframe index in the ${containerFormat} container for ` +
+            `"${logName}" — a copied picture has no honest grid without one, so the video is ` +
+            "re-encoded instead and its keyframes are placed on our own cuts"
         );
       }
     } else if (hasDuration && transcodeVideo) {
@@ -2035,6 +2067,9 @@ export class HlsSessionManager {
       // KNOWN valid position instead of trusting the container's own on-the-fly
       // seek at an arbitrary target — see the probe call above for why.
       keyframeTimes,
+      // How far those times may sit from the instants they name — nonzero only
+      // for AVI, which computes them from frame numbers.
+      keyframeTolerance,
       // Which container the index came from, and how well it has held up. The
       // cut times of a copied video ARE its index, and an index can be wrong —
       // measured 2026-08-06, one claimed a keyframe four seconds from where the
@@ -6848,6 +6883,7 @@ export class HlsSessionManager {
             // creations (field 2026-08-17, corrections of 0.6-2.9 s).
             published: base.publishedBoundaries,
             keyframeTimes: base.keyframeTimes,
+            keyframeTolerance: base.keyframeTolerance,
             containerFormat: base.containerFormat
           }
         : null,

package/test/seek-landing.test.js

@@ -48,3 +48,29 @@ test("no keyframe list is still answered", () => {
   assert.equal(seekLandingOffsetFor({ transcodeVideo: false }, 5), OFFSET);
   assert.equal(seekLandingOffsetFor(null, 5), OFFSET);
 });
+
+test("a grid whose times are approximate is asked for that much later again", () => {
+  // AVI names a keyframe by its frame NUMBER and the time is that number times
+  // the frame duration, so a name can sit just BELOW the keyframe it refers to
+  // — measured 2026-08-21, 10-44 ms out on two files, always under one frame.
+  // Asking at the name alone would seek to before the real keyframe and land on
+  // the one before that, which is the fault this offset exists for.
+  const session = {
+    transcodeVideo: false,
+    keyframeTolerance: 0.04,
+    keyframeTimes: [0, 4.004, 8.008, 12.012]
+  };
+  assert.equal(seekLandingOffsetFor(session, 4.004), OFFSET + 0.04);
+});
+
+test("an exact grid claims no tolerance", () => {
+  // Matroska and MP4 state instants outright — measured the same day, nine
+  // files and 11 665 keyframes with not one disagreement.
+  const session = { transcodeVideo: false, keyframeTolerance: 0, keyframeTimes: [0, 4.004, 8.008] };
+  assert.equal(seekLandingOffsetFor(session, 4.004), OFFSET);
+});
+
+test("the bound still holds once a tolerance is added", () => {
+  const session = { transcodeVideo: false, keyframeTolerance: 1, keyframeTimes: [0, 0.1, 0.2] };
+  assert.equal(seekLandingOffsetFor(session, 0.1), 0.05);
+});