@torrent-tv/proxy 2.98.5 → 2.98.7

package/package.json

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

package/server.js

@@ -200,7 +200,7 @@ export async function startProxyServer({
     // The ONE forward reference here, and it is safe by construction: this fires
     // only once the worker thread is up and a piece has verified, which is long
     // after the declarations below have run.
-    onPiecesArrived: ({ sourceKey, fileIndexes }) => {
+    onPiecesArrived: ({ sourceKey, fileIndexes, arrived }) => {
       for (const fileIndex of fileIndexes) {
         mediaReads.bytesChanged(sourceKey, fileIndex);
         probeReads.bytesChanged(sourceKey, fileIndex);
@@ -211,7 +211,9 @@ export async function startProxyServer({
         // is read again now; nothing was recorded for that wait.
         keyframeTables.readAgainIfUnanswered({ sourceKey, fileIndex, logName: String(fileIndex) });
       }
-      outputParts.encodeInputs?.bytesChanged();
+      // Which bytes arrived, when the event names them: an input waiting for
+      // named bytes is tried again only when some of them have come.
+      outputParts.encodeInputs?.bytesChanged(Array.isArray(arrived) ? { sourceKey, ranges: arrived } : null);
     }
   });
   const selectedPort = await getPort({

package/services/encode/EncodeInputs.js

@@ -259,10 +259,35 @@ export class EncodeInputs {
     return this.take(output, from, to);
   }
 
-  bytesChanged() {
+  /**
+   * Bytes of a source changed: every waiting input is tried again, except one
+   * that waits for named bytes none of which have come. Tried at every piece
+   * of the file, a seek's input was prepared 28 times in 8.5 s on Home
+   * Assistant, each time asking the torrent thread which ranges it holds
+   * (171 ms on average), and the try that found its bytes could start only
+   * after the one in flight (r34, torrent-tv/meta#178).
+   *
+   * @param {{ sourceKey: string, ranges: Array<{ fileIndex: number, start: number, end: number }> } | null} [arrived] -
+   *   The bytes that arrived, inclusive, when the event names them.
+   */
+  bytesChanged(arrived = null) {
     this.#revision++;
     for (const request of this.#requests.values()) {
-      if (!request.pending && request.result?.kind !== "result" && request.result?.kind !== "terminal") this.#prepare(request);
+      if (request.pending) {
+        // The try in flight may have read before these bytes came. What it
+        // waits for is known only when it answers, so they are kept for that
+        // answer; bytes not named make it try again whatever it answers.
+        if (!arrived) request.unnamedArrival = true;
+        else (request.arrivedMeanwhile ??= []).push(arrived);
+        continue;
+      }
+      if (request.result?.kind === "result" || request.result?.kind === "terminal") continue;
+      if (arrived && request.result?.kind === "needs-bytes" && !awaitedIn(request.result, arrived)) {
+        // Nothing it waits for has come: it stands as tried at this revision.
+        request.revision = this.#revision;
+        continue;
+      }
+      this.#prepare(request);
     }
   }
 
@@ -324,6 +349,8 @@ export class EncodeInputs {
     request.pending = true;
     request.revision = this.#revision;
     request.memoryRevision = this.#memoryRevision;
+    request.arrivedMeanwhile = null;
+    request.unnamedArrival = false;
     // Where the time from the request to its input goes, across every attempt:
     // field 2026-10-10, a picture's request took 38 s before its copy began and
     // nothing said on what (torrent-tv/meta#166).
@@ -365,12 +392,29 @@ export class EncodeInputs {
       request.pending = false;
       if (request.result?.kind !== "needs-memory") this.#wanted.delete(request.key);
       const changed = request.result?.kind === "needs-memory"
-        ? request.memoryRevision !== this.#memoryRevision : request.revision !== this.#revision;
+        ? request.memoryRevision !== this.#memoryRevision : this.#arrivedFor(request);
       if (this.#requests.get(request.key) === request && changed &&
         request.result?.kind !== "result" && request.result?.kind !== "terminal") this.#prepare(request);
     });
   }
 
+  /**
+   * Whether bytes came during a try that the try may have missed. A try that
+   * waits for named bytes is repeated only when some of them came, or when an
+   * event named nothing; the others stand it as tried at this revision. In r36
+   * a held-range check took 344 ms, and a piece of the file arriving during it
+   * started another (torrent-tv/meta#178).
+   */
+  #arrivedFor(request) {
+    if (request.revision === this.#revision) return false;
+    const arrivals = request.arrivedMeanwhile ?? [];
+    request.arrivedMeanwhile = null;
+    if (request.unnamedArrival || request.result?.kind !== "needs-bytes" ||
+      arrivals.some(arrived => awaitedIn(request.result, arrived))) return true;
+    request.revision = this.#revision;
+    return false;
+  }
+
   /** The reservation a packet input makes: all of it, or nothing. */
   #reserveFor(request) {
     return async bytes => {
@@ -486,7 +530,9 @@ export class EncodeInputs {
       // found pieces missing, and the run was refused for good (torrent-tv/meta#178).
       if (this.#heldRanges !== null && !await this.#present(chosen.sources, held, request.timing)) {
         const [first] = chosen.sources;
-        return { kind: "needs-bytes", sourceKey: first.sourceKey, fileIndex: first.fileIndex, ranges: first.input.ranges };
+        return { kind: "needs-bytes", sourceKey: first.sourceKey, fileIndex: first.fileIndex, ranges: first.input.ranges,
+          // Every source of the stretch, so the bytes of any of them wake it.
+          awaiting: chosen.sources.map(source => ({ sourceKey: source.sourceKey, fileIndex: source.fileIndex, ranges: source.input.ranges })) };
       }
       if (this.#requests.get(request.key) !== request) return undefined;
       this.#wanted.set(request.key, { wanted: chosen.bytes, required: chosen.bytes });
@@ -527,6 +573,21 @@ export class EncodeInputs {
   }
 }
 
+/**
+ * Whether some of the bytes an input waits for are among those that arrived.
+ *
+ * @param {{ sourceKey: string, fileIndex: number, ranges: Array<[number, number]>,
+ *   awaiting?: Array<{ sourceKey: string, fileIndex: number, ranges: Array<[number, number]> }> }} waiting
+ * @param {{ sourceKey: string, ranges: Array<{ fileIndex: number, start: number, end: number }> }} arrived
+ * @returns {boolean}
+ */
+function awaitedIn(waiting, arrived) {
+  const sources = waiting.awaiting ?? [waiting];
+  return sources.some(source => source.sourceKey === arrived.sourceKey && Array.isArray(source.ranges) &&
+    arrived.ranges.some(range => range.fileIndex === source.fileIndex &&
+      source.ranges.some(([start, end]) => range.start <= end && range.end >= start)));
+}
+
 /**
  * Where a request has spent its time since it was asked, as one clause of its
  * log line. The resolutions include the reads of the file they made, and those

package/services/torrent/torrent-pool.js

@@ -1300,6 +1300,7 @@ export class TorrentPool {
     // depend on facts that are gone by the time it is said.
     if (Array.isArray(zones) && zones.length === 0) {
       withdrawPriorityMap(torrent, fileIndex);
+      reconcileAll();
       // The ends of the file go with it. They are kept for as long as the file
       // is open, and this is what says it is not.
       // And this may have been the last thing anybody wanted of this torrent.
@@ -1346,6 +1347,11 @@ export class TorrentPool {
     // Bands the map no longer has: a viewer moved on, and what they had wanted
     // is not wanted by anybody now.
     withdrawPriorityMap(torrent, fileIndex, ordered.length);
+    // THE SWARM IS TOLD WHEN THE MAP IS APPLIED, not at the next piece verified
+    // or the pool's timer: on Home Assistant a seek's map was applied and the
+    // swarm went on fetching the old first class for 1.16 s, until the next
+    // piece happened to be verified (r34, torrent-tv/meta#178).
+    reconcileAll();
     // WHAT THE SWARM WAS ACTUALLY TOLD, said on change and never on a timer.
     // The map was applied in silence: that it had been BUILT was visible in the
     // encoding's own line, and that the download had received it was visible

package/services/torrent/worker/client.js

@@ -254,7 +254,8 @@ export class TorrentWorkerClient {
           this.#onPiecesArrived({
             sourceKey: message.sourceKey,
               fileIndexes: Array.isArray(message.fileIndexes) ? message.fileIndexes : [],
-              ...(typeof message.reason === "string" ? { reason: message.reason } : {})
+              ...(typeof message.reason === "string" ? { reason: message.reason } : {}),
+              ...(Array.isArray(message.arrived) ? { arrived: message.arrived } : {})
           });
           break;
         default:

package/services/torrent/worker/worker.js

@@ -881,12 +881,36 @@ function describePieceBuffers() {
  * @param {object} torrent
  * @returns {void}
  */
-function announceArrivals(sourceKey, torrent, reason = "verified") {
+function announceArrivals(sourceKey, torrent, reason = "verified", piece = null) {
   const fileIndexes = [...demandFor(torrent).register.files()];
   if (fileIndexes.length === 0) {
     return;
   }
-  parentPort.postMessage({ type: Event.PIECES_CHANGED, sourceKey, fileIndexes, reason });
+  parentPort.postMessage({ type: Event.PIECES_CHANGED, sourceKey, fileIndexes, reason,
+    ...(Number.isSafeInteger(piece) ? { arrived: bytesOfPiece(torrent, piece) } : {}) });
+}
+
+/**
+ * The bytes of one piece, as each file it covers counts them: what a reader
+ * waiting for named bytes compares against, so a piece of another part of the
+ * file wakes nobody (torrent-tv/meta#178).
+ *
+ * @param {object} torrent
+ * @param {number} piece
+ * @returns {Array<{ fileIndex: number, start: number, end: number }>} Inclusive.
+ */
+function bytesOfPiece(torrent, piece) {
+  const pieceLength = Number(torrent.pieceLength);
+  const length = Number(torrent.length);
+  if (!(pieceLength > 0) || !(length > 0)) return [];
+  const start = piece * pieceLength;
+  const end = Math.min(length, start + pieceLength) - 1;
+  const arrived = [];
+  (torrent.files ?? []).forEach((file, fileIndex) => {
+    const from = Math.max(start, file.offset), to = Math.min(end, file.offset + file.length - 1);
+    if (to >= from) arrived.push({ fileIndex, start: from - file.offset, end: to - file.offset });
+  });
+  return arrived;
 }
 
 
@@ -917,7 +941,7 @@ function ensureArrivalsWired(sourceKey, torrent) {
   }
   arrivalsWired.add(torrent);
   holdingsChanged();
-  torrent.on("verified", () => announceArrivals(sourceKey, torrent));
+  torrent.on("verified", (piece) => announceArrivals(sourceKey, torrent, "verified", piece));
   torrent.on("piece-withdrawn", () => announceArrivals(sourceKey, torrent, "withdrawn"));
   torrent.once("close", () => {
     if (resolvedTorrents.get(sourceKey) !== torrent) return;