@torrent-tv/proxy 2.97.19 → 2.97.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.97.19",
+  "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/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;
+  };
+}