@torrent-tv/proxy 2.107.34 → 2.107.35

package/package.json

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

package/server.js

@@ -649,6 +649,7 @@ export async function startProxyServer({
       return downloadMaps.refresh(sourceKey, fileIndex);
     }).catch(error => logger.warn(`download map after a packet table: ${error?.message ?? error}`));
   };
+  let outputPartsReady = false;
   const downloadMaps = new DownloadMaps({
     // The ranges a picture reads at open are named again by every segment;
     // only the zone the swarm would rank first is sent (torrent-tv/meta#166).
@@ -665,6 +666,12 @@ export async function startProxyServer({
     pack: (zones) => coalescedZones(zones),
     log: (line) => logger.info(line),
     observeWait: (sourceKey, event, fields) => waitTrace.source(sourceKey, event, fields),
+    // A file's own reads are wanted while a present viewer has the file chosen
+    // or on screen. The viewers are assembled below; until they exist no read
+    // can have been asked for by one.
+    fileWanted: (sourceKey, fileIndex) => (outputPartsReady ? outputParts.viewers.forSource(sourceKey) : [])
+      .some(viewer => viewer.source?.selectedFileIndex === fileIndex ||
+        viewer.source?.visibleFileIndices?.includes(fileIndex)),
     resolvePlayback: async (map) => {
       const fileKey = `${map.sourceKey}:${map.fileIndex}`;
       if (map.zones.length === 0) {
@@ -1000,7 +1007,10 @@ export async function startProxyServer({
             ...(demand ? { priority: demand.priority, urgent: demand.urgent, deadlineAt: demand.deadlineAt, interval: demand, leadSeconds: demand.leadSeconds ?? 0 } : {}),
             ...(readPriority?.requestId ? { priority: readPriority.rank, urgent: readPriority.urgent === true,
               deadlineAt: Number.isFinite(readPriority.deadlineAt) ? readPriority.deadlineAt : Number.POSITIVE_INFINITY,
-              scope: "preparation" } : {}) });
+              scope: "preparation" } : {}),
+            // Neither a viewer's interval nor an encode input asked for it: the
+            // file read itself, and that read is wanted while the file is.
+            ...(!demand && !readPriority?.requestId ? { owner: "file" } : {}) });
         }
         if (finished && result.kind === "result") {
           void downloadMaps.refresh(sourceKey, fileIndex).catch(error =>
@@ -1039,7 +1049,11 @@ export async function startProxyServer({
     pinnedPreset,
     indexMemory,
     readMetadataActivity: () => containerOrchestrator.activity(),
-    onViewerChanged: () => { void sourcePreparation?.refresh(); onStateChanged(); },
+    onViewerChanged: () => {
+      void sourcePreparation?.refresh();
+      void downloadMaps.viewersChanged().catch(error => logger.warn(`download maps after a viewer change: ${error.message}`));
+      onStateChanged();
+    },
     onEncodersChanged: () => onStateChanged(),
     sourceInputsFor: (output, index) => segmentInputs.inputsFor(output.file.sourceKey, output.outputKey, index),
     readSourceMedia: async (params) => {
@@ -1333,6 +1347,7 @@ export async function startProxyServer({
       await torrentPool.fillFileInBackground?.(torrent, fileIndex);
     }
   });
+  outputPartsReady = true;
   // Where the processor goes, and at a cold start what the main thread does
   // with it, when the operator asks (torrent-tv/meta#177).
   const startupProfile = startupCpuProfile({

package/services/torrent/download/SwarmSelection.js

@@ -89,6 +89,9 @@ export class SwarmSelection {
     const strictFirstClass = first !== null && !isConditional(first.urgency);
     /** @type {Map<string, { from: number, to: number, priority: number }>} */
     const wanted = new Map();
+    // Who asked for the first class here, for the line that says what the
+    // swarm is told first: which file and which request holds it.
+    const holders = new Set();
     for (const priority of [1, 0]) {
       const ranges = [];
       for (const window of missing) {
@@ -99,6 +102,7 @@ export class SwarmSelection {
           && window.urgency === first.urgency && window.priority >= first.priority;
         if (strictFirstClass && !inFirstClass) continue;
         if ((inFirstClass ? 1 : 0) !== priority) continue;
+        if (priority === 1) holders.add(`${window.fileIndex}:${window.requestId}`);
         const range = this.#piecesFor(window);
         if (range) ranges.push(range);
       }
@@ -114,6 +118,7 @@ export class SwarmSelection {
       for (const range of union) wanted.set(`${range.from}-${range.to}-${priority}`, range);
       if (priority === 1) {
         this.firstClassPieces = union.map(range => range.from === range.to ? `${range.from}` : `${range.from}-${range.to}`);
+        this.firstClassHolders = [...holders].sort();
         this.#required = strictFirstClass ? union.map(({ from, to }) => ({ from, to })) : [];
       }
     }

package/services/torrent/download/registry.js

@@ -285,9 +285,16 @@ export function reconcileAll() {
   for (const entry of entries) entry.limit.sample();
   // What the swarm is told to fetch FIRST, said when it changes. Lower classes
   // are withheld because a wire with no first-class piece would fall through.
+  // And who asked for it, as file:request: a class one torrent holds is what
+  // every other torrent waits behind, so the line names the request holding it.
+  const holdersOf = entry => {
+    const holders = entry.selection.firstClassPieces?.length ? entry.selection.firstClassHolders ?? [] : [];
+    return holders.length ? ` (held by ${holders.slice(0, 4).join(", ")}${holders.length > 4 ? ` +${holders.length - 4} more` : ""})` : "";
+  };
   const said = entries.map(entry => `${String(entry.torrent.infoHash ?? "").slice(0, 8)}: ` +
     `${(entry.selection.firstClassPieces ?? []).slice(0, 8).join(",") || "nothing"}` +
-    `${(entry.selection.firstClassPieces?.length ?? 0) > 8 ? ` +${entry.selection.firstClassPieces.length - 8} more` : ""}`).join("; ");
+    `${(entry.selection.firstClassPieces?.length ?? 0) > 8 ? ` +${entry.selection.firstClassPieces.length - 8} more` : ""}` +
+    holdersOf(entry)).join("; ");
   const head = firstClass ? `${urgencyName(firstClass.urgency)} priority ${firstClass.priority}` : "none";
   firstClassStated = `${head} — pieces ${said}`;
   return { torrents: entries.length, speculativeAllowed, stated, withdrawn };

package/services/viewer/DownloadMaps.js

@@ -21,13 +21,21 @@ export class DownloadMaps {
   /** What the torrent is told of the playback zones: as many windows as say the same thing. */
   #pack;
   #observeWait;
+  /**
+   * Whether a present viewer holds this file, chosen or listed. A read the
+   * file itself made — its track table, media info, keyframes, cover — has no
+   * owner of its own, so it is wanted exactly while the file is.
+   */
+  #fileWanted;
 
   constructor({ publish, resolvePlayback = async map => map.zones, log = null, now = Date.now,
-    clock = () => performance.timeOrigin + performance.now(), pack = zones => zones, observeWait = null }) {
+    clock = () => performance.timeOrigin + performance.now(), pack = zones => zones, observeWait = null,
+    fileWanted = () => true }) {
     if (typeof publish !== "function") throw new TypeError("Download map publication is required.");
     this.#publish = publish;
     this.#resolvePlayback = resolvePlayback;
     this.#pack = pack;
+    this.#fileWanted = fileWanted;
     this.#log = typeof log === "function" ? log : null;
     this.#now = now;
     this.#clock = clock;
@@ -178,7 +186,14 @@ export class DownloadMaps {
     return Boolean(file && zoneIndexOf(file).exactly({ from, to }));
   }
 
-  metadata({ sourceKey, fileIndex, statement, result, priority = 100, urgent = true, deadlineAt = 0, interval, leadSeconds = 0, scope = "playback", order = 0 }) {
+  /**
+   * @param {object} params
+   * @param {"file"} [params.owner] - `"file"` for a read the file made for
+   *   itself with no viewer's demand behind it. Such a statement is published
+   *   only while {@link DownloadMaps#viewersChanged}'s question says the file
+   *   is held by somebody.
+   */
+  metadata({ sourceKey, fileIndex, statement, result, priority = 100, urgent = true, deadlineAt = 0, interval, leadSeconds = 0, scope = "playback", order = 0, owner }) {
     if (!Number.isFinite(leadSeconds) || leadSeconds < 0) throw new TypeError("Metadata preparation time must be finite and nonnegative.");
     const file = this.#file(sourceKey, fileIndex);
     if (result.kind === "needs-ranges") {
@@ -189,7 +204,8 @@ export class DownloadMaps {
         urgent = current.urgent;
         deadlineAt = Number.isFinite(current.deadlineAt) ? current.deadlineAt - leadSeconds * 1000 : current.deadlineAt;
       }
-      const entry = { ranges: result.ranges, requestId: result.requestId, priority, urgent, deadlineAt, interval, leadSeconds, scope, order };
+      const entry = { ranges: result.ranges, requestId: result.requestId, priority, urgent, deadlineAt, interval, leadSeconds, scope, order,
+        ...(owner === "file" ? { owner } : {}) };
       const previous = file.metadata.get(statement);
       if (previous && sameMetadata(previous, entry) && this.#standing(file)) return this.#unchanged(file);
       file.metadata.set(statement, entry);
@@ -254,6 +270,35 @@ export class DownloadMaps {
     return Promise.all(changed);
   }
 
+  /**
+   * The viewers changed: a file's own reads are published again where whether
+   * anybody holds the file has changed.
+   *
+   * A read the file made for itself states its bytes at the urgency of a
+   * stopped viewer, and the swarm fetches only the most urgent class across
+   * every torrent. Kept after its viewer had gone, the head of a film nobody
+   * was opening any more held that class for the whole proxy: its swarm gave
+   * nothing, and every other film was told to fetch only the piece its viewer
+   * stood on (Home Assistant 2026-10-26, PPPD-452, torrent-tv/meta#239).
+   *
+   * @returns {Promise<unknown[]>}
+   */
+  viewersChanged() {
+    const sent = [];
+    for (const file of this.#files.values()) {
+      const own = [...file.metadata].filter(([, metadata]) => metadata.owner === "file");
+      if (own.length === 0) continue;
+      const wanted = this.#fileWanted(file.sourceKey, file.fileIndex) === true;
+      if (file.ownReadsWanted === wanted) continue;
+      file.ownReadsWanted = wanted;
+      this.#log?.(`download map ${file.sourceKey}:${file.fileIndex}: ${own.length} read(s) of the file itself ` +
+        `${wanted ? "stated again — a viewer holds the file" : "withheld — no present viewer holds the file"} ` +
+        `[${own.map(([statement]) => statement).join(", ")}]`);
+      sent.push(this.#emit(file));
+    }
+    return Promise.all(sent);
+  }
+
   forget(sourceKey, fileIndex, { keepPreparation = false } = {}) {
     const file = this.#file(sourceKey, fileIndex);
     this.#setZones(file, []);
@@ -302,7 +347,10 @@ export class DownloadMaps {
     // Compared and sent as the torrent is to act on it: the playback zones
     // packed into as few windows as say the same (`coalescedZones`).
     const zones = [...this.#packedPlayback(file)];
-    for (const { ranges, requestId, priority, urgent, deadlineAt, order } of file.metadata.values()) {
+    const ownReadsWanted = this.#fileWanted(file.sourceKey, file.fileIndex) === true;
+    file.ownReadsWanted = ownReadsWanted;
+    for (const { ranges, requestId, priority, urgent, deadlineAt, order, owner } of file.metadata.values()) {
+      if (owner === "file" && !ownReadsWanted) continue;
       for (const [byteStart, byteEnd] of ranges) {
         zones.push({ byteStart, byteEnd, priority, urgent, downloadOnly: true, requestId, deadlineAt, ...(order ? { order } : {}) });
       }
@@ -520,6 +568,7 @@ function sameMetadata(left, right) {
   return left.requestId === right.requestId && Object.is(left.priority, right.priority) &&
     left.urgent === right.urgent && Object.is(left.deadlineAt, right.deadlineAt) &&
     Object.is(left.leadSeconds, right.leadSeconds) && left.scope === right.scope && left.order === right.order &&
+    left.owner === right.owner &&
     (left.interval?.from ?? null) === (right.interval?.from ?? null) &&
     (left.interval?.to ?? null) === (right.interval?.to ?? null) &&
     left.ranges.length === right.ranges.length &&