@torrent-tv/proxy 2.97.6 → 2.97.7

package/package.json

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

package/server.js

@@ -802,6 +802,7 @@ export async function startProxyServer({
     // thread, so the map crosses the worker channel; what it does with it —
     // seconds into bytes, what to ask the swarm for, what to keep in memory —
     // is its own business.
+    setDownloadRate: (bytesPerSecond, because) => torrentPool.setDownloadRate?.(bytesPerSecond, because),
     setPriorityMap: async ({ sourceKey, fileIndex, durationSeconds, zones }) => {
       void sourcePreparation?.refresh();
       const record = sourceRegistry.get(sourceKey);

package/services/encode/quality/HostLoad.js

@@ -89,6 +89,11 @@ export class HostLoad {
   /**
    * @param {object} host - `liveRunsOf`, `runStateOf`, the readings of `encode/host-load.js` (`readMachineState`, `readProcessCpuSeconds`, `readProxyCpuSeconds`, `readSystemCpu`, `shareOfMachine`), `getSourceStats`, `getTorrentTotals`, `outputs`
    */
+  /** The share of one core this process draws doing nothing priced; zero until measured. */
+  get baseDraw() {
+    return this.#observedBaseDraw ?? 0;
+  }
+
   constructor(host) {
     this.#host = host;
   }

package/services/server/wire-outputs.js

@@ -97,6 +97,9 @@ import path from "node:path";
 import { contentOf, LocalObservations, PROXY_ROOT } from "../encode/LocalObservations.js";
 import { configurationKeyOf } from "../encode/fingerprint.js";
 import { qualityStateOf } from "../encode/quality/OutputQualityState.js";
+import os from "node:os";
+import { downloadShare } from "../storage/processor-share.js";
+import { ENCODE_RUN_STATE, processCanBeSignalled } from "../encode/encode-run-state.js";
 
 // Where a variant and an audio rendition live under a session — `v/<height>/…`
 // and `a/<track>/…` — is stated in `encode/output/playlists.js`, beside the lines that
@@ -193,6 +196,7 @@ export function wireOutputs({
     decodeCostModel = null,
     getSourceStats = null,
     setPriorityMap = null,
+    setDownloadRate = null,
     // What a second job costs on this host, measured at startup. Null when it
     // could not be measured, and then nothing is corrected — the alternative
     // is inventing a penalty, which is the same fault as inventing a fill rate.
@@ -342,7 +346,7 @@ export function wireOutputs({
     get encoders() { return parts.encoders; },
     invalidateWaits: (output) => parts.serving.invalidateWaits(output),
     productionFailed: (output) => parts.renditions.noteProductionFailed(output),
-    encodersChanged: () => onEncodersChanged?.(),
+    encodersChanged: () => { parts.applyDownloadShare?.(); onEncodersChanged?.(); },
   });
   // How much film is ready in front of the viewers, said; and the spare soundtracks fetched once it is full.
   parts.cushion = new CushionReport({
@@ -648,6 +652,31 @@ export function wireOutputs({
   // (sourceKey, fileIndex) => Promise<{ downloadSpeed, fileLength, fileProgress } | null>.
   parts.getSourceStats = typeof getSourceStats === "function" ? getSourceStats : null;
   parts.setPriorityMap = typeof setPriorityMap === "function" ? setPriorityMap : null;
+  parts.setDownloadRate = typeof setDownloadRate === "function" ? setDownloadRate : null;
+  // HOW FAST THE TORRENTS MAY DOWNLOAD: the processor the encoders leave
+  // (`storage/processor-share.js`, torrent-tv/meta#178). Worked out again
+  // when the machine is read and when an encoder starts or ends, over every
+  // watched file of every torrent.
+  parts.applyDownloadShare = () => {
+    if (!parts.setDownloadRate || !parts.hostLoad || !parts.encodeCost) return;
+    const files = new Map();
+    for (const output of parts.outputs.values()) {
+      if (!(parts.viewers?.forOutput(output)?.size > 0)) continue;
+      const key = output.file.key;
+      const length = Number(output.file.lengthBytes ?? parts.hostLoad.fileLengthByKey.get(key));
+      const file = files.get(key) ?? { bytesPerFilmSecond: length / Number(output.file.durationSeconds), encodeCostSec: 0 };
+      const state = parts.encodeRuns.runStateOf(output);
+      if (processCanBeSignalled(state) && state !== ENCODE_RUN_STATE.SUSPENDED) {
+        file.encodeCostSec += parts.encodeCost.loadOfOutput(output.outputKey)?.costSec ?? 0;
+      }
+      files.set(key, file);
+    }
+    const watched = [...files.values()].filter((file) => Number.isFinite(file.bytesPerFilmSecond) && file.bytesPerFilmSecond > 0);
+    const share = downloadShare({ cores: os.cpus().length, availableShare: parts.hostLoad.hostAvailability?.share ?? 1,
+      baseDraw: parts.hostLoad.baseDraw, costPerMegabyte: parts.hostLoad.observedTorrentCostPerMegabyte, files: watched });
+    void Promise.resolve(parts.setDownloadRate(share.bytesPerSecond, `film speed ${share.filmSpeed.toFixed(2)}x ` +
+      `over ${watched.length} file(s), ${share.capacity.toFixed(2)} core(s) for the proxy`)).catch(() => {});
+  };
   parts.contentionPenalties = contentionPenalties instanceof Map ? contentionPenalties : null;
   // Seconds of film per second when the picture is COPIED, measured at
   // startup. Nothing else prices that branch: the other benchmarks measure
@@ -1060,7 +1089,7 @@ export function wireOutputs({
     liveConsumers: (...args) => parts.renditions.liveConsumers(...args),
     liveRunsOf: (...args) => parts.encodeRuns.liveRunsOf(...args),
     producedNumbers: (...args) => parts.serving.producedNumbers(...args),
-    reportHostLoad: (...args) => parts.hostLoad.reportHostLoad(...args),
+    reportHostLoad: async (...args) => { await parts.hostLoad.reportHostLoad(...args); parts.applyDownloadShare?.(); },
     runStateOf: (...args) => parts.encodeRuns.runStateOf(...args),
     sampleDownloadRates: (...args) => parts.hostLoad.sampleDownloadRates(...args),
     get encodeCost() { return parts.encodeCost; },

package/services/storage/processor-share.js

@@ -0,0 +1,52 @@
+/**
+ * @file How fast the torrents may download, so that downloading does not take
+ * the processor the encoders need (torrent-tv/meta#178).
+ *
+ * Field 2026-10-11, Home Assistant: an AVI re-encoded at 720x400 needs 2.3 s
+ * of processor per second of film. While the torrent downloaded 4.5-9.8 MB/s —
+ * mostly far ahead of the viewer — its thread took 56-63 % of a core, ffmpeg
+ * got 176-182 %, below real time, and the viewer saw the spinner; once the
+ * download stopped ffmpeg got 216-261 % and there were no stops.
+ *
+ * THE MODEL. The processor the proxy has, `C`, is what other processes leave
+ * of every core, less what the proxy draws doing nothing priced. Every watched
+ * file `f` of every torrent advances at a film speed `s`: its encoders take
+ * `s·k_f` (seconds of processor per second of film, as measured for the
+ * encoders running now) and its download `s·w_f·c` (`w_f` its bytes per second
+ * of film, `c` the measured processor per byte moved). One speed for all is
+ * the division under which the slowest file is as fast as it can be:
+ *
+ *     s* = C / Σ_f (k_f + w_f·c),    download rate = max(s*, 1) · Σ_f w_f
+ *
+ * Downloading faster than `s*·w` only piles bytes ahead while the encoders
+ * starve; what is fetched first within the rate is the priority map's order.
+ * The rate never falls below the films' own byte rate, `Σ w`, because below it
+ * the viewer stops whatever the encoders get. Where `s* < 1` or the swarm
+ * gives less than the rate, stops cannot be avoided, and the start forecast,
+ * reading the speeds measured under this rate, waits for them at the start
+ * and after a seek. With nothing encoding `k` is zero and the download has the
+ * processor. A term nobody has measured contributes nothing: an unmeasured
+ * price of a byte leaves the download unlimited.
+ */
+
+/**
+ * @param {object} params
+ * @param {number} params.cores
+ * @param {number} params.availableShare - The share of the machine other processes leave, 0..1.
+ * @param {number} params.baseDraw - Processor the proxy draws doing nothing priced, in cores.
+ * @param {number | null} params.costPerMegabyte - Processor seconds per megabyte the torrent moves.
+ * @param {{ bytesPerFilmSecond: number, encodeCostSec: number }[]} params.files - Watched files.
+ * @returns {{ filmSpeed: number, bytesPerSecond: number, capacity: number }}
+ *   `bytesPerSecond` is Infinity where the download is not limited.
+ */
+export function downloadShare({ cores, availableShare, baseDraw, costPerMegabyte, files }) {
+  const capacity = Math.max(0, cores * availableShare - baseDraw);
+  // A byte whose price is not measured, or costs nothing, takes nothing from
+  // the encoders: there is then no share to keep the download to.
+  const perByte = Number.isFinite(costPerMegabyte) && costPerMegabyte > 0 ? costPerMegabyte / 1e6 : 0;
+  const bytes = files.reduce((sum, file) => sum + file.bytesPerFilmSecond, 0);
+  const demand = files.reduce((sum, file) => sum + file.encodeCostSec + file.bytesPerFilmSecond * perByte, 0);
+  const filmSpeed = capacity / demand;
+  const bytesPerSecond = perByte > 0 ? Math.max(filmSpeed, 1) * bytes : Infinity;
+  return { filmSpeed, capacity, bytesPerSecond: Number.isFinite(bytesPerSecond) && bytes > 0 ? bytesPerSecond : Infinity };
+}

package/services/torrent/torrent-pool.js

@@ -1261,6 +1261,35 @@ export class TorrentPool {
    *   film against a number, highest first in urgency.
    * @param {number} durationSeconds
    */
+  /**
+   * How fast every torrent may download in all: the share of the processor
+   * the encoders leave (`storage/processor-share.js`, torrent-tv/meta#178).
+   * Within it the swarm is asked for what the priority map puts first.
+   *
+   * @param {number | null} bytesPerSecond - Infinity or null for no limit.
+   * @param {string} [because]
+   */
+  setDownloadRate(bytesPerSecond, because = "") {
+    if (!this.client || this.client.destroyed || typeof this.client.throttleDownload !== "function") return;
+    const rate = Number.isFinite(bytesPerSecond) ? Math.max(1, Math.round(bytesPerSecond)) : -1;
+    if (rate === this.#downloadLimit) return;
+    this.client.throttleDownload(rate);
+    // Said when the limit is set or lifted, and when it moves by a factor of
+    // two either way — the scale on which a limit changes what the swarm gives.
+    const scale = rate < 0 ? null : Math.round(Math.log2(rate));
+    if (scale !== this.#downloadLimitScale) {
+      this.#downloadLimitScale = scale;
+      logger.info(`torrent-pool: download limit -> ${rate < 0 ? "none" : `${Math.round(rate / 1024)} KB/s`}${because ? ` (${because})` : ""}`);
+    }
+    this.#downloadLimit = rate;
+  }
+
+  /** The download limit in force, -1 for none. */
+  #downloadLimit = -1;
+
+  /** The power of two the last limit said was nearest, null for none. */
+  #downloadLimitScale = null;
+
   applyPriorityMap(torrent, fileIndex, zones, durationSeconds) {
     // A MAP WITH NOTHING IN IT IS A STATEMENT, and it is answered before
     // anything else is looked at. It says nobody wants any of this file, and

package/services/torrent/worker/client.js

@@ -475,6 +475,17 @@ export class TorrentWorkerClient {
    * @param {{ sourceKey: string, fileIndex: number, durationSeconds: number, zones: { from: number, to: number, priority: number }[] }} params
    * @returns {Promise<void>}
    */
+  /**
+   * How fast the torrents may download in all (`Command.DOWNLOAD_RATE`).
+   *
+   * @param {number} bytesPerSecond - Infinity for no limit.
+   * @param {string} [because]
+   * @returns {Promise<void>}
+   */
+  async setDownloadRate(bytesPerSecond, because = "") {
+    return this.#caller.call(Command.DOWNLOAD_RATE, { bytesPerSecond: Number.isFinite(bytesPerSecond) ? bytesPerSecond : null, because });
+  }
+
   async setPriorityMap({ sourceKey, fileIndex, zones, durationSeconds, postedAt }) {
     return this.#caller.call(Command.PRIORITY_MAP, {
       sourceKey,

package/services/torrent/worker/pool-adapter.js

@@ -164,6 +164,17 @@ export class WorkerTorrentPool {
    * @param {{ sourceKey: string, fileIndex: number, durationSeconds: number, zones: object[] }} params
    * @returns {Promise<void>}
    */
+  /**
+   * How fast the torrents may download in all, Infinity for no limit.
+   *
+   * @param {number} bytesPerSecond
+   * @param {string} [because]
+   * @returns {Promise<void>}
+   */
+  async setDownloadRate(bytesPerSecond, because = "") {
+    return this.#client.setDownloadRate(bytesPerSecond, because);
+  }
+
   async setPriorityMap({ sourceKey, fileIndex, durationSeconds, zones, postedAt }) {
     if (!sourceKey) {
       return;

package/services/torrent/worker/protocol.js

@@ -66,6 +66,12 @@ export const Command = {
    * sixteen pieces is what tore a film apart on 2026-09-05.
    */
   PRIORITY_MAP: "priority-map",
+  /**
+   * How fast the torrents may download in all, in bytes per second, or
+   * Infinity for no limit: the share of the processor the encoders leave
+   * (`storage/processor-share.js`, torrent-tv/meta#178).
+   */
+  DOWNLOAD_RATE: "download-rate",
   /** Read a byte range; the body arrives as CHUNK messages. */
   READ_RANGE: "read-range",
   /** Abandon an in-flight READ_RANGE (viewer gone, seek superseded). */

package/services/torrent/worker/worker.js

@@ -476,6 +476,11 @@ async function runCommand(command, params, id) {
       return { appliedMs: performance.now() - startedAt, receivedAt, repliedAt: performance.timeOrigin + performance.now() };
     }
 
+    case Command.DOWNLOAD_RATE: {
+      pool.setDownloadRate(params.bytesPerSecond, params.because);
+      return true;
+    }
+
     case Command.READ_RANGE: {
       // Streams its own reply; the caller's promise resolves once the body has
       // been fully sent, which is what lets the client await completion.