@torrent-tv/proxy 2.97.18 → 2.97.20

package/package.json

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

package/server.js

@@ -79,6 +79,7 @@ import { readHostFingerprint } from "./services/encode/fingerprint.js";
 import { measureStartAndStop } from "./services/encode/start-stop-cost.js";
 import { benchmarkAudio } from "./services/encode/audio-calibration.js";
 import { logger } from "./utils/logger.js";
+import { takeTurns } from "./utils/take-turns.js";
 import { completedFilesRoot } from "./services/storage/files/CompletedFiles.js";
 import { startupCpuProfile } from "./services/storage/cpu-profile.js";
 import { startProcessorReport } from "./services/storage/processor-report.js";
@@ -532,6 +533,7 @@ export async function startProxyServer({
       // answers; asking every segment held the main thread for 3.3 s on a cold
       // two-hour AVI (torrent-tv/meta#178).
       const waiting = new Set();
+      const turn = takeTurns();
       for (const zone of demands) {
         if (!map.isCurrent()) return [];
         // WHAT A SEGMENT READS IS WORKED OUT ONCE, not on every publication: its
@@ -571,14 +573,14 @@ export async function startProxyServer({
               value = new SegmentInputs({ index, tracks: wanted }).forInterval({ ...interval, mode: track => modes.get(track) });
             }
           } catch { value = null; }
-          // A zone worked out gives the thread back before the next: worked out
-          // in one stretch, the first pass over a film's 4000 zones held the main
-          // thread 5-7 s while FFmpeg's first open waited for its answers. What
-          // was worked out is kept, so a pass a newer map ends is not lost
+          // The pass shares the thread in equal turns (`takeTurns`): in one
+          // stretch the first pass over a film's 4000 zones held the main thread
+          // for all of its work, and handed back after every zone it took
+          // 14.7-22 s while the start forecast waited for it. What was worked
+          // out is kept, so a pass a newer map ends is not lost
           // (torrent-tv/meta#178).
           if (value?.kind === "result") segmentSourceRanges.set(rangesKey, value.ranges);
-          await new Promise(resolve => setImmediate(resolve));
-          if (!map.isCurrent()) return [];
+          if (await turn() && !map.isCurrent()) return [];
           if (value?.kind === "result") {
             convert(value.ranges);
             continue;

package/services/encode/AdmittedInput.js

@@ -99,8 +99,17 @@ export async function admitInput({ sources, reserve, readRanges }) {
   }
 }
 
-/** Respect stdin backpressure and release input on every completion path. */
-export async function writeAdmittedInput(input, stdin, { next = null } = {}) {
+/**
+ * Respect stdin backpressure and release input on every completion path.
+ *
+ * `waiting(true)` and `waiting(false)` bracket each wait for the next input:
+ * the encoder has nothing to read then, and that time is not its work. Counted
+ * as work, a soundtrack copy fed a segment at a time read 0.43x while ffmpeg
+ * used 0.014 s of processor per second of film, and the start forecast charged
+ * the download a second time through it (Home Assistant 2026-10-12,
+ * torrent-tv/meta#178).
+ */
+export async function writeAdmittedInput(input, stdin, { next = null, waiting = null } = {}) {
   if (input?.kind !== "result") throw new TypeError("Only complete input may be written to an encoder.");
   const originSeconds = input.originSeconds;
   const declarations = JSON.stringify(input.tracks.map(input => matroskaTrackIdentity(input.track)));
@@ -137,7 +146,14 @@ export async function writeAdmittedInput(input, stdin, { next = null } = {}) {
       }
       await flush();
       current.release();
-      current = next ? await next() : null;
+      if (next) {
+        waiting?.(true);
+        try {
+          current = await next();
+        } finally {
+          waiting?.(false);
+        }
+      } else current = null;
       includeHeader = false;
     }
     stdin.end();

package/services/encode/EncodeRuns.js

@@ -1206,7 +1206,7 @@ export class EncodeRuns {
         run.admittedInputKeys.set(nextIndex, this.#inputFailures.key(next, inputParameters));
         run.to = nextIndex++;
         return next;
-      } }).catch(error => {
+      }, waiting: waits => { if (waits) run.inputWaitBegins(); else run.inputWaitEnds(); } }).catch(error => {
         this.#host.logger.warn(`encode input output=${session.outputKey} segment=${safeIndex} write failed: ${error.message}`);
         run.process?.stdin?.destroy();
       });

package/utils/take-turns.js

@@ -0,0 +1,28 @@
+/**
+ * Long work on one thread, shared with the rest of that thread in equal turns.
+ *
+ * The returned function is called between steps of the work. It hands the
+ * thread back once the work has run, since it last did, as long as the rest
+ * of the thread took in its own turn then: the work takes at most about twice
+ * its own time, and nothing else waits longer than it took itself. Handed back
+ * after every step, the download map's first pass over a two-hour AVI took
+ * 14.7-22 s of wall time for about 4 s of its own work, and the start forecast,
+ * which needs the whole pass, could not answer meanwhile; held in one stretch
+ * it held the thread for that work (Home Assistant 2026-10-12,
+ * torrent-tv/meta#178).
+ *
+ * @param {{ now?: () => number, nextTurn?: () => Promise<void> }} [options]
+ * @returns {() => Promise<boolean>} Resolves true when the thread was handed back.
+ */
+export function takeTurns({ now = () => performance.now(), nextTurn = () => new Promise(resolve => setImmediate(resolve)) } = {}) {
+  let workingSince = now();
+  let othersTook = 0;
+  return async () => {
+    if (now() - workingSince < othersTook) return false;
+    const handedBackAt = now();
+    await nextTurn();
+    workingSince = now();
+    othersTook = workingSince - handedBackAt;
+    return true;
+  };
+}