@torrent-tv/proxy 2.89.0 → 2.89.2

package/services/encode/host-load.js

@@ -1,174 +1,174 @@
-/**
- * @file What the machine is doing while an encoder runs on it.
- *
- * The budget predicts a rung from two benchmarks taken at startup on an idle
- * machine. On 2026-08-15 it predicted 1.83x for a rung that then ran at
- * 0.90-0.999x with nothing else encoding, and nothing in any log said why. The
- * candidates are all measurable and none of them was being measured:
- *
- *   - the encoder is not getting the cores (something else is taking them, or
- *     it is waiting on input);
- *   - the machine is no longer the machine that was benchmarked, because it has
- *     dropped its clock or grown hot;
- *   - the work around the encode — hashing pieces, serving segments — costs
- *     more than anyone counted.
- *
- * Everything here is Linux-specific and best effort: a host without these files
- * reports nulls and nothing above it changes. The proxy stays
- * deployment-agnostic (`../CLAUDE.md`).
- */
-
-import { readFile } from "node:fs/promises";
-import os from "node:os";
-
-/**
- * Clock ticks per second, the unit `/proc/<pid>/stat` counts CPU time in.
- * `getconf CLK_TCK` is 100 on every Linux this runs on; spawning a process to
- * ask would cost more than the measurement.
- */
-const CLOCK_TICKS_PER_SECOND = 100;
-
-/**
- * @typedef {object} CpuTotals
- * @property {number} busySeconds - Everything but idle.
- * @property {number} idleSeconds
- * @property {number} iowaitSeconds - Idle because it is waiting for a disk.
- */
-
-/**
- * The system's CPU time since boot, from `/proc/stat`.
- *
- * @returns {Promise<CpuTotals | null>}
- */
-export async function readSystemCpu() {
-  try {
-    const text = await readFile("/proc/stat", "utf8");
-    const line = text.split("\n", 1)[0];
-    if (!line.startsWith("cpu ")) {
-      return null;
-    }
-    const fields = line.trim().split(/\s+/).slice(1).map(Number);
-    if (fields.length < 5 || fields.some((value) => !Number.isFinite(value))) {
-      return null;
-    }
-    const [user, nice, system, idle, iowait] = fields;
-    const busyTicks = user + nice + system + fields.slice(5).reduce((sum, value) => sum + value, 0);
-    return {
-      busySeconds: busyTicks / CLOCK_TICKS_PER_SECOND,
-      idleSeconds: idle / CLOCK_TICKS_PER_SECOND,
-      iowaitSeconds: iowait / CLOCK_TICKS_PER_SECOND
-    };
-  } catch {
-    return null; // not Linux, or /proc is not mounted
-  }
-}
-
-/**
- * The CPU time one process has used, from `/proc/<pid>/stat`.
- *
- * The comm field can itself contain spaces and brackets, so the fields are
- * counted from the LAST `)` rather than by splitting the whole line — the usual
- * trap with this file.
- *
- * @param {number} pid
- * @returns {Promise<number | null>} Seconds of CPU, or null.
- */
-export async function readProcessCpuSeconds(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) {
-    return null;
-  }
-  try {
-    const text = await readFile(`/proc/${pid}/stat`, "utf8");
-    const afterComm = text.slice(text.lastIndexOf(")") + 2).trim().split(/\s+/);
-    // After the comm and state fields, utime is index 11 and stime index 12.
-    const utime = Number(afterComm[11]);
-    const stime = Number(afterComm[12]);
-    if (!Number.isFinite(utime) || !Number.isFinite(stime)) {
-      return null;
-    }
-    return (utime + stime) / CLOCK_TICKS_PER_SECOND;
-  } catch {
-    return null; // the process is gone, or this is not Linux
-  }
-}
-
-/**
- * Is this still the machine the benchmarks were taken on: its clock and its
- * temperature.
- *
- * @returns {Promise<{ megahertz: number | null, celsius: number | null }>}
- */
-export async function readMachineState() {
-  const [frequency, temperature] = await Promise.all([
-    readFile("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq", "utf8").catch(() => null),
-    readFile("/sys/class/thermal/thermal_zone0/temp", "utf8").catch(() => null)
-  ]);
-  const kilohertz = frequency === null ? Number.NaN : Number(frequency.trim());
-  const milliCelsius = temperature === null ? Number.NaN : Number(temperature.trim());
-  return {
-    megahertz: Number.isFinite(kilohertz) ? Math.round(kilohertz / 1000) : null,
-    celsius: Number.isFinite(milliCelsius) ? Math.round(milliCelsius / 100) / 10 : null
-  };
-}
-
-/**
- * Turn two readings into the shares of ONE second of wall clock that each part
- * of the machine spent working. A share is per whole machine: 1.0 means every
- * core was busy for the whole interval.
- *
- * @param {{ takenAt: number, processCpuSeconds: number | null, system: CpuTotals | null }} before
- * @param {{ takenAt: number, processCpuSeconds: number | null, system: CpuTotals | null }} after
- * @param {number} [cores=os.cpus().length]
- * @returns {{ elapsedSec: number, processShare: number | null, systemShare: number | null, iowaitShare: number | null } | null}
- */
-export function shareOfMachine(before, after, cores = os.cpus().length) {
-  const elapsedSec = (after.takenAt - before.takenAt) / 1000;
-  if (!(elapsedSec > 0) || !(cores > 0)) {
-    return null;
-  }
-  const machineSeconds = elapsedSec * cores;
-  const processShare = before.processCpuSeconds !== null && after.processCpuSeconds !== null
-    ? (after.processCpuSeconds - before.processCpuSeconds) / machineSeconds
-    : null;
-  const systemShare = before.system !== null && after.system !== null
-    ? (after.system.busySeconds - before.system.busySeconds) / machineSeconds
-    : null;
-  const iowaitShare = before.system !== null && after.system !== null
-    ? (after.system.iowaitSeconds - before.system.iowaitSeconds) / machineSeconds
-    : null;
-  return { elapsedSec, processShare, systemShare, iowaitShare };
-}
-
-/**
- * One reading of everything above, to be compared against the next.
- *
- * @param {number | null} pid - The encoder's process, when one is running.
- * @returns {Promise<{ takenAt: number, processCpuSeconds: number | null, system: CpuTotals | null }>}
- */
-export async function sampleHost(pid) {
-  const [processCpuSeconds, system] = await Promise.all([
-    pid === null ? Promise.resolve(null) : readProcessCpuSeconds(pid),
-    readSystemCpu()
-  ]);
-  return { takenAt: Date.now(), processCpuSeconds, system };
-}
-
-/**
- * How much CPU THIS process has used, across every thread it owns.
- *
- * The proxy is not only its encoders. It downloads the torrent, verifies every
- * piece it receives, keeps the piece store, and pushes segments down a data
- * channel — work that happens in this process and its workers, that scales with
- * the file's own bitrate, and that the encode budget counts as nothing.
- * Measured on the addon host with both encoders suspended, the machine was
- * still 20-29 % busy; this is the number that says how much of that is ours.
- *
- * `process.cpuUsage()` covers all threads of the process, so the torrent
- * worker's hashing is included without asking it anything.
- *
- * @returns {number} Seconds of CPU used since this process began.
- */
-export function readProxyCpuSeconds() {
-  const usage = process.cpuUsage();
-  return (usage.user + usage.system) / 1e6;
-}
+/**
+ * @file What the machine is doing while an encoder runs on it.
+ *
+ * The budget predicts a rung from two benchmarks taken at startup on an idle
+ * machine. On 2026-08-15 it predicted 1.83x for a rung that then ran at
+ * 0.90-0.999x with nothing else encoding, and nothing in any log said why. The
+ * candidates are all measurable and none of them was being measured:
+ *
+ *   - the encoder is not getting the cores (something else is taking them, or
+ *     it is waiting on input);
+ *   - the machine is no longer the machine that was benchmarked, because it has
+ *     dropped its clock or grown hot;
+ *   - the work around the encode — hashing pieces, serving segments — costs
+ *     more than anyone counted.
+ *
+ * Everything here is Linux-specific and best effort: a host without these files
+ * reports nulls and nothing above it changes. The proxy stays
+ * deployment-agnostic (`../CLAUDE.md`).
+ */
+
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+
+/**
+ * Clock ticks per second, the unit `/proc/<pid>/stat` counts CPU time in.
+ * `getconf CLK_TCK` is 100 on every Linux this runs on; spawning a process to
+ * ask would cost more than the measurement.
+ */
+const CLOCK_TICKS_PER_SECOND = 100;
+
+/**
+ * @typedef {object} CpuTotals
+ * @property {number} busySeconds - Everything but idle.
+ * @property {number} idleSeconds
+ * @property {number} iowaitSeconds - Idle because it is waiting for a disk.
+ */
+
+/**
+ * The system's CPU time since boot, from `/proc/stat`.
+ *
+ * @returns {Promise<CpuTotals | null>}
+ */
+export async function readSystemCpu() {
+  try {
+    const text = await readFile("/proc/stat", "utf8");
+    const line = text.split("\n", 1)[0];
+    if (!line.startsWith("cpu ")) {
+      return null;
+    }
+    const fields = line.trim().split(/\s+/).slice(1).map(Number);
+    if (fields.length < 5 || fields.some((value) => !Number.isFinite(value))) {
+      return null;
+    }
+    const [user, nice, system, idle, iowait] = fields;
+    const busyTicks = user + nice + system + fields.slice(5).reduce((sum, value) => sum + value, 0);
+    return {
+      busySeconds: busyTicks / CLOCK_TICKS_PER_SECOND,
+      idleSeconds: idle / CLOCK_TICKS_PER_SECOND,
+      iowaitSeconds: iowait / CLOCK_TICKS_PER_SECOND
+    };
+  } catch {
+    return null; // not Linux, or /proc is not mounted
+  }
+}
+
+/**
+ * The CPU time one process has used, from `/proc/<pid>/stat`.
+ *
+ * The comm field can itself contain spaces and brackets, so the fields are
+ * counted from the LAST `)` rather than by splitting the whole line — the usual
+ * trap with this file.
+ *
+ * @param {number} pid
+ * @returns {Promise<number | null>} Seconds of CPU, or null.
+ */
+export async function readProcessCpuSeconds(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return null;
+  }
+  try {
+    const text = await readFile(`/proc/${pid}/stat`, "utf8");
+    const afterComm = text.slice(text.lastIndexOf(")") + 2).trim().split(/\s+/);
+    // After the comm and state fields, utime is index 11 and stime index 12.
+    const utime = Number(afterComm[11]);
+    const stime = Number(afterComm[12]);
+    if (!Number.isFinite(utime) || !Number.isFinite(stime)) {
+      return null;
+    }
+    return (utime + stime) / CLOCK_TICKS_PER_SECOND;
+  } catch {
+    return null; // the process is gone, or this is not Linux
+  }
+}
+
+/**
+ * Is this still the machine the benchmarks were taken on: its clock and its
+ * temperature.
+ *
+ * @returns {Promise<{ megahertz: number | null, celsius: number | null }>}
+ */
+export async function readMachineState() {
+  const [frequency, temperature] = await Promise.all([
+    readFile("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq", "utf8").catch(() => null),
+    readFile("/sys/class/thermal/thermal_zone0/temp", "utf8").catch(() => null)
+  ]);
+  const kilohertz = frequency === null ? Number.NaN : Number(frequency.trim());
+  const milliCelsius = temperature === null ? Number.NaN : Number(temperature.trim());
+  return {
+    megahertz: Number.isFinite(kilohertz) ? Math.round(kilohertz / 1000) : null,
+    celsius: Number.isFinite(milliCelsius) ? Math.round(milliCelsius / 100) / 10 : null
+  };
+}
+
+/**
+ * Turn two readings into the shares of ONE second of wall clock that each part
+ * of the machine spent working. A share is per whole machine: 1.0 means every
+ * core was busy for the whole interval.
+ *
+ * @param {{ takenAt: number, processCpuSeconds: number | null, system: CpuTotals | null }} before
+ * @param {{ takenAt: number, processCpuSeconds: number | null, system: CpuTotals | null }} after
+ * @param {number} [cores=os.cpus().length]
+ * @returns {{ elapsedSec: number, processShare: number | null, systemShare: number | null, iowaitShare: number | null } | null}
+ */
+export function shareOfMachine(before, after, cores = os.cpus().length) {
+  const elapsedSec = (after.takenAt - before.takenAt) / 1000;
+  if (!(elapsedSec > 0) || !(cores > 0)) {
+    return null;
+  }
+  const machineSeconds = elapsedSec * cores;
+  const processShare = before.processCpuSeconds !== null && after.processCpuSeconds !== null
+    ? (after.processCpuSeconds - before.processCpuSeconds) / machineSeconds
+    : null;
+  const systemShare = before.system !== null && after.system !== null
+    ? (after.system.busySeconds - before.system.busySeconds) / machineSeconds
+    : null;
+  const iowaitShare = before.system !== null && after.system !== null
+    ? (after.system.iowaitSeconds - before.system.iowaitSeconds) / machineSeconds
+    : null;
+  return { elapsedSec, processShare, systemShare, iowaitShare };
+}
+
+/**
+ * One reading of everything above, to be compared against the next.
+ *
+ * @param {number | null} pid - The encoder's process, when one is running.
+ * @returns {Promise<{ takenAt: number, processCpuSeconds: number | null, system: CpuTotals | null }>}
+ */
+export async function sampleHost(pid) {
+  const [processCpuSeconds, system] = await Promise.all([
+    pid === null ? Promise.resolve(null) : readProcessCpuSeconds(pid),
+    readSystemCpu()
+  ]);
+  return { takenAt: Date.now(), processCpuSeconds, system };
+}
+
+/**
+ * How much CPU THIS process has used, across every thread it owns.
+ *
+ * The proxy is not only its encoders. It downloads the torrent, verifies every
+ * piece it receives, keeps the piece store, and pushes segments down a data
+ * channel — work that happens in this process and its workers, that scales with
+ * the file's own bitrate, and that the encode budget counts as nothing.
+ * Measured on the addon host with both encoders suspended, the machine was
+ * still 20-29 % busy; this is the number that says how much of that is ours.
+ *
+ * `process.cpuUsage()` covers all threads of the process, so the torrent
+ * worker's hashing is included without asking it anything.
+ *
+ * @returns {number} Seconds of CPU used since this process began.
+ */
+export function readProxyCpuSeconds() {
+  const usage = process.cpuUsage();
+  return (usage.user + usage.system) / 1e6;
+}

package/services/encode/index.js

@@ -1,9 +1,9 @@
-// Only what is imported through this file. Everything else in `encode/` is
-// imported from the module that declares it, which is how the rest of the
-// package already reads — four other folders had a file like this one that
-// nothing imported at all, and they are gone.
-export { NvencEncoder } from "./NvencEncoder.js";
-export { QsvEncoder } from "./QsvEncoder.js";
-export { SoftwareEncoder } from "./SoftwareEncoder.js";
-export { V4l2m2mEncoder } from "./V4l2m2mEncoder.js";
-export { VaapiEncoder } from "./VaapiEncoder.js";
+// Only what is imported through this file. Everything else in `encode/` is
+// imported from the module that declares it, which is how the rest of the
+// package already reads — four other folders had a file like this one that
+// nothing imported at all, and they are gone.
+export { NvencEncoder } from "./NvencEncoder.js";
+export { QsvEncoder } from "./QsvEncoder.js";
+export { SoftwareEncoder } from "./SoftwareEncoder.js";
+export { V4l2m2mEncoder } from "./V4l2m2mEncoder.js";
+export { VaapiEncoder } from "./VaapiEncoder.js";

package/services/encode/learned-median.js

@@ -1,90 +1,90 @@
-/**
- * @file Publishing a value that is learned from repeated readings.
- *
- * Four costs are learned this way — what a file costs to decode, what copying
- * it costs, what a soundtrack costs, what the torrent costs per megabyte — and
- * each has the same two decisions to make: which figure the readings amount to,
- * and when a new figure replaces the published one.
- *
- * The first is the median, because one starved moment must not drag the answer.
- *
- * The second used to be "more than five per cent", a figure nobody measured.
- * It is now the scatter of the readings themselves: a median that has moved
- * further than its own readings disagree with each other has moved for a
- * reason, and one that has not is the same answer read again. Republishing
- * costs something real — every session recomputes its offer, on the path that
- * serves every playlist, init and segment — so the question is worth asking,
- * but it is answered from the measurements rather than from a constant.
- */
-
-/**
- * How many of the most recent readings the median is taken over.
- *
- * A statement about how much of the past still describes the host, not a
- * measured quantity, and it is written as one rather than dressed up as one.
- * It lives here because it is a property of this rule and not of any one cost:
- * all four learn the same way, and it was declared in the session manager under
- * a name that claimed it was about decoding while three of the four used it.
- */
-export const READINGS_KEPT = 7;
-
-/**
- * The middle of a set of readings, or null when there are none.
- *
- * @param {number[]} values
- * @returns {number | null}
- */
-export function medianOf(values) {
-  const usable = (Array.isArray(values) ? values : []).filter((value) => Number.isFinite(value));
-  if (usable.length === 0) {
-    return null;
-  }
-  const sorted = [...usable].sort((left, right) => left - right);
-  const middle = Math.floor(sorted.length / 2);
-  return sorted.length % 2 === 0 ? (sorted[middle - 1] + sorted[middle]) / 2 : sorted[middle];
-}
-
-/**
- * How far the readings sit from their own middle — the median of their
- * distances to it.
- *
- * The median distance rather than the mean one, for the same reason the value
- * itself is a median: a single disturbed reading describes the disturbance, not
- * the host.
- *
- * @param {number[]} values
- * @returns {number | null} Null when there is nothing to measure. Zero is a
- *   real answer: readings that all agree disagree by nothing.
- */
-export function scatterOf(values) {
-  const middle = medianOf(values);
-  if (middle === null) {
-    return null;
-  }
-  const distances = (Array.isArray(values) ? values : [])
-    .filter((value) => Number.isFinite(value))
-    .map((value) => Math.abs(value - middle));
-  return medianOf(distances);
-}
-
-/**
- * Whether a newly computed median should replace the published one.
- *
- * @param {number | null} published - What every session is answering with now.
- * @param {number} median - What the readings say today.
- * @param {number[]} readings - The readings that median came from.
- * @returns {boolean}
- */
-export function movedBeyondScatter(published, median, readings) {
-  if (!Number.isFinite(median)) {
-    return false;
-  }
-  if (!Number.isFinite(published)) {
-    return true; // nothing published yet; the first answer is always news
-  }
-  const scatter = scatterOf(readings);
-  if (scatter === null) {
-    return true;
-  }
-  return Math.abs(median - published) > scatter;
-}
+/**
+ * @file Publishing a value that is learned from repeated readings.
+ *
+ * Four costs are learned this way — what a file costs to decode, what copying
+ * it costs, what a soundtrack costs, what the torrent costs per megabyte — and
+ * each has the same two decisions to make: which figure the readings amount to,
+ * and when a new figure replaces the published one.
+ *
+ * The first is the median, because one starved moment must not drag the answer.
+ *
+ * The second used to be "more than five per cent", a figure nobody measured.
+ * It is now the scatter of the readings themselves: a median that has moved
+ * further than its own readings disagree with each other has moved for a
+ * reason, and one that has not is the same answer read again. Republishing
+ * costs something real — every session recomputes its offer, on the path that
+ * serves every playlist, init and segment — so the question is worth asking,
+ * but it is answered from the measurements rather than from a constant.
+ */
+
+/**
+ * How many of the most recent readings the median is taken over.
+ *
+ * A statement about how much of the past still describes the host, not a
+ * measured quantity, and it is written as one rather than dressed up as one.
+ * It lives here because it is a property of this rule and not of any one cost:
+ * all four learn the same way, and it was declared in the session manager under
+ * a name that claimed it was about decoding while three of the four used it.
+ */
+export const READINGS_KEPT = 7;
+
+/**
+ * The middle of a set of readings, or null when there are none.
+ *
+ * @param {number[]} values
+ * @returns {number | null}
+ */
+export function medianOf(values) {
+  const usable = (Array.isArray(values) ? values : []).filter((value) => Number.isFinite(value));
+  if (usable.length === 0) {
+    return null;
+  }
+  const sorted = [...usable].sort((left, right) => left - right);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[middle - 1] + sorted[middle]) / 2 : sorted[middle];
+}
+
+/**
+ * How far the readings sit from their own middle — the median of their
+ * distances to it.
+ *
+ * The median distance rather than the mean one, for the same reason the value
+ * itself is a median: a single disturbed reading describes the disturbance, not
+ * the host.
+ *
+ * @param {number[]} values
+ * @returns {number | null} Null when there is nothing to measure. Zero is a
+ *   real answer: readings that all agree disagree by nothing.
+ */
+export function scatterOf(values) {
+  const middle = medianOf(values);
+  if (middle === null) {
+    return null;
+  }
+  const distances = (Array.isArray(values) ? values : [])
+    .filter((value) => Number.isFinite(value))
+    .map((value) => Math.abs(value - middle));
+  return medianOf(distances);
+}
+
+/**
+ * Whether a newly computed median should replace the published one.
+ *
+ * @param {number | null} published - What every session is answering with now.
+ * @param {number} median - What the readings say today.
+ * @param {number[]} readings - The readings that median came from.
+ * @returns {boolean}
+ */
+export function movedBeyondScatter(published, median, readings) {
+  if (!Number.isFinite(median)) {
+    return false;
+  }
+  if (!Number.isFinite(published)) {
+    return true; // nothing published yet; the first answer is always news
+  }
+  const scatter = scatterOf(readings);
+  if (scatter === null) {
+    return true;
+  }
+  return Math.abs(median - published) > scatter;
+}