@torrent-tv/proxy 2.95.23 → 2.95.25

package/package.json

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

package/services/encode/EncodePlan.js

@@ -794,13 +794,24 @@ function latenessOf(encoders, coverage, wanted, untilNeeded, rate, refetchSecPer
   const lateAt = new Map(ranks.map((rank) => [rank, 0]));
   /** When the last number of a rank is made, per rank. @type {Map<number, number>} */
   const doneAt = new Map(ranks.map((rank) => [rank, 0]));
+  // How many numbers each encoder has already passed over that are made, kept
+  // as the walk goes rather than counted again for every number: counted again,
+  // a film of two thousand pieces cost the plan four million steps, and the
+  // plan held the proxy's thread for most of every second (Home Assistant
+  // 2026-10-08, torrent-tv/meta#151). The same count `madeBetween` gives.
+  const passed = encoders.map((encoder) => coverage.madeBetween(encoder.at, first - 1));
   for (let index = first; index <= last; index += 1) {
+    const readyHere = coverage.isReady(index);
+    for (let at = 0; at < encoders.length; at += 1) {
+      if (readyHere && encoders[at].at <= index) passed[at] += 1;
+    }
     // Which encoder gets to this piece first, and when. One standing on it is
     // already there; one behind it must work its way up, re-making anything
     // already made on the way, which costs its own time and the swarm's.
     let soonest = Number.POSITIVE_INFINITY;
     let byWhom = null;
-    for (const encoder of encoders) {
+    for (let at = 0; at < encoders.length; at += 1) {
+      const encoder = encoders[at];
       if (encoder.at > index) {
         continue;
       }
@@ -820,13 +831,13 @@ function latenessOf(encoders, coverage, wanted, untilNeeded, rate, refetchSecPer
       // stood still for 116.7 s.
       const arrival = encoder.delaySec
         + (index - encoder.at) / rate
-        + coverage.madeBetween(encoder.at, index) * refetchSecPerSegment;
+        + passed[at] * refetchSecPerSegment;
       if (arrival < soonest) {
         soonest = arrival;
         byWhom = encoder;
       }
     }
-    if (coverage.isReady(index)) {
+    if (readyHere) {
       // It exists. Nobody waits for it and nothing is owed — but whoever passes
       // over it makes it a second time, and the swarm fetches its bytes again.
       if (byWhom !== null) {
@@ -1103,8 +1114,19 @@ function gapFinderFor(coverage, surviving, rate, refetchSecPerSegment = 0) {
     // the map happens to be in.
     let best = null;
     let bestDue = Number.POSITIVE_INFINITY;
+    // Where every encoder already placed stands, and how many made numbers lie
+    // between it and the number the walk is on — kept as the walk goes, because
+    // counted again for every number a two-hour film made this one walk
+    // millions of steps, and the plan held the proxy's thread for most of every
+    // second (Home Assistant 2026-10-08, torrent-tv/meta#151).
+    const standing = [...placed.map((live) => live.at), ...(alsoPlaced ?? [])];
+    const passed = standing.map((a) => coverage.madeBetween(a, start - 1));
     for (let index = start; index <= last; index += 1) {
-      if (coverage.isReady(index)) {
+      const readyHere = coverage.isReady(index);
+      for (let which = 0; which < standing.length; which += 1) {
+        if (readyHere && standing[which] <= index) passed[which] += 1;
+      }
+      if (readyHere) {
         continue;
       }
       const deadline = deadlineAt(index);
@@ -1121,7 +1143,8 @@ function gapFinderFor(coverage, surviving, rate, refetchSecPerSegment = 0) {
       // second and a third on the very next numbers — three processes a segment
       // apart for one person, which is the waste this model exists to refuse.
       let soonest = Number.POSITIVE_INFINITY;
-      for (const a of [...placed.map((live) => live.at), ...(alsoPlaced ?? [])]) {
+      for (let which = 0; which < standing.length; which += 1) {
+        const a = standing[which];
         if (a > index) {
           // Standing past it. Encoders only move forward, so it never will.
           continue;
@@ -1141,7 +1164,7 @@ function gapFinderFor(coverage, surviving, rate, refetchSecPerSegment = 0) {
         // to arrive, and the model compares arrivals. Asked separately it was a
         // second authority over the same encoder, and the two disagreed.
         const arrival = (index - a + 1) / rate
-          + coverage.madeBetween(a, index) * refetchSecPerSegment;
+          + passed[which] * refetchSecPerSegment;
         if (arrival < soonest) {
           soonest = arrival;
         }

package/services/encode/EncodeRuns.js

@@ -1009,7 +1009,16 @@ export class EncodeRuns {
       onSpeedMeasured: () => this.#host.noteRunSpeedMeasured?.(session, run),
       onEnded: (ended) => {
         this.#runsByInputToken.delete(inputToken);
-        if (admittedInput.original) admittedInput.release();
+        if (admittedInput.original) {
+          const reads = admittedInput.reads?.();
+          if (reads) {
+            const since = (at) => at ? `${at - run.startedAt}ms` : "never";
+            this.#host.logger.info(`encode input of run #${run.from}..#${run.to} on ${session.outputKey}: ` +
+              `${reads.count} read(s), ${reads.bytes} bytes, first at ${since(reads.firstAt)}, last at ${since(reads.lastAt)}, ` +
+              `ended at ${Date.now() - run.startedAt}ms`);
+          }
+          admittedInput.release();
+        }
         this.noteRunEnded(session, run, ended);
       }
     });

package/services/encode/OriginalInput.js

@@ -27,6 +27,10 @@ export async function admitOriginalInput({ sources, reserve, readRanges }) {
     }
     let released = false;
     retained = true;
+    // What FFmpeg asked of this input, for the run's own account of where its
+    // time went: field 2026-10-08, a run took 6-9 s for a piece FFmpeg makes in
+    // 1.6 s from a file, and nothing said whether it was waiting on its input.
+    const reads = { count: 0, bytes: 0, firstAt: 0, lastAt: 0 };
     return {
       kind: "result", original: true, sources, bytes, fingerprint: hash.digest("hex"),
       tracks: sources.flatMap(source => (source.input.selections ?? []).map(selection => ({ track: selection.track,
@@ -43,9 +47,15 @@ export async function admitOriginalInput({ sources, reserve, readRanges }) {
         const position = ranges.findIndex(([from, to]) => from <= start && (partial ? start : stop) <= to);
         if (position < 0) return null;
         stop = Math.min(stop, ranges[position][1]);
+        const now = Date.now();
+        reads.count += 1;
+        reads.bytes += stop - start + 1;
+        reads.firstAt ||= now;
+        reads.lastAt = now;
         return { length: fileLength, end: stop, bytes: entry.buffers[position].subarray(start - ranges[position][0], stop - ranges[position][0] + 1) };
       },
       lengthOf: fileIndex => held.get(fileIndex)?.source.input.fileLength ?? null,
+      reads: () => ({ ...reads }),
       release() {
         if (released) return;
         released = true;