@torrent-tv/proxy 2.34.0 → 2.36.0

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 2.36.0
+
+- **New**: The torrent is charged for the megabytes it is measured to be moving, and the price it is charged at no longer contains work that is not the torrent's. Two faults, both visible in one field log from the addon host (2026-08-18): the same session reported **145.4 ms of CPU per MB over 8.7 MB and 23.1 ms per MB over 54 MB**, a sixfold disagreement that followed the size of the interval rather than anything about the torrent — because a process with nothing to do still runs its timers, its tunnel and its session sweeps, and that draw does not shrink when fewer megabytes move. A minimum-megabytes threshold stood against exactly this and did not hold, because a chosen number was standing in for a measured one. The draw is now measured directly, in the intervals where nothing encodes and not one byte moves, and subtracted before the rest is called the torrent's (`services/torrent-cost.js`). What the threshold was reaching for is arrived at from the readings instead: the draw's own readings disagree by a measured amount, that disagreement is worth `scatter × elapsed` seconds over an interval, and a remainder smaller than it measures the wobble in the subtraction rather than the torrent — so a small interval fails on the same arithmetic that lets a large one through, with no size chosen anywhere. The second fault: the price was then charged against the file's own byte rate — what the viewer consumes — so a fully downloaded file moving nothing still paid, and a file being fetched ahead of the viewer, which is how every session starts, paid too little. It is charged against the rate the torrent is measured to be moving, sampled every five seconds per watched torrent and divided among the files of it being read, so two episodes of one pack do not each pay for the whole download.
+- **New**: No separate penalty for downloading, because the measurement says none is needed. The readings of 2026-08-18 have decoding at 10.1-11.2x with nothing running and 6.45-6.71x while the torrent pulled 1.8 MB/s — an extra 0.050-0.066 seconds of work per second of content, which is **28-37 ms per megabyte moved**, against the 20-35 ms/MB the host measures for itself. The download's effect on other work is the processor time it consumes, and that is already priced; unlike a second encoder, which costs 2.71× and is not explained by any sum. So this closes roadmap item 6 with a subtraction rather than another multiplier.
+- **New**: A quality step is judged against the speed this file's own supply demands, not against a chosen margin. `1.5` (and `1.8` where decoding had no price) stood for "faster than realtime by enough", and what "enough" means is measured per file and per swarm by the reader that waits for the pieces: `1 + worst wait / median interval`, which the proxy has been printing since 2.30.0 without using. On the field torrent of 2026-08-17 that is 1.67, and on the 720p rip of the same evening 4.04-8.14 — a torrent on which no re-encoded step could have kept up, and which a fixed 1.5 admitted. Where the swarm has not been measured yet — fewer than two interruptions — the bar is realtime, which is the one thing that can be said without measuring it, and the offer is restated as soon as the reader has something to say. The refusal line names the figure it refused against and where it came from. One chosen number survives, and only where nothing can be measured: a host whose calibration produced no decode term at all is judged on an encode-only prediction that was several times optimistic in the field, and its bar stays at the 1.8 it has had since before decoding was priced, because lowering it to realtime would make the least-measured hosts the most permissive.
+- **Chore**: Two learning thresholds removed, both of which were chosen numbers standing in for measurements. A reading of an encoder's speed is no longer withheld for the first twenty seconds of a run: each sample now carries the serial of the run it was taken from and a pair whose serials differ is discarded, which is what the wait stood in for — a restart spends up to a second and a half making its directory and burying its predecessor, and a sample taken in that window carries the old run's position, so paired with the new one it reads a twenty-minute seek as twenty minutes produced in five seconds. The wait cost every reading a short run could have given, which is how a rung spent three minutes below realtime teaching nothing (2026-08-15); the serial costs none. And a new median is adopted when it has moved further than the readings behind it disagree with each other, instead of by more than five per cent (`services/learned-median.js`). What remains chosen is the length of the history a median is taken over, and it is now written down as such rather than given a measured-sounding reason.
+
+## 2.35.0
+
+- **New**: A second job's cost is measured on the host instead of being added as though jobs were independent. Measured on the addon host 2026-08-18, decoding the same clip: **2.10-2.25x alone, 0.79-0.90x with one encoder beside it, 0.56-0.64x with two** — the same work costs 2.6× more for having company, and 3.7× for having two. Heat is not the cause: the hot idle machine (68 °C, a lower reported clock) was the fastest reading of all, which settles what roadmap item 6 was opened for. Four cores sharing one path to memory is the cause, and it contradicts the SHAPE of the budget rather than its constants — everything in the quality offer adds seconds of work per second of content, and these readings say two jobs that each fit alone do not fit together. So the penalty is now measured at startup the way everything else is (the cheapest clip decoded alone, then again while an encoder of it runs), and the offer multiplies a step's cost by it when anything else is encoding. Beyond the readings it holds the largest rather than extrapolating: two points say nothing about a fourth job, and a budget that guesses at a memory bottleneck will be wrong in whichever direction it guesses. With nothing measured, nothing is corrected. This is separate from the availability share of 2.33.0, which removes work nobody has been charged for; this is our own work colliding with itself.
+
 ## 2.34.0
 
 - **New**: The proxy tells the browser the smallest buffer at which no interruption reaches the viewer, measured on the file being watched. It is one whole segment — the one being played — plus the worst wait its own reader met before the buffer could refill, from that file's recent interruptions on that swarm. On the field torrent of 2026-08-17 that is 7-9 s, where the browser has been waiting for a hand-chosen 25: sixteen seconds of spinner that nothing had shown to be necessary. Null until the reader has seen two interruptions — one wait shows no interval, and an interval invented from one point is what this work exists to remove — and the browser keeps its own figure until then. The reader measures it, the session manager states it with its own segment length, and the progress reply carries it.

package/package.json

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

package/server.js

@@ -37,7 +37,7 @@ import { createSourceRegistry } from "./store/source-registry.js";
 import { WorkerTorrentPool } from "./services/torrent-worker/pool-adapter.js";
 import { HlsSessionManager } from "./services/hls-session-manager.js";
 import { createPlaybackPlanner } from "./services/playback-planner.js";
-import { detectVideoEncoder, benchmarkSoftwarePresets, benchmarkDecodeCost, detectTonemapSupport } from "./services/hwaccel.js";
+import { detectVideoEncoder, benchmarkSoftwarePresets, benchmarkDecodeCost, benchmarkContention, detectTonemapSupport } from "./services/hwaccel.js";
 import { logger } from "./utils/logger.js";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -130,6 +130,12 @@ export async function startProxyServer({ host, port, transcodeAudio, ffmpegBin,
   const decodeCostModel = videoEncoder?.kind === "software"
     ? await benchmarkDecodeCost({ ffmpegBin, logger })
     : null;
+  // What a second job costs on this host. Measured because the budget adds
+  // independent prices and this host says two jobs that each fit alone do not
+  // fit together — 2.6× on the addon box (2026-08-18).
+  const contentionPenalties = videoEncoder?.kind === "software"
+    ? await benchmarkContention({ ffmpegBin, logger })
+    : null;
   const softwarePresetBenchmark = videoEncoder?.kind === "software"
     ? await benchmarkSoftwarePresets({ ffmpegBin, logger })
     : null;
@@ -147,6 +153,7 @@ export async function startProxyServer({ host, port, transcodeAudio, ffmpegBin,
     videoEncoder,
     softwarePresetBenchmark,
     decodeCostModel,
+    contentionPenalties,
     tonemapSupported,
     segmentFormatId: segmentFormat,
     stateDir,

package/services/contention.js

@@ -0,0 +1,128 @@
+/**
+ * @file What a second job costs on this machine — measured, because it is not
+ * the sum of two prices.
+ *
+ * Measured on the addon host 2026-08-18, decoding the same clip:
+ *
+ * | what else was running | decode speed | cost |
+ * |---|---|---|
+ * | nothing (cold) | 2.10-2.25x | 0.46 s/s |
+ * | nothing (hot, 68 °C) | 2.30-2.33x | 0.43 s/s |
+ * | one encoder | 0.79-0.90x | 1.18 s/s |
+ * | two encoders | 0.56-0.64x | 1.67 s/s |
+ *
+ * The same work costs **2.6× more** with one encoder beside it and 3.7× with
+ * two. Heat is not the cause — the hot idle machine was the fastest of all.
+ * Four cores share one narrow path to memory, and decoding and encoding both
+ * saturate it.
+ *
+ * That contradicts the shape of the budget, not just its constants. Everything
+ * in the quality offer adds seconds of work per second of content — this
+ * encode, plus that decode, plus what is already committed — and these readings
+ * say two jobs that each fit alone do not fit together. The availability
+ * correction in `available-share.js` does not cover it either: that subtracts
+ * the share of the machine taken by work nobody has been charged for, while
+ * this is our own work colliding with itself.
+ *
+ * So the penalty is measured rather than derived, at startup, on the host it
+ * describes — and beyond the range that was measured it does not extrapolate:
+ * it holds the largest reading and says so, because nothing here knows what a
+ * fourth job would do.
+ */
+
+/**
+ * Penalties measured on this host, keyed by how many OTHER jobs were running.
+ *
+ * @typedef {Map<number, number>} ContentionPenalties
+ */
+
+/**
+ * The multiplier for a job's cost when `othersRunning` other jobs share the
+ * machine.
+ *
+ * @param {number} othersRunning
+ * @param {ContentionPenalties | null} measured
+ * @returns {{ penalty: number, measured: boolean, from: number }}
+ *   `from` is the reading it came from — equal to `othersRunning` when one was
+ *   measured for exactly that many, and the largest available otherwise.
+ */
+export function contentionPenalty(othersRunning, measured) {
+  const others = Number.isFinite(othersRunning) ? Math.max(0, Math.round(othersRunning)) : 0;
+  if (others === 0) {
+    // Alone on the machine is what every benchmark measures, so there is
+    // nothing to correct.
+    return { penalty: 1, measured: true, from: 0 };
+  }
+  if (!(measured instanceof Map) || measured.size === 0) {
+    // Nothing measured: the honest multiplier is 1, and the caller's own log
+    // says the prediction is uncorrected. Inventing a penalty would be the
+    // same mistake as inventing a fill rate.
+    return { penalty: 1, measured: false, from: 0 };
+  }
+  const exact = measured.get(others);
+  if (Number.isFinite(exact) && exact > 0) {
+    return { penalty: exact, measured: true, from: others };
+  }
+  // Beyond what was measured, hold the largest reading rather than continue the
+  // curve. Two readings say nothing about the shape past them, and a budget
+  // that extrapolates a memory bottleneck will be wrong in whichever direction
+  // it guesses.
+  let largestKey = 0;
+  let largestValue = 1;
+  for (const [key, value] of measured) {
+    if (key <= others && key > largestKey && Number.isFinite(value) && value > 0) {
+      largestKey = key;
+      largestValue = value;
+    }
+  }
+  if (largestKey === 0) {
+    return { penalty: 1, measured: false, from: 0 };
+  }
+  return { penalty: largestValue, measured: true, from: largestKey };
+}
+
+/**
+ * A cost, corrected for what else will be running.
+ *
+ * @param {number} costSecondsPerSecond - As the benchmarks priced it, alone.
+ * @param {number} othersRunning
+ * @param {ContentionPenalties | null} measured
+ * @returns {number}
+ */
+export function costWithContention(costSecondsPerSecond, othersRunning, measured) {
+  if (!Number.isFinite(costSecondsPerSecond) || costSecondsPerSecond <= 0) {
+    return costSecondsPerSecond;
+  }
+  return costSecondsPerSecond * contentionPenalty(othersRunning, measured).penalty;
+}
+
+/**
+ * Turn measured decode speeds into penalties.
+ *
+ * @param {number} aloneSpeed - Decode speed with the machine to itself.
+ * @param {Array<{ others: number, speed: number }>} beside - One reading per
+ *   number of other jobs running.
+ * @returns {ContentionPenalties | null} Null when the alone reading is missing,
+ *   since every penalty is relative to it.
+ */
+export function penaltiesFrom(aloneSpeed, beside) {
+  if (!Number.isFinite(aloneSpeed) || aloneSpeed <= 0) {
+    return null;
+  }
+  const penalties = new Map();
+  for (const reading of Array.isArray(beside) ? beside : []) {
+    const others = Number.isFinite(reading?.others) ? Math.round(reading.others) : null;
+    const speed = Number(reading?.speed);
+    if (others === null || others <= 0 || !Number.isFinite(speed) || speed <= 0) {
+      continue;
+    }
+    // Cost is the reciprocal of speed, so the penalty is the reciprocal ratio.
+    // A job that runs at half the speed costs twice as much.
+    const penalty = aloneSpeed / speed;
+    // Below 1 would mean the machine got FASTER for being busier. It happens in
+    // the noise on a fast host, and it is not a discovery — it is a reading
+    // that says there is no penalty to measure here.
+    penalties.set(others, penalty > 1 ? penalty : 1);
+  }
+  return penalties.size > 0 ? penalties : null;
+}