@torrent-tv/proxy 2.97.17 → 2.97.19

package/package.json

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

package/server.js

@@ -556,6 +556,9 @@ export async function startProxyServer({
         const known = segmentSourceRanges.get(rangesKey);
         if (known) { convert(known); continue; }
         if (waiting.has(zone.outputKey)) continue;
+        // What is resolved so far is stated before a lower zone is worked out
+        // (DownloadMaps, torrent-tv/meta#178).
+        map.workingOut?.(zone.priority, converted);
         if (direct) {
           // Asked per zone too: a soundtrack of an AVI is read from its own
           // packets, which the same index states (torrent-tv/meta#166).

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/services/media/container/AviContainer.js

@@ -43,6 +43,8 @@ export class AviContainer extends Container {
   /** The index alone: undefined until read, null when the file states none. */
   #index = undefined;
   #layout = null;
+  /** The first RIFF's `idx1`: undefined until looked for, null when there is none. */
+  #idx1Chunk = undefined;
 
   async #readHeaders() {
     if (this.#headers) return this.#headers;
@@ -124,17 +126,40 @@ export class AviContainer extends Container {
   }
 
 
-  /** The first RIFF's `movi` list and `idx1` chunk. */
+  /**
+   * The first RIFF's `movi` list, found without reading past it: the chunk
+   * after `movi` lies where the first RIFF ends, which on a cold start is a
+   * piece of its own off the swarm.
+   */
   async #topLevel() {
     if (this.#layout) return this.#layout;
     const header = await this.readRange(0, 11);
-    const chunks = await riffChunks(this.readRange, 12, 8 + header.readUInt32LE(4));
-    const movi = chunks.find(chunk => chunk.id === "LIST" && chunk.type === "movi");
+    const end = 8 + header.readUInt32LE(4);
+    const before = await riffChunks(this.readRange, 12, end, "movi");
+    const movi = before.find(chunk => chunk.id === "LIST" && chunk.type === "movi");
     if (!movi) throw new Error("AVI media list is absent.");
-    this.#layout = { movi, idx1: chunks.find(chunk => chunk.id === "idx1") ?? null };
+    this.#layout = { movi, end, before };
     return this.#layout;
   }
 
+  /**
+   * The first RIFF's `idx1` chunk, which follows `movi`. Read only for a file
+   * with no OpenDML index, as FFmpeg reads it: a loaded OpenDML index marks
+   * the index loaded and `avi_load_index` is not called (avidec.c n6.1 and
+   * n8.1, `read_odml_index`). Looked for on every file, it cost a cold
+   * two-hour OpenDML AVI a round trip to the swarm: its index's own piece was
+   * asked for 4.4 s later than it could have been (Home Assistant 2026-10-12,
+   * torrent-tv/meta#178).
+   */
+  async #idx1() {
+    if (this.#idx1Chunk !== undefined) return this.#idx1Chunk;
+    const { movi, end, before } = await this.#topLevel();
+    const after = movi.end + ((movi.end - movi.start) & 1);
+    const chunks = [...before, ...(after < end ? await riffChunks(this.readRange, after, end) : [])];
+    this.#idx1Chunk = chunks.find(chunk => chunk.id === "idx1") ?? null;
+    return this.#idx1Chunk;
+  }
+
   /**
    * What the index states, read once; null when the file states no index.
    * A shortage of bytes or memory is thrown and nothing is kept, so the next
@@ -144,7 +169,8 @@ export class AviContainer extends Container {
     if (this.#index !== undefined) return this.#index;
     const tracks = await this.readTracks();
     const { streams } = await this.#readHeaders();
-    const { movi, idx1 } = await this.#topLevel();
+    const { movi } = await this.#topLevel();
+    const idx1 = streams.some(stream => stream.indexChunks.length) ? null : await this.#idx1();
     const record = { dispose: () => this.#index?.dispose?.() };
     const allocation = this.packetMemory?.forRecord?.(record, "index") ?? this.packetMemory;
     const index = await readAviIndex({ read: this.readRange, fileSize: this.fileSize, movi, idx1, allocation,

package/services/viewer/DownloadMaps.js

@@ -74,8 +74,28 @@ export class DownloadMaps {
     }
     if (changed) await this.#emit(file);
     if (revision !== file.revision) return;
+    const isCurrent = () => this.#files.get(`${sourceKey}:${fileIndex}`) === file && revision === file.revision;
+    // WHAT IS RESOLVED IS STATED WHILE THE REST IS STILL BEING RESOLVED. A pass
+    // works the zones out in the order the swarm is to fetch them, and
+    // published only at its end it kept the first bytes from the swarm for as
+    // long as the far end of the film took: 14.6 s on a cold two-hour AVI, the
+    // swarm fetching nothing for 17.5 s while the encoder waited for its next
+    // piece (Home Assistant 2026-10-12, torrent-tv/meta#178). The swarm
+    // fetches the highest group still missing, so before the pass works out a
+    // zone of a lower priority than any before it, what it has resolved is
+    // published, with the zones still retained for what it has not reached. A
+    // pass that works nothing out — every pass over a film already worked out
+    // — states nothing early.
+    let stated = Number.POSITIVE_INFINITY;
+    const workingOut = (priority, zones) => {
+      if (!(priority < stated)) return;
+      stated = priority;
+      if (zones.length === 0 || !isCurrent()) return;
+      this.#setZones(file, withRetained(zones, retained));
+      this.#emit(file).catch(() => undefined);
+    };
     const resolved = await this.#resolvePlayback({ sourceKey, fileIndex, durationSeconds, zones: file.sourceZones,
-      isCurrent: () => this.#files.get(`${sourceKey}:${fileIndex}`) === file && revision === file.revision });
+      isCurrent, workingOut });
     if (revision !== file.revision) return;
     this.#setZones(file, resolved);
     return this.#emit(file);
@@ -333,6 +353,19 @@ export class DownloadMaps {
   }
 }
 
+/**
+ * Zones resolved so far, with the retained zones of every segment they do not
+ * yet resolve again: a segment's bytes are stated once, by its newest reading.
+ */
+function withRetained(resolved, retained) {
+  const keyOf = zone => typeof zone.outputKey === "string" && Number.isSafeInteger(zone.index) ? `${zone.outputKey}:${zone.index}` : null;
+  const resolvedKeys = new Set(resolved.map(keyOf).filter(key => key !== null));
+  return [...resolved, ...retained.filter(zone => {
+    const key = keyOf(zone);
+    return key === null || !resolvedKeys.has(key);
+  })];
+}
+
 /** @param {number} since */
 function emptyStats(since) {
   return { since, sent: 0, unchanged: 0, zones: [], deliveredMs: [], appliedMs: [],