@torrent-tv/proxy 2.92.4 → 2.92.6

package/package.json

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

package/services/media/container/MatroskaContainer.js

@@ -137,7 +137,7 @@ export class MatroskaContainer extends Container {
   /** @type {Array<import("../tracks/ContainerTrack.js").ContainerTrack> | null} */
   #tracks = null;
   #packets = null;
-  #packetState = {};
+  #packetStates = new Map();
 
   /**
    * The Cues reading: undefined until read, null when the file has none.
@@ -150,8 +150,8 @@ export class MatroskaContainer extends Container {
   }
 
   packetIndexBytes() {
-    return (this.#packets?.allocatedBytes() ?? 0) +
-      [...(this.#packetState.packets?.values() ?? [])].reduce((sum, records) => sum + records.allocatedBytes, 0);
+    return [...this.#packetStates.values()].reduce((sum, state) => sum +
+      [...(state.packets?.values() ?? [])].reduce((bytes, records) => bytes + records.allocatedBytes, 0), 0);
   }
 
   static detect(head) {
@@ -437,16 +437,50 @@ export class MatroskaContainer extends Container {
     if (!layout) throw new Error("Matroska Segment is absent.");
     const tracks = await this.readTracks();
     const info = await this.readMediaInfo();
+    const start = await this.#packetStart(layout, tracks, interval);
+    // Reuse a contiguous reading that has already reached this cue. A seek
+    // across an unindexed gap gets its own reading instead of walking the gap.
+    let state = [...this.#packetStates.values()]
+      .filter(one => one.startAt <= start && one.at >= start)
+      .sort((a, b) => b.startAt - a.startAt)[0];
+    if (!state) {
+      state = { startAt: start, at: start };
+      this.#packetStates.set(start, state);
+    }
     const index = await readMatroskaPackets({ readRange: this.readRange,
       fileSize: this.fileSize, portionBytes: this.portionBytes, layout, tracks,
-      durationSeconds: info.durationSeconds, interval, state: this.#packetState, packetMemory: this.packetMemory });
-    if (index.isComplete()) {
+      durationSeconds: info.durationSeconds, interval, state, packetMemory: this.packetMemory });
+    if (index.isComplete() && state.startAt === layout.firstClusterAt) {
       this.#packets = index;
-      this.#packetState = {};
     }
     return index;
   }
 
+  async #packetStart(layout, tracks, interval) {
+    const first = layout.firstClusterAt ?? layout.segmentEnd;
+    if (!Number.isFinite(interval?.from) || interval.from <= 0) return first;
+    const cues = await this.readCues();
+    const requested = tracks.filter(track => interval.trackIds ? interval.trackIds.includes(track.trackNumber)
+      : ["video", "audio"].includes(track.type));
+    // A subtitle can remain visible across arbitrarily many picture Clusters;
+    // picture cues alone cannot prove that an earlier subtitle has ended.
+    if (requested.every(track => track.type === "subtitle")) return first;
+    const cueTrack = requested.find(track => track.type === "video") ??
+      tracks.find(track => track.type === "video") ?? requested[0];
+    if (!cueTrack) return first;
+    const points = (cues?.points ?? []).flatMap(point => point.positions
+      .filter(position => position.track === cueTrack.trackNumber && position.clusterAt >= first && position.clusterAt < layout.segmentEnd)
+      .map(position => ({ at: position.clusterAt, seconds: point.ticks * layout.secondsPerTick })))
+      .sort((a, b) => a.seconds - b.seconds);
+    const preroll = Math.max(0, ...requested.map(track =>
+      Math.max(track.seekPrerollSeconds ?? 0, track.defaultDurationSeconds ?? 0)));
+    let preceding = -1;
+    for (let index = 0; index < points.length && points[index].seconds <= interval.from - preroll; index++) preceding = index;
+    // The preceding cue's Cluster also retains audio that overlaps this cut
+    // and decoder dependencies before the first presented packet.
+    return preceding < 0 ? first : points[Math.max(0, preceding - 1)].at;
+  }
+
   /**
    * The Cues table, read once, every CuePoint with every track it names.
    *

package/services/media/container/matroska-packets.js

@@ -15,7 +15,7 @@ export async function readMatroskaPackets({ readRange, fileSize, portionBytes, l
   const declared = new Map(tracks.filter(track => ["video", "audio", "subtitle"].includes(track.type)).map(track => [track.trackNumber, track]));
   if (!state.packets) {
     state.packets = new Map([...declared.keys()].map(id => [id, new PacketRecords(packetMemory)]));
-    state.at = layout.firstClusterAt ?? layout.segmentEnd;
+    state.at ??= layout.firstClusterAt ?? layout.segmentEnd;
   }
   const packets = state.packets;
   if (intervalCovered(declared, packets, interval)) return buildIndex(declared, packets, durationSeconds, false, interval, packetMemory);

package/services/storage/piece-store/piece-lru.js

@@ -289,15 +289,16 @@ export class PieceLru {
    *
    * @returns {{ readers: number, names: string[], unionPieces: number, widestPieces: number, capacity: number }}
    */
-  demand() {
+  demand({ memoryRequiredOnly = false } = {}) {
     // WHO THEY ARE, not only how many. A "reader" here is whoever declared a
     // range, and on 2026-09-08 the field said `5 reader(s) want 24 piece(s) of
     // 25` on a session with two encoders — because the priority map declares one
     // range per zone and four of its zones were arriving as four readers. The
     // count alone could not say that, and choosing between "narrow the windows"
     // and "raise the allowance" was guesswork until the names were printed.
-    const names = [...this.#protected.keys()].map(String).sort();
-    const ranges = [...this.#protected.values()]
+    const entries = [...this.#protected.entries()].filter(([, range]) => !memoryRequiredOnly || range.memoryRequired);
+    const names = entries.map(([name]) => String(name)).sort();
+    const ranges = entries.map(([, range]) => range)
       .map((range) => ({ from: range.from, to: range.to }))
       .sort((left, right) => left.from - right.from);
     let unionPieces = 0;
@@ -432,9 +433,11 @@ export class PieceLru {
    *   urgent. A caller that states none is treated as wanting these pieces
    *   least of everyone who did state one, so an unstated range can never
    *   displace a stated one.
+   * @param {boolean} [memoryRequired] - Read windows require room; download
+   *   preferences can yield under pressure.
    * @returns {void}
    */
-  protect(readerId, from, to, urgency, deadlineAt, priority = 1) {
+  protect(readerId, from, to, urgency, deadlineAt, priority = 1, memoryRequired = true) {
     if (!Number.isInteger(from) || !Number.isInteger(to) || to < from) {
       return;
     }
@@ -443,7 +446,8 @@ export class PieceLru {
       to,
       urgency: Number.isFinite(urgency) ? Number(urgency) : Number.MAX_SAFE_INTEGER,
       deadlineAt,
-      priority
+      priority,
+      memoryRequired
     });
   }
 

package/services/storage/piece-store/shared-piece-store.js

@@ -658,10 +658,13 @@ export class SharedPieceStore {
    * range to declare.
    */
   get wantedBytes() {
+    // Download preferences may use spare RAM, but cannot become a required
+    // floor or a retained reading window after the map has been withdrawn.
     const demand = this.#lru.demand();
+    const required = this.#lru.demand({ memoryRequiredOnly: true });
     const pinned = this.#lru.pinnedCount;
     if (demand.readers > 0) {
-      this.#widestSeenPieces = Math.max(this.#widestSeenPieces, demand.widestPieces);
+      this.#widestSeenPieces = Math.max(this.#widestSeenPieces, required.widestPieces);
       const pieces = Math.max(MIN_RESIDENT_PIECES, demand.unionPieces, demand.widestPieces, pinned);
       // Plus room to absorb what arrives while a write is finishing. Asking for
       // exactly what the readers want leaves no free place ever, so every
@@ -710,7 +713,7 @@ export class SharedPieceStore {
     // also pin pieces without a priority-map range, so those measured pins are
     // part of the same minimum. Exceeding the share is the lesser failure, and
     // the line below says when it happens.
-    const demand = this.#lru.demand();
+    const demand = this.#lru.demand({ memoryRequiredOnly: true });
     const activeDemandPieces = Math.max(
       MIN_RESIDENT_PIECES,
       demand.readers > 0 ? demand.unionPieces : 0,
@@ -1848,8 +1851,8 @@ export class SharedPieceStore {
    * @param {number} [urgency]
    * @returns {void}
    */
-  protectRange(readerId, from, to, urgency, deadlineAt, priority) {
-    this.#lru.protect(readerId, from, to, urgency, deadlineAt, priority);
+  protectRange(readerId, from, to, urgency, deadlineAt, priority, memoryRequired = true) {
+    this.#lru.protect(readerId, from, to, urgency, deadlineAt, priority, memoryRequired);
     // A READER DECLARES ITSELF IN A MOMENT; the allowance was re-derived once a
     // minute. Between the two a read met whatever the store had shrunk to while
     // nobody was reading, and a claim gives up after five seconds — twelve

package/services/torrent/download/DeadlineScheduler.js

@@ -25,8 +25,7 @@ function requestArrival(wire, request, now) {
   return requestArrivals.get(request);
 }
 
-export function peerRequestCapacity(torrent, wire) {
-  const speed = Math.max(0, Number(wire.downloadSpeed?.()) || 0);
+export function peerRequestCapacity(torrent, wire, speed = Math.max(0, Number(wire.downloadSpeed?.()) || 0)) {
   if (wire.type === "webSeed") {
     return Math.min(1 + Math.ceil(speed / torrent.pieceLength), torrent.maxWebConns);
   }
@@ -36,8 +35,7 @@ export function peerRequestCapacity(torrent, wire) {
   return capacity;
 }
 
-export function requestCompletionAt(wire, bytes, now) {
-  const speed = Number(wire.downloadSpeed?.());
+export function requestCompletionAt(wire, bytes, now, speed = Number(wire.downloadSpeed?.())) {
   if (!(speed > 0)) return Number.POSITIVE_INFINITY;
   const queued = (wire.requests ?? []).reduce((total, request) => total + request.length, 0);
   return now + (queued + bytes) / speed * 1000;
@@ -116,26 +114,45 @@ export function downloadCandidates(entries, findStore = pieceStoreOf) {
 /** Run against protocol peers or an isolated future-state copy. */
 export function dispatchDownloadCandidates(candidates, now) {
   let requested = 0, reassigned = 0;
-  const hasCapacity = torrent => (torrent.wires ?? []).some(wire =>
-    !wire.destroyed && (wire.requests?.length ?? 0) < peerRequestCapacity(torrent, wire));
-  const writable = new Set(candidates.map(candidate => candidate.torrent).filter(hasCapacity));
+  // Rates and advertised limits cannot change during this synchronous pass.
+  // Read each peer once, and only inspect torrents once regardless of map size.
+  const readings = new Map();
+  const readingOf = (torrent, wire) => {
+    let reading = readings.get(wire);
+    if (!reading) {
+      const speed = Math.max(0, Number(wire.downloadSpeed?.()) || 0);
+      readings.set(wire, reading = { speed, capacity: peerRequestCapacity(torrent, wire, speed) });
+    }
+    return reading;
+  };
+  const usable = wire => !wire.destroyed &&
+    (!wire.peerChoking || (wire.hasFast && wire.peerAllowedFastSet?.length > 0));
+  const available = (torrent, wire) => usable(wire) &&
+    (wire.requests?.length ?? 0) < readingOf(torrent, wire).capacity;
+  const completionAt = (torrent, wire, bytes) =>
+    requestCompletionAt(wire, bytes, now, readingOf(torrent, wire).speed);
+  const writable = new Map();
+  for (const torrent of new Set(candidates.map(candidate => candidate.torrent))) {
+    const peers = (torrent.wires ?? []).filter(wire => available(torrent, wire));
+    if (peers.length) writable.set(torrent, peers);
+  }
   for (const candidate of candidates) {
     if (!writable.size) break;
     const { torrent, piece, deadlineAt, requestId } = candidate;
     if (!writable.has(torrent)) continue;
-    const wires = (torrent.wires ?? []).filter(wire => peerCanServe(wire, piece) &&
-      (wire.requests?.length ?? 0) < peerRequestCapacity(torrent, wire));
+    const peers = writable.get(torrent);
+    const wires = peers.filter(wire => peerCanServe(wire, piece) && available(torrent, wire));
     while (wires.length) {
-      wires.sort((a, b) => requestCompletionAt(a, BLOCK_BYTES, now) - requestCompletionAt(b, BLOCK_BYTES, now) ||
+      wires.sort((a, b) => completionAt(torrent, a, BLOCK_BYTES) - completionAt(torrent, b, BLOCK_BYTES) ||
         (a.requests?.length ?? 0) - (b.requests?.length ?? 0));
       const wire = wires[0];
       const before = wire.requests?.length ?? 0;
       let accepted = torrent._request(wire, piece, false);
       if (!accepted && Number.isFinite(deadlineAt)) {
-        const fasterAt = requestCompletionAt(wire, BLOCK_BYTES, now);
+        const fasterAt = completionAt(torrent, wire, BLOCK_BYTES);
         for (const slower of torrent.wires ?? []) {
           if (slower === wire || typeof slower.cancel !== "function") continue;
-          const lateAt = requestCompletionAt(slower, 0, now);
+          const lateAt = completionAt(torrent, slower, 0);
           if (!Number.isFinite(lateAt) || !(lateAt > deadlineAt && fasterAt < lateAt)) continue;
           const request = slower.requests?.find(one => one.piece === piece);
           if (!request) continue;
@@ -159,9 +176,9 @@ export function dispatchDownloadCandidates(candidates, now) {
         torrent.emit?.("download-requested", { piece, deadlineAt, requestId, peer: wire.remoteAddress, queued: wire.requests?.length ?? 0 });
       }
       if (!accepted || (wire.requests?.length ?? 0) <= before ||
-        (wire.requests?.length ?? 0) >= peerRequestCapacity(torrent, wire)) wires.shift();
+        (wire.requests?.length ?? 0) >= readingOf(torrent, wire).capacity) wires.shift();
     }
-    if (!hasCapacity(torrent)) writable.delete(torrent);
+    if (!peers.some(wire => available(torrent, wire))) writable.delete(torrent);
   }
   return { requested, reassigned };
 }

package/services/torrent/download/SwarmSelection.js

@@ -235,7 +235,9 @@ export class SwarmSelection {
         // The level goes with the range: it is what eviction compares when
         // everything resident is wanted by somebody, and dropping it here is
         // what left the store choosing by recency alone.
-        store.protectRange(window.claimant, range.from, range.to, window.urgency, window.deadlineAt, window.priority);
+        // The download map is an eviction preference. Actual reads own pins;
+        // declaring a whole-file tail must not set a whole-file memory floor.
+        store.protectRange(window.claimant, range.from, range.to, window.urgency, window.deadlineAt, window.priority, false);
         holding.add(window.claimant);
       }
     }