@torrent-tv/proxy 2.99.20 → 2.100.0

package/bin/cli.js

@@ -89,7 +89,7 @@ program
   .option("--no-port-mapping", "Disable automatic UPnP/NAT-PMP port mapping")
   .option("--delivery-sink", "Serve /api/delivery-sink, a torrent-free byte stream for delivery testing")
   .option("--pin-preset <name>", "Encode every software picture at this libx264 preset only, for runs that must be compared at one quality (off by default)")
-  .option("--profile-start <seconds>", "Profile the main thread's CPU for this many seconds from the first source opened, written beside the state (off by default)")
+  .option("--profile-start <seconds>", "Profile the CPU of the main thread and the torrent thread for this many seconds from the first source opened, written beside the state (off by default)")
   .option(
     "--send-chunk-bytes <bytes>",
     "Size of one data-channel message when sending a response body (0 = whatever the body read hands over, ~64KB). For measuring whether the delivery wedge depends on that size."

package/package.json

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

package/server.js

@@ -868,7 +868,7 @@ export async function startProxyServer({
     },
     // `timing`, when given, is told how long each read of a file waited behind
     // the reads asked before it and how long it took (torrent-tv/meta#166).
-    resolveEncodeInput: async (output, fromIndex, toIndex, timing = null) => {
+    resolveEncodeInput: async (output, fromIndex, toIndex, timing = null, isCurrent = null) => {
       const grid = output.timeline?.published ?? output.timeline?.boundaries;
       const from = grid?.[fromIndex], to = grid?.[toIndex + 1];
       if (!Number.isFinite(from) || !(to > from)) return { kind: "terminal", reason: "output-interval-not-declared" };
@@ -914,6 +914,7 @@ export async function startProxyServer({
         if (media.kind !== "result") return media;
         const timeShiftSeconds = Number(media.value?.startTimeSeconds) || 0;
         const sourceInterval = output.timeline.sourceInterval(fromIndex, toIndex, timeShiftSeconds);
+        if (isCurrent) params.isCurrent = isCurrent;
         params.packetInterval = { ...sourceInterval,
           trackIds: wanted.map(track => track.trackNumber),
           modes: Object.fromEntries(wanted.map(track => [track.trackNumber, modes.get(track)])) };
@@ -1098,7 +1099,8 @@ export async function startProxyServer({
     seconds: profileStartSeconds,
     dir: stateDir || "",
     log: (line) => logger.info(line),
-    mayKeep: (bytes) => diagnostics?.mayKeep?.({ what: "a CPU profile", bytes }) ?? true
+    mayKeep: (bytes) => diagnostics?.mayKeep?.({ what: "a CPU profile", bytes }) ?? true,
+    torrentThread: (seconds) => torrentPool.cpuProfile?.(seconds) ?? Promise.resolve(null)
   });
   startProcessorReport({
     log: (line) => logger.info(line),

package/services/encode/EncodeInputs.js

@@ -92,10 +92,10 @@ export class EncodeInputs {
   }
 
   /** The container's statement of an interval, its time added to the request's account. */
-  async #resolveTimed(timing, output, from, to) {
+  async #resolveTimed(timing, output, from, to, isCurrent = null) {
     const startedAt = this.#now();
     try {
-      return await this.#resolve(output, from, to, timing);
+      return await this.#resolve(output, from, to, timing, isCurrent);
     } finally {
       timing.resolutions += 1;
       timing.resolveMs += this.#now() - startedAt;
@@ -384,7 +384,11 @@ export class EncodeInputs {
       reads: 0, queuedMs: 0, readMs: 0, heldMs: 0, budgetMs: 0 };
     request.timing.attempts += 1;
     request.promise = (async () => {
-      const resolved = await this.#resolveTimed(request.timing, request.output, request.from, request.from);
+      // A request the plan withdraws stops its reads: a soundtrack piece's
+      // packet walk, left to run, held the file's reads and the piece the
+      // viewer had seeked to waited 16.9 s behind it (r59, torrent-tv/meta#178).
+      const resolved = await this.#resolveTimed(request.timing, request.output, request.from, request.from,
+        () => this.#requests.get(request.key) === request);
       if (resolved.kind === "result") this.#original.set(request.output, resolved.sources?.every(source => source.input.original === true) === true);
       if (this.#requests.get(request.key) !== request) return;
       let result;

package/services/media/ContainerOrchestrator.js

@@ -215,7 +215,8 @@ export class ContainerOrchestrator {
         value = await container.readSourceRanges(params.packetInterval);
         if (value.kind !== "result") return { ...value, requestId };
       } else if (statement === "packets") {
-        value = await container.readPacketIndex(params.packetInterval);
+        value = await container.readPacketIndex(params.packetInterval, { isCurrent: params.isCurrent });
+        if (value === null) return { kind: "terminal", reason: "request-obsolete", requestId };
         await value?.prepareAudioDependencies?.(params.packetInterval, container.readRange);
       } else {
         throw new TypeError(`Unknown media statement: ${statement}`);

package/services/media/container/MatroskaContainer.js

@@ -782,7 +782,12 @@ export class MatroskaContainer extends Container {
       streamSearchSeconds: FFMPEG_STREAM_SEARCH_SECONDS };
   }
 
-  async readPacketIndex(interval) {
+  /**
+   * @param {object} [interval]
+   * @param {{ isCurrent?: () => boolean }} [options] - A walk whose request is
+   *   no longer current stops between clusters and answers null.
+   */
+  async readPacketIndex(interval, { isCurrent } = {}) {
     if (this.#packets) return this.#packets;
     const layout = await this.#segmentLayout();
     if (!layout) throw new Error("Matroska Segment is absent.");
@@ -801,7 +806,8 @@ export class MatroskaContainer extends Container {
     const complete = new Set();
     let whole = true;
     for (const track of requested) {
-      const chain = await this.#readTrackPackets(layout, tracks, track, start, interval);
+      const chain = await this.#readTrackPackets(layout, tracks, track, start, interval, isCurrent);
+      if (!chain) return null;
       streams.set(track.trackNumber, chain.records);
       if (chain.reachesEnd) complete.add(track.trackNumber);
       if (!chain.reachesEnd || chain.startAt !== layout.firstClusterAt) whole = false;
@@ -825,7 +831,7 @@ export class MatroskaContainer extends Container {
    *
    * @returns {Promise<{ records: PacketRecordsChain, startAt: number, reachesEnd: boolean }>}
    */
-  async #readTrackPackets(layout, tracks, track, start, interval) {
+  async #readTrackPackets(layout, tracks, track, start, interval, isCurrent) {
     const id = track.trackNumber;
     const previous = this.#packetWalks.get(id) ?? Promise.resolve();
     let finished;
@@ -882,7 +888,8 @@ export class MatroskaContainer extends Container {
         const following = readings.find(reading => reading.startAt > current.startAt);
         const outcome = await walkMatroskaPackets({ readRange: this.readRange, fileSize: this.fileSize,
           portionBytes: this.portionBytes, layout, tracks, trackIds: [id], interval, packetMemory: this.packetMemory,
-          state: current, until: following?.startAt ?? null, isCovered: covered, readsThrough });
+          state: current, until: following?.startAt ?? null, isCovered: covered, readsThrough, isCurrent });
+        if (outcome === "obsolete") return null;
         if (outcome !== "until") break;
         current.next = following;
       }

package/services/media/container/matroska-packets.js

@@ -44,9 +44,12 @@ function recordedTracks(tracks, trackIds) {
  * `start` on, where the caller knows it: those are read a portion at a time
  * across clusters too.
  *
- * @returns {Promise<"covered" | "until" | "end">}
+ * A walk whose `isCurrent` turns false stops at the next cluster, where its
+ * state is whole, and answers "obsolete".
+ *
+ * @returns {Promise<"covered" | "until" | "end" | "obsolete">}
  */
-export async function walkMatroskaPackets({ readRange, fileSize, portionBytes, layout, tracks, trackIds, interval, packetMemory, state, until = null, isCovered = null, readsThrough = null }) {
+export async function walkMatroskaPackets({ readRange, fileSize, portionBytes, layout, tracks, trackIds, interval, packetMemory, state, until = null, isCovered = null, readsThrough = null, isCurrent = null }) {
   // INSIDE A CLUSTER EVERY BLOCK HEADER IS READ, so its bytes are read a
   // portion at a time up to the cluster's end, and never past it. Read a
   // header at a time, each a read of a few bytes from the torrent thread, the
@@ -71,6 +74,7 @@ export async function walkMatroskaPackets({ readRange, fileSize, portionBytes, l
   if (covered()) return "covered";
   let at = state.at;
   while (at < limit) {
+    if (!state.cluster && isCurrent?.() === false) return "obsolete";
     const element = state.cluster?.element ?? await validHeader(reader, at, layout.segmentEnd);
     if (element.id !== CLUSTER) {
       if (element.end === null) throw new Error("An unknown-sized Matroska element is not a Cluster.");

package/services/storage/cpu-profile.js

@@ -1,17 +1,23 @@
 /**
- * @file A CPU profile of the main thread at a cold start, asked for by the
- * operator and never taken otherwise (torrent-tv/meta#177).
+ * @file CPU profiles of the main thread and of the torrent thread, asked for
+ * by the operator and never taken otherwise (torrent-tv/meta#177, #178).
  *
  * At a cold start on the addon host (#166 run 12) the picture's first input
  * waited 29.5 s, 20.2 s of it inside a budget revision, while the main thread
  * ran at 83-108 % of a core; what it was doing is not in any log. A profile of
  * that thread names it.
  *
+ * The torrent thread is profiled beside it. After a seek on Home Assistant
+ * (r60, #178) a soundtrack's input waited 23.3 s, every read of held bytes took
+ * 1.5-6 s in that thread, its loop ran up to 2.7 s late and it drew three
+ * quarters of a core; what it spent them on is in no log either.
+ *
  * In-process, through `node:inspector`: the sampling profiler runs beside the
  * thread and does not stop it — unlike the debugger that stopped every thread
- * of this process on 2026-09-05 (torrent-tv/meta#77). It begins at the first
- * source opened, which is where a cold start begins, runs for the seconds the
- * operator named, and writes `cpu-start-<time>.cpuprofile` beside the log,
+ * of this process on 2026-09-05 (torrent-tv/meta#77). Both begin at the first
+ * source opened, which is where a cold start begins, run for the seconds the
+ * operator named, and are written by this thread under the one storage budget
+ * as `cpu-start-<time>.cpuprofile` (main) and `cpu-torrent-<time>.cpuprofile`,
  * readable in Chrome's DevTools (Performance, "Load profile").
  */
 
@@ -19,50 +25,72 @@ import { Session } from "node:inspector/promises";
 import { writeFile } from "node:fs/promises";
 import path from "node:path";
 
+/**
+ * Profile the thread this runs on for `seconds`.
+ *
+ * @param {number} seconds
+ * @returns {Promise<object>} The profile, as `Profiler.stop` gives it.
+ */
+export async function profileThisThread(seconds) {
+  const session = new Session();
+  session.connect();
+  try {
+    await session.post("Profiler.enable");
+    await session.post("Profiler.start");
+    await new Promise((resolve) => {
+      const timer = setTimeout(resolve, seconds * 1000);
+      if (typeof timer.unref === "function") timer.unref();
+    });
+    const { profile } = await session.post("Profiler.stop");
+    return profile;
+  } finally {
+    session.disconnect();
+  }
+}
+
 /**
  * @param {object} params
  * @param {number} params.seconds - How long to profile; nothing happens unless positive.
  * @param {string} params.dir - Where to write the profile.
  * @param {(line: string) => void} params.log
  * @param {(bytes: number) => boolean} [params.mayKeep] - Whether the storage budget lets it be kept.
+ * @param {(seconds: number) => Promise<string | null>} [params.torrentThread] - The torrent thread's
+ *   profile over the same seconds, as JSON text, or null when it could not be taken.
  * @returns {{ begin: () => void, active: () => boolean }}
  */
-export function startupCpuProfile({ seconds, dir, log, mayKeep = () => true }) {
+export function startupCpuProfile({ seconds, dir, log, mayKeep = () => true, torrentThread = null }) {
   let begun = false;
-  let running = false;
+  let running = 0;
   const wanted = Number.isFinite(seconds) && seconds > 0 && typeof dir === "string" && dir.length > 0;
-  const take = async () => {
-    const session = new Session();
-    session.connect();
+  const keep = async (name, text) => {
+    const bytes = Buffer.byteLength(text);
+    if (!mayKeep(bytes)) {
+      log(`cpu profile: ${name} not kept, ${bytes} bytes refused by the storage budget`);
+      return;
+    }
+    const file = path.join(dir, `cpu-${name}-${new Date().toISOString().replace(/[:.]/g, "-")}.cpuprofile`);
+    await writeFile(file, text);
+    log(`cpu profile: written to ${file} (${bytes} bytes)`);
+  };
+  const take = async (name, profile) => {
+    running += 1;
     try {
-      await session.post("Profiler.enable");
-      await session.post("Profiler.start");
-      running = true;
-      log(`cpu profile: the main thread is profiled for ${seconds}s from the first source opened`);
-      await new Promise((resolve) => {
-        const timer = setTimeout(resolve, seconds * 1000);
-        if (typeof timer.unref === "function") timer.unref();
-      });
-      const { profile } = await session.post("Profiler.stop");
-      const text = JSON.stringify(profile);
-      if (!mayKeep(Buffer.byteLength(text))) {
-        log(`cpu profile: not kept, ${Buffer.byteLength(text)} bytes refused by the storage budget`);
-        return;
-      }
-      const file = path.join(dir, `cpu-start-${new Date().toISOString().replace(/[:.]/g, "-")}.cpuprofile`);
-      await writeFile(file, text);
-      log(`cpu profile: written to ${file} (${Buffer.byteLength(text)} bytes)`);
+      const text = await profile();
+      if (text) await keep(name, text);
+    } catch (error) {
+      log(`cpu profile: ${name} failed — ${error.message}`);
     } finally {
-      running = false;
-      session.disconnect();
+      running -= 1;
     }
   };
   return {
     begin() {
       if (!wanted || begun) return;
       begun = true;
-      void take().catch((error) => log(`cpu profile: failed — ${error.message}`));
+      log(`cpu profile: the main thread${torrentThread ? " and the torrent thread are" : " is"} profiled for ${seconds}s from the first source opened`);
+      void take("start", async () => JSON.stringify(await profileThisThread(seconds)));
+      if (torrentThread) void take("torrent", () => torrentThread(seconds));
     },
-    active: () => running
+    active: () => running > 0
   };
 }

package/services/torrent/worker/client.js

@@ -744,6 +744,17 @@ export class TorrentWorkerClient {
     return this.wholeFileBytes ?? 0;
   }
 
+  /**
+   * A processor profile of the torrent thread over `seconds`, as JSON text.
+   *
+   * @param {number} seconds
+   * @returns {Promise<string | null>}
+   */
+  async cpuProfile(seconds) {
+    const text = await this.#caller.call(Command.CPU_PROFILE, { seconds });
+    return typeof text === "string" ? text : null;
+  }
+
   /**
    * Say how much disk the spilled pieces on this thread may take between them.
    *

package/services/torrent/worker/pool-adapter.js

@@ -278,6 +278,11 @@ export class WorkerTorrentPool {
    *
    * @returns {Promise<{ infoHash: string, progress: number, bytes: number }[]>}
    */
+  /** A processor profile of the torrent thread, as JSON text (`TorrentWorkerClient.cpuProfile`). */
+  async cpuProfile(seconds) {
+    return this.#client.cpuProfile(seconds);
+  }
+
   async heldTorrents() {
     const answer = await this.#client.heldTorrents();
     return Array.isArray(answer?.held) ? answer.held : [];

package/services/torrent/worker/protocol.js

@@ -107,6 +107,8 @@ export const Command = {
   SPILL_ALLOWANCE: "spill-allowance",
   WHOLE_FILES_ALLOWANCE: "whole-files-allowance",
   MEMORY_ALLOWANCE: "memory-allowance",
+  /** Profile this thread's processor for some seconds and answer with the profile as JSON text (opt-in, torrent-tv/meta#178). */
+  CPU_PROFILE: "cpu-profile",
   DESTROY_ALL: "destroy-all"
 };
 

package/services/torrent/worker/worker.js

@@ -39,6 +39,7 @@ import { wholeFileStats } from "./whole-file-stats.js";
 import { describeHeldObjects, readUtpOpenCount } from "./held-objects.js";
 import { destroyedTorrents } from "../destroyed-torrents.js";
 import { startMemoryReport, WORKER_MEMORY_SAMPLE_MS } from "../../storage/memory-report.js";
+import { profileThisThread } from "../../storage/cpu-profile.js";
 import { forwardLogsTo, logger } from "../../../utils/logger.js";
 
 /**
@@ -603,6 +604,12 @@ async function runCommand(command, params, id) {
       return after.bytes;
     }
 
+    case Command.CPU_PROFILE: {
+      // The operator's profile of this thread, written by the main thread under
+      // the storage budget there (`storage/cpu-profile.js`).
+      return JSON.stringify(await profileThisThread(Number(params.seconds)));
+    }
+
     case Command.DESTROY_ALL: {
       torrentsByKey.clear();
       resolvedTorrents.clear();