@torrent-tv/proxy 2.95.5 → 2.95.7

package/package.json

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

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

@@ -665,14 +665,17 @@ 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();
+    // MEMORY HOLDS WHAT IS READ; WHAT IS DOWNLOADED AHEAD HAS THE DISK. Download
+    // preferences order eviction and nothing else. Counted here, the map of a
+    // whole film asked for the whole film, the adaptive budget handed over all
+    // the memory the machine had free, and once the swarm was told the whole
+    // band the store filled 4.4 GB in five minutes and the kernel killed the
+    // process (Home Assistant, 2026-10-07, torrent-tv/meta#95).
     const required = this.#lru.demand({ memoryRequiredOnly: true });
     const pinned = this.#lru.pinnedCount;
-    if (demand.readers > 0) {
+    if (required.readers > 0) {
       this.#widestSeenPieces = Math.max(this.#widestSeenPieces, required.widestPieces);
-      const pieces = Math.max(MIN_RESIDENT_PIECES, demand.unionPieces, demand.widestPieces, pinned);
+      const pieces = Math.max(MIN_RESIDENT_PIECES, required.unionPieces, required.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
       // arrival evicts one of them — measured 2026-09-02: `6 reader(s) want 23

package/services/torrent/download/SwarmSelection.js

@@ -17,14 +17,28 @@
  * vendored 2.8.5: selections are sorted by priority only when one is inserted,
  * and `shufflePriority` then moves the selection just served to the back of the
  * whole non-zero group. Distinct numbers therefore order the list once and
- * round-robin it afterwards. So the ordering is kept HERE, by choosing what to
- * state at all, and the library is given only the distinction it honours:
- * non-zero for what is wanted now, zero for the speculative tail.
+ * round-robin it afterwards. The library honours one distinction: non-zero
+ * before zero. A wire with nothing left to take from the non-zero selections
+ * goes on to the zero ones, and within a selection it takes the earliest piece
+ * it holds.
+ *
+ * **So everything wanted is stated, and only the first class is non-zero.**
+ * The first class is the most urgent level that is still missing anything, at
+ * its highest priority, whatever its deadlines. Everything else that is not
+ * speculative is stated at zero, so it is fetched only by a wire that would
+ * otherwise stand idle. Stating only the earliest deadline, as this did after
+ * #95, left every peer that held none of that segment's pieces without a
+ * request: on Home Assistant, with three peers each holding every third piece
+ * and one complete slow peer, twelve segments took 184 s at 0.61 MiB/s against
+ * 18.3 s at 6.1 MiB/s when the whole band was stated
+ * (`research/download-translation-2026-10-07.md`, torrent-tv/meta#95).
+ * Speculative levels stay withheld while anything urgent is missing anywhere,
+ * because the link is shared.
  */
 
 import {
+  isConditional,
   piecesOf,
-  selectionPriority,
   Urgency,
   urgencyName
 } from "../demand/index.js";
@@ -68,39 +82,40 @@ export class SwarmSelection {
    *   torrent is still waiting for something urgent. The registry works it out
    *   once and hands the same answer to every selection, because the link is
    *   shared and the question is not a per-torrent one.
+   * @param {{ urgency: number, priority: number } | null} [options.firstClass] -
+   *   The most urgent missing level and its highest priority across every
+   *   torrent. Without it, this torrent's own.
    * @returns {{ stated: number, withdrawn: number }}
    */
-  reconcile({ speculativeAllowed = true, maximumUrgency = Infinity, minimumPriority = 1, latestDeadlineAt = Infinity } = {}) {
-    const windows=this.#register.windows();
-    const missing=windows.filter(window=>!this.#isSatisfied(window));
-    const urgency=missing.length?Math.min(...missing.map(window=>window.urgency)):null;
-    const eligible=missing.filter(window=>window.urgency===urgency);
-    const priority=eligible.length?Math.max(...eligible.map(window=>window.priority)):null;
-    const ranked=eligible.filter(window=>window.priority===priority);
-    const deadlineAt=ranked.length?Math.min(...ranked.map(window=>window.deadlineAt)):Infinity;
-    const active=urgency===null||urgency>maximumUrgency||priority<minimumPriority||deadlineAt>latestDeadlineAt||(!speculativeAllowed&&urgency>=Urgency.TAIL)?[]:
-      ranked.filter(window=>window.deadlineAt===deadlineAt);
+  reconcile({ speculativeAllowed = !this.hasUrgentMissing(), firstClass = null } = {}) {
+    const missing = this.#register.windows().filter(window => !this.#isSatisfied(window));
+    const first = firstClass ?? this.missingBand();
     /** @type {Map<string, { from: number, to: number, priority: number }>} */
     const wanted = new Map();
-    for (const window of active) {
+    for (const priority of [1, 0]) {
+      const ranges = [];
+      for (const window of missing) {
+        if (!speculativeAllowed && isConditional(window.urgency)) continue;
+        // Speculative levels are never the first class: the library keeps
+        // zero-priority selections last and never rotates them above.
+        const inFirstClass = first !== null && !isConditional(window.urgency)
+          && window.urgency === first.urgency && window.priority >= first.priority;
+        if ((inFirstClass ? 1 : 0) !== priority) continue;
         const range = this.#piecesFor(window);
-        if (!range) {
-          continue;
-        }
-        // Merged by range and priority, not by claimant: two readers wanting
-        // the same pieces are one instruction to the swarm.
-        const key = `${range.from}-${range.to}-${selectionPriority(window.urgency)}`;
-        wanted.set(key, { from: range.from, to: range.to, priority: selectionPriority(window.urgency) });
+        if (range) ranges.push(range);
+      }
+      // Merged within one priority: two readers wanting the same or adjacent
+      // pieces are one instruction, and an unchanged map restates nothing.
+      ranges.sort((a, b) => a.from - b.from);
+      const union = [];
+      for (const range of ranges) {
+        const previous = union.at(-1);
+        if (previous && range.from <= previous.to + 1) previous.to = Math.max(previous.to, range.to);
+        else union.push({ from: range.from, to: range.to, priority });
+      }
+      for (const range of union) wanted.set(`${range.from}-${range.to}-${priority}`, range);
     }
 
-    // Public selections merge adjacent ranges. Publish their union so an
-    // unchanged map does not repeatedly replace the library's merged range.
-    const ordered=[...wanted.values()].sort((a,b)=>a.from-b.from);
-    wanted.clear();
-    const union=[];
-    for(const range of ordered){const previous=union.at(-1);if(previous&&range.from<=previous.to+1)previous.to=Math.max(previous.to,range.to);else union.push({...range});}
-    for(const range of union)wanted.set(`${range.from}-${range.to}-${range.priority}`,range);
-
     let withdrawn = 0;
     for (const [key, range] of [...this.#stated]) {
       if (wanted.has(key)) {

package/services/torrent/download/registry.js

@@ -116,16 +116,18 @@ export function reconcileAll() {
   if (publishingSelections) return { torrents: live.size, speculativeAllowed: false, stated: 0, withdrawn: 0 };
   const entries = [...live];
   const speculativeAllowed = !entries.some((entry) => entry.selection.hasUrgentMissing());
-  const bands=entries.map(entry=>entry.selection.missingBand()).filter(Boolean);
-  const maximumUrgency=bands.length?Math.min(...bands.map(band=>band.urgency)):Infinity;
-  const minimumPriority=bands.length?Math.max(...bands.filter(band=>band.urgency===maximumUrgency).map(band=>band.priority)):1;
-  const latestDeadlineAt=bands.length?Math.min(...bands.filter(band=>band.urgency===maximumUrgency&&band.priority===minimumPriority).map(band=>band.deadlineAt)):Infinity;
+  // The first class across every torrent: the most urgent missing level and
+  // its highest priority. Each selection states it non-zero and the rest zero.
+  const bands = entries.map(entry => entry.selection.missingBand()).filter(Boolean);
+  const urgency = bands.length ? Math.min(...bands.map(band => band.urgency)) : null;
+  const firstClass = urgency === null ? null
+    : { urgency, priority: Math.max(...bands.filter(band => band.urgency === urgency).map(band => band.priority)) };
   let stated = 0;
   let withdrawn = 0;
   publishingSelections = true;
   try {
     for (const entry of entries) {
-      const result = entry.selection.reconcile({ speculativeAllowed, maximumUrgency, minimumPriority, latestDeadlineAt });
+      const result = entry.selection.reconcile({ speculativeAllowed, firstClass });
       stated += result.stated;
       withdrawn += result.withdrawn;
     }