@torrent-tv/proxy 2.36.1 → 2.36.2

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 2.36.2
+
+- **Fix**: A live session no longer answers 404 to the master playlist it has just published. The browser is handed `master.m3u8` when the session is created, and which rungs are worth OFFERING is recomputed every five seconds — so on 2026-08-18 a five-rung offer became a one-rung offer **192 ms** after creation (the session's own encoder started, charging the contention penalty of 2.35.0, and the first supply reading raised the bar of 2.36.0 from 1.00x to 1.06x), `buildMasterPlaylist` returned null for having fewer than two rungs, and the master answered 404. hls.js treats that as fatal and unrecoverable, so nothing played at all. The master now lists what CAN be spliced onto this session's cut grid — a fact about the source, settled once — while the live judgement stays where it belongs, in `offeredHeights` and in every progress report, which is what the viewer's menu already follows. The variant routes honour the published set too, so a quality switch can no longer meet a 404 on a rung the master named.
+- **Fix**: Peer discovery no longer starves behind name resolution. Node resolves host names on the libuv thread pool, which holds four threads by default; a torrent announces to every tracker in its file at once, so four names resolve and the rest queue — and a tracker that no longer exists holds its thread for the resolver's full ten-second timeout while every announce behind it blows its own fifteen-second deadline. Measured inside the addon container: the ten trackers of one film took **7.58 s** to resolve as a burst and **27-42 ms** each with a larger pool. That film has 517 seeders on a tracker that answers in 50 ms, and it spent eleven minutes with **zero peers** while four other torrents in the same process were fine — they were the ones whose live trackers happened to fall in the first four. The pool is now stated before anything can create it (`services/thread-pool.js`, imported first by the entry point), and a deployment that states its own size is left alone.
+
 ## 2.36.1
 
 - **Fix**: The cut list of a copied picture is built from the picture's own keyframes, and no longer from every entry in the container's table. A Matroska CuePoint belongs to the track named inside it, and RFC 9559 leaves the muxer free to index whichever tracks it likes — both field files index their subtitles as well. Measured over the swarm on 2026-08-18, reading only the head and the table: `Minions.and.Monsters.1080p.mkv` has **2778 video entries, one every 2.002 s, and 4669 more across four subtitle tracks**; `Moana.2.2024.720p.BluRay … MegaPeer.mkv` has **1055 video entries and 5007 across five**. Read without the track, the extra times entered the cut list as though they were keyframes; ffmpeg can only cut a copied picture at a real keyframe at or after the time it is given, so each such cut landed at the next one instead — which is exactly the disagreement the field measured, and why it was always positive: 2.002 s on the first file (its own keyframe spacing), a median of 6.3 s and a worst case of 21 s on the second. The reader now takes the first video track's number from Tracks — already inside the head it fetches, with one short extra read only for a file that keeps Tracks elsewhere — and keeps the entries of that track. Nothing else about the two-read approach changes, and a session costs nothing more. With the fix the same two files read 2778 and 1055 times, all of them keyframes. When the filter leaves NOTHING — a table whose entries name a track number Tracks never declares — the unfiltered table is used rather than no table: that case is this reader failing to recognise the file, and answering with nothing would put an even grid on a copied picture, which is the failure it exists to prevent.

package/bin/cli.js

@@ -8,6 +8,11 @@
  * automatically on reconnect so the server's in-memory store stays consistent.
  */
 
+// FIRST, and it must stay first: it sets how many blocking calls this process
+// can have in flight, and a module's imports are evaluated before its body, so
+// anything imported above it would get the default pool. See the file itself
+// for the measurement that made it necessary.
+import "../services/thread-pool.js";
 import { Command } from "commander";
 import crypto from "node:crypto";
 import { spawnSync } from "node:child_process";

package/package.json

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

package/services/hls-session-manager.js

@@ -2065,7 +2065,7 @@ export class HlsSessionManager {
     // flip the arrangement under a stream that is playing.
     session.audioSeparate = inheritedAudioSeparate === null
       ? audioRenditions === true &&
-        this.#variantHeights(session).length >= 2 &&
+        this.#splicableHeights(session).length >= 2 &&
         this.#audioRenditionsOf(session).length > 0
       : inheritedAudioSeparate === true;
 
@@ -5379,6 +5379,42 @@ export class HlsSessionManager {
     return session.variantHeight;
   }
 
+  /**
+   * The heights this file's variants CAN be spliced at — a fact about the
+   * source and the cut grid, settled once and never moved.
+   *
+   * Separate from {@link #variantHeights}, which answers a different question:
+   * which of them are worth OFFERING to the viewer right now, on a machine
+   * whose load moves every five seconds. Both were the same list until
+   * 2026-08-18, and that is what broke playback outright: the browser is told
+   * at session creation that a master playlist exists, and 192 ms later — after
+   * the session's own encoder had started and the first supply reading had
+   * arrived — the live list had fallen from five rungs to one, `buildMaster
+   * Playlist` returned null for having fewer than two, and the master answered
+   * 404 to the very session that had just published it. hls.js treats that as
+   * fatal and unrecoverable, so nothing played at all (session `4ef731d8`,
+   * "Moana (2016).mkv", 17:43:01).
+   *
+   * A live figure may decide what to offer. It may not decide whether a
+   * published document exists.
+   *
+   * @param {HlsSession} session
+   * @returns {number[]} Largest first.
+   */
+  #splicableHeights(session) {
+    const owner = this.#baseOf(session);
+    if (Array.isArray(owner.splicableHeights)) {
+      return owner.splicableHeights;
+    }
+    const heights = new Set(variantHeightsFor(Number(owner.sourceHeight) || 0));
+    const own = this.variantHeightOf(owner);
+    if (own > 0) {
+      heights.add(own);
+    }
+    owner.splicableHeights = [...heights].sort((left, right) => right - left);
+    return owner.splicableHeights;
+  }
+
   /**
    * The heights this session's file is offered at, largest first.
    *
@@ -6540,8 +6576,11 @@ export class HlsSessionManager {
       return null;
     }
     // Only the heights the master offers. Anything else is a made-up request,
-    // and honouring it would let a client start encoder runs at will.
-    if (!this.#variantHeights(base).includes(height)) {
+    // and honouring it would let a client start encoder runs at will. The
+    // MASTER's list, not the live one: a rung is published for the session's
+    // whole life, and refusing what we published is how a quality switch became
+    // a 404 storm across every level.
+    if (!this.#splicableHeights(base).includes(height)) {
       return null;
     }
     if (height === this.variantHeightOf(base)) {
@@ -6690,7 +6729,7 @@ export class HlsSessionManager {
     if (!isPlaylist && !isInit && !isSegment) {
       return { sessionId: null };
     }
-    if (!this.#variantHeights(base).includes(height)) {
+    if (!this.#splicableHeights(base).includes(height)) {
       return { sessionId: null };
     }
     // Answered from the base, and no encoder is started for it. Every variant of
@@ -6945,7 +6984,11 @@ export class HlsSessionManager {
       return null;
     }
     const sourceHeight = Number(session.sourceHeight) || 0;
-    const rungs = this.#variantHeights(session);
+    // What CAN be spliced, not what is worth offering this second. The live
+    // judgement travels in `offeredHeights` and in every progress report, which
+    // is what the viewer's menu follows; letting it decide the master's
+    // existence made a live session answer 404 to its own published address.
+    const rungs = this.#splicableHeights(session);
     if (rungs.length < 2) {
       return null;
     }

package/services/thread-pool.js

@@ -0,0 +1,30 @@
+/**
+ * @file How many blocking calls this process can have in flight — set before
+ * anything makes one.
+ *
+ * Node resolves host names with `getaddrinfo`, which runs on the libuv thread
+ * pool, and that pool holds FOUR threads by default. A torrent announces to
+ * every tracker in its file at once — ten or thirteen of them — so four names
+ * are resolved and the rest queue; a tracker that no longer exists holds its
+ * thread for the resolver's full ten-second timeout, and every announce behind
+ * it blows its own fifteen-second deadline.
+ *
+ * Measured inside the addon container on 2026-08-18, resolving the ten trackers
+ * of one film: as a burst on the default pool, two names answered in 30-40 ms
+ * and the other seven took **7.58 s**; with a larger pool every live name
+ * answered in **27-42 ms**. The film itself had 517 seeders on a tracker that
+ * answers in 50 ms, and spent eleven minutes with zero peers, because every
+ * announce — UDP and HTTP alike — timed out waiting for a name.
+ *
+ * Sized to hold several torrents' announce lists at once, since the same pool
+ * also serves this process's file reads. Idle threads cost memory and nothing
+ * else, and a deployment that states its own size is left alone.
+ *
+ * Imported FIRST by the entry point, because a module's imports are evaluated
+ * before its body: written as a statement in `cli.js` this would run after
+ * every other import had already had its chance to create the pool.
+ */
+
+if (!process.env.UV_THREADPOOL_SIZE) {
+  process.env.UV_THREADPOOL_SIZE = "64";
+}

package/test/decode-cost.test.js

@@ -288,7 +288,7 @@ test("the source's decode figures come off the probe, or not at all", () => {
   assert.equal(sourceDecodeCharacteristics(null), null);
 });
 
-test("the master playlist drops the rungs the host cannot hold", async (t) => {
+test("the OFFER drops the rungs the host cannot hold, and the master keeps addressing them", async (t) => {
   const dirPath = await mkdtemp(path.join(os.tmpdir(), "decode-cost-"));
   const manager = new HlsSessionManager({
     enabled: true,
@@ -339,15 +339,22 @@ test("the master playlist drops the rungs the host cannot hold", async (t) => {
   };
   manager.sessionsById.set(session.id, session);
 
-  assert.equal(
-    manager.buildMasterPlaylist(session.id),
-    null,
-    "every rung under the copy runs below realtime here, so there is nothing to switch to"
-  );
   assert.deepEqual(
     manager.offeredHeights(session),
     [1080],
-    "and the list the browser is given says the same, since both come from one answer"
+    "every rung under the copy runs below realtime here, so there is nothing to switch to"
+  );
+  // The master is NOT that answer. It says which rungs can be spliced onto this
+  // cut grid, which is a fact about the file, and it has to hold still for the
+  // session's life: the browser is handed its address at creation, and a live
+  // figure that withdrew it left a session answering 404 to itself (field
+  // 2026-08-18, "Moana (2016).mkv" — nothing played at all).
+  const weakMaster = manager.buildMasterPlaylist(session.id);
+  assert.ok(weakMaster, "published once, whatever the host is managing this second");
+  assert.deepEqual(
+    [...weakMaster.matchAll(/^v\/(\d+)\/index\.m3u8$/gm)].map((match) => Number(match[1])),
+    [1080, 720, 540, 480, 360, 240],
+    "the ladder of the source, addressable — the menu the viewer sees is offeredHeights"
   );
 
   // A host with a little more encoder keeps the rungs it can actually hold. A
@@ -355,11 +362,18 @@ test("the master playlist drops the rungs the host cannot hold", async (t) => {
   manager.softwarePresetBenchmark = [{ preset: "ultrafast", pixelsPerSec: 12e6 }];
   const stronger = { ...session, id: "dddddddd-eeee-ffff-0000-111111111111", offeredHeightsCache: undefined };
   manager.sessionsById.set(stronger.id, stronger);
+  assert.deepEqual(
+    manager.offeredHeights(stronger),
+    [1080, 360, 240],
+    "nothing is known about this swarm, so the bar is realtime"
+  );
   const master = manager.buildMasterPlaylist(stronger.id);
-  assert.ok(master, "1080p copied plus the rungs this host can produce");
-  const heights = [...master.matchAll(/^v\/(\d+)\/index\.m3u8$/gm)].map((match) => Number(match[1]));
-  assert.deepEqual(heights, [1080, 360, 240], "nothing is known about this swarm, so the bar is realtime");
-  assert.deepEqual(manager.offeredHeights(stronger), heights);
+  assert.ok(master, "1080p copied plus every rung that can be spliced beside it");
+  assert.deepEqual(
+    [...master.matchAll(/^v\/(\d+)\/index\.m3u8$/gm)].map((match) => Number(match[1])),
+    [1080, 720, 540, 480, 360, 240],
+    "the same published set as before: what the host manages is the offer's business, not the document's"
+  );
 
   // The same host, once the reader has measured what this file's supply
   // demands: waits arriving as they did on the field torrent of 2026-08-17 ask

package/test/quality-variants.test.js

@@ -813,3 +813,49 @@ test("a quality step being warmed is not refused by its own cost", async (t) =>
       "offer by the act of warming it — and its next segment 404s on a stream that is playing"
   );
 });
+
+test("the master survives a live offer that has collapsed to one rung", async (t) => {
+  // The field case of 2026-08-18, in the smallest form that reproduces it: a
+  // host too slow for any re-encoded rung, and a swarm whose interruptions
+  // demand far more than realtime. The live offer then holds only the height an
+  // encoder is already producing — and until this test existed, that made
+  // `buildMasterPlaylist` answer null and the route answer 404 to a session
+  // that had just published the address.
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "quality-variants-collapse-"));
+  const manager = new HlsSessionManager({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090,
+    // A megapixel a second: every rung below the source costs more than the
+    // machine has.
+    softwarePresetBenchmark: [{ preset: "veryfast", pixelsPerSec: 1_000_000 }],
+    decodeCostModel: { pixelTerm: 0.01, bitrateTerm: 0, constantTerm: 0 }
+  });
+  const base = fakeSession({ id: BASE_ID, encodeHeight: 812, dirPath });
+  base.sourceDecode = { megapixelsPerSecond: 50, megabitsPerSecond: 10 };
+  // What this file's own reader measured: a step must run at eight times
+  // realtime to survive this swarm.
+  base.supplyFigures = { requiredSpeed: 8 };
+  manager.sessionsById.set(BASE_ID, base);
+  t.after(async () => {
+    await manager.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+
+  assert.deepEqual(
+    manager.offeredHeights(base),
+    [812],
+    "the live judgement is unchanged: nothing but the running height is worth offering"
+  );
+
+  const master = manager.buildMasterPlaylist(BASE_ID);
+
+  assert.ok(master, "the master is a published document, not a live figure");
+  const heights = [...master.matchAll(/^v\/(\d+)\/index\.m3u8$/gm)].map((match) => Number(match[1]));
+  assert.deepEqual(
+    heights,
+    [1080, 812, 720, 540, 480, 360, 240],
+    "every rung that can be spliced onto this cut grid stays addressable"
+  );
+});

package/test/thread-pool.test.js

@@ -0,0 +1,53 @@
+/**
+ * @file The blocking-call pool is stated before anything can create it.
+ *
+ * Field 2026-08-18: a film with 517 seeders spent eleven minutes with zero
+ * peers on the addon host. Every announce timed out — UDP and HTTP alike — and
+ * the cause was not the network: resolving that torrent's ten tracker names as
+ * a burst took 7.58 s on the default four-thread pool, against 27-42 ms each
+ * when the pool was larger. A dead tracker holds a thread for the resolver's
+ * whole timeout, and every announce queued behind it misses its own deadline.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+test("the pool is set, and left alone when the deployment states its own", async () => {
+  const previous = process.env.UV_THREADPOOL_SIZE;
+  try {
+    process.env.UV_THREADPOOL_SIZE = "";
+    await import(`../services/thread-pool.js?first=${Date.now()}`);
+    assert.equal(
+      Number(process.env.UV_THREADPOOL_SIZE) >= 16,
+      true,
+      "enough threads for a torrent's whole announce list to resolve at once"
+    );
+
+    process.env.UV_THREADPOOL_SIZE = "8";
+    await import(`../services/thread-pool.js?stated=${Date.now()}`);
+    assert.equal(process.env.UV_THREADPOOL_SIZE, "8", "a stated size is the deployment's to choose");
+  } finally {
+    if (previous === undefined) {
+      delete process.env.UV_THREADPOOL_SIZE;
+    } else {
+      process.env.UV_THREADPOOL_SIZE = previous;
+    }
+  }
+});
+
+test("the entry point imports it before anything that could create the pool", async () => {
+  const cli = await readFile(path.join(here, "..", "bin", "cli.js"), "utf8");
+  const imports = [...cli.matchAll(/^import\s.*?from\s+["'](.+?)["'];|^import\s+["'](.+?)["'];/gm)]
+    .map((match) => match[1] ?? match[2]);
+
+  assert.equal(
+    imports[0],
+    "../services/thread-pool.js",
+    "a module's imports run before its body, so this cannot be a statement in cli.js"
+  );
+});