@torrent-tv/proxy 2.89.5 → 2.89.7

package/services/encode/throughput.js

@@ -1,97 +1,97 @@
-/**
- * @file How fast a calibrated encoding mode runs at a given frame size, from
- * the readings the startup calibration took (`encode/calibration.js`).
- *
- * Pure arithmetic over measured figures, kept apart from the calibration so
- * that everything which prices an encode can read it without reaching the code
- * that runs ffmpeg.
- */
-
-/**
- * @typedef {object} SizeReading
- * @property {number} width
- * @property {number} height
- * @property {number} pixelsPerSec
- */
-
-/**
- * The rate of pictures this mode would encode at this frame, in pixels per
- * second, or null where this machine has not shown it can.
- *
- * An entry with no readings by size — built before sizes were read, or by a
- * check that states one figure — answers with its one figure, as it always did.
- *
- * @param {{ pixelsPerSec: number, bySize?: SizeReading[], interpolationError?: number | null }} entry
- * @param {{ width: number, height: number } | null | undefined} frame
- * @returns {number | null}
- */
-export function throughputAt(entry, frame) {
-  const bySize = Array.isArray(entry?.bySize) ? entry.bySize : [];
-  const width = Number(frame?.width) || 0;
-  const height = Number(frame?.height) || 0;
-  if (bySize.length === 0 || width <= 0 || height <= 0) {
-    const figure = Number(entry?.pixelsPerSec);
-    return Number.isFinite(figure) && figure > 0 ? figure : null;
-  }
-  const area = width * height;
-  const sorted = [...bySize].sort((left, right) => left.width * left.height - right.width * right.height);
-  const smallest = sorted[0];
-  const largest = sorted[sorted.length - 1];
-  if (area < smallest.width * smallest.height || area > largest.width * largest.height) {
-    return null;
-  }
-  for (let index = 0; index < sorted.length; index += 1) {
-    const reading = sorted[index];
-    const readArea = reading.width * reading.height;
-    if (readArea === area) {
-      return reading.pixelsPerSec;
-    }
-    if (readArea > area) {
-      const error = entry.interpolationError;
-      if (!(Number.isFinite(error) && error >= 0 && error < 1)) {
-        return null;
-      }
-      const below = sorted[index - 1];
-      return interpolate(below, reading, area) * (1 - error);
-    }
-  }
-  return null;
-}
-
-/**
- * Pixels per second at an area between two readings, straight in logarithms
- * of both: throughput against frame area is a power law over any short
- * stretch, and a straight line between two points of it is the least that
- * can be said without inventing a shape.
- *
- * @param {SizeReading} below
- * @param {SizeReading} above
- * @param {number} area
- * @returns {number}
- */
-function interpolate(below, above, area) {
-  const lowArea = below.width * below.height;
-  const highArea = above.width * above.height;
-  const share = Math.log(area / lowArea) / Math.log(highArea / lowArea);
-  return Math.exp(Math.log(below.pixelsPerSec) + share * (Math.log(above.pixelsPerSec) - Math.log(below.pixelsPerSec)));
-}
-
-/**
- * How far an interpolation between readings of this mode was measured to be
- * wrong: the largest relative error of a middle reading predicted from the two
- * outside it.
- *
- * @param {SizeReading[]} bySize - Smallest first.
- * @returns {number | null} Null with fewer than three readings.
- */
-export function interpolationErrorOf(bySize) {
-  let largest = null;
-  for (let index = 1; index + 1 < bySize.length; index += 1) {
-    const middle = bySize[index];
-    const predicted = interpolate(bySize[index - 1], bySize[index + 1], middle.width * middle.height);
-    const error = Math.abs(predicted - middle.pixelsPerSec) / middle.pixelsPerSec;
-    largest = largest === null ? error : Math.max(largest, error);
-  }
-  return largest;
-}
-
+/**
+ * @file How fast a calibrated encoding mode runs at a given frame size, from
+ * the readings the startup calibration took (`encode/calibration.js`).
+ *
+ * Pure arithmetic over measured figures, kept apart from the calibration so
+ * that everything which prices an encode can read it without reaching the code
+ * that runs ffmpeg.
+ */
+
+/**
+ * @typedef {object} SizeReading
+ * @property {number} width
+ * @property {number} height
+ * @property {number} pixelsPerSec
+ */
+
+/**
+ * The rate of pictures this mode would encode at this frame, in pixels per
+ * second, or null where this machine has not shown it can.
+ *
+ * An entry with no readings by size — built before sizes were read, or by a
+ * check that states one figure — answers with its one figure, as it always did.
+ *
+ * @param {{ pixelsPerSec: number, bySize?: SizeReading[], interpolationError?: number | null }} entry
+ * @param {{ width: number, height: number } | null | undefined} frame
+ * @returns {number | null}
+ */
+export function throughputAt(entry, frame) {
+  const bySize = Array.isArray(entry?.bySize) ? entry.bySize : [];
+  const width = Number(frame?.width) || 0;
+  const height = Number(frame?.height) || 0;
+  if (bySize.length === 0 || width <= 0 || height <= 0) {
+    const figure = Number(entry?.pixelsPerSec);
+    return Number.isFinite(figure) && figure > 0 ? figure : null;
+  }
+  const area = width * height;
+  const sorted = [...bySize].sort((left, right) => left.width * left.height - right.width * right.height);
+  const smallest = sorted[0];
+  const largest = sorted[sorted.length - 1];
+  if (area < smallest.width * smallest.height || area > largest.width * largest.height) {
+    return null;
+  }
+  for (let index = 0; index < sorted.length; index += 1) {
+    const reading = sorted[index];
+    const readArea = reading.width * reading.height;
+    if (readArea === area) {
+      return reading.pixelsPerSec;
+    }
+    if (readArea > area) {
+      const error = entry.interpolationError;
+      if (!(Number.isFinite(error) && error >= 0 && error < 1)) {
+        return null;
+      }
+      const below = sorted[index - 1];
+      return interpolate(below, reading, area) * (1 - error);
+    }
+  }
+  return null;
+}
+
+/**
+ * Pixels per second at an area between two readings, straight in logarithms
+ * of both: throughput against frame area is a power law over any short
+ * stretch, and a straight line between two points of it is the least that
+ * can be said without inventing a shape.
+ *
+ * @param {SizeReading} below
+ * @param {SizeReading} above
+ * @param {number} area
+ * @returns {number}
+ */
+function interpolate(below, above, area) {
+  const lowArea = below.width * below.height;
+  const highArea = above.width * above.height;
+  const share = Math.log(area / lowArea) / Math.log(highArea / lowArea);
+  return Math.exp(Math.log(below.pixelsPerSec) + share * (Math.log(above.pixelsPerSec) - Math.log(below.pixelsPerSec)));
+}
+
+/**
+ * How far an interpolation between readings of this mode was measured to be
+ * wrong: the largest relative error of a middle reading predicted from the two
+ * outside it.
+ *
+ * @param {SizeReading[]} bySize - Smallest first.
+ * @returns {number | null} Null with fewer than three readings.
+ */
+export function interpolationErrorOf(bySize) {
+  let largest = null;
+  for (let index = 1; index + 1 < bySize.length; index += 1) {
+    const middle = bySize[index];
+    const predicted = interpolate(bySize[index - 1], bySize[index + 1], middle.width * middle.height);
+    const error = Math.abs(predicted - middle.pixelsPerSec) / middle.pixelsPerSec;
+    largest = largest === null ? error : Math.max(largest, error);
+  }
+  return largest;
+}
+

package/services/encode/torrent-cost.js

@@ -1,88 +1,88 @@
-/**
- * @file What the torrent itself costs this machine, per megabyte it moves.
- *
- * Downloading, verifying every piece and pushing segments down a data channel
- * are work on the same box as the encoder, and they scale with what is moved.
- * The reading is taken only while nothing is encoding, because that is the one
- * moment the spending needs no arithmetic to attribute: what the process uses
- * then is the torrent's.
- *
- * Except that it is not all the torrent's, and that is what this file exists
- * for. Measured on the addon host 2026-08-18, one session reported **145.4 ms
- * per megabyte over 8.7 MB** and **23.1 ms per megabyte over 54 MB** — the same
- * host, the same minute, a sixfold disagreement that follows the size of the
- * interval rather than anything about the torrent. 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: divided by a small number it swamps the
- * answer. 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 measurable. An interval in which nothing encodes and the torrents
- * move no bytes at all costs whatever this process spends anyway; subtract that
- * from an interval which did move bytes, and what remains is the torrent's.
- */
-
-/**
- * The share of one core this process draws while it has nothing to do.
- *
- * @param {{ cpuSeconds: number, elapsedSeconds: number }} interval - CPU seconds
- *   already divided by the number of cores, so the figure is comparable with
- *   the wall seconds every other cost in the budget is stated in.
- * @returns {number | null} Null when the interval cannot be divided.
- */
-export function baseDrawFrom({ cpuSeconds, elapsedSeconds }) {
-  if (!Number.isFinite(cpuSeconds) || !Number.isFinite(elapsedSeconds) || !(elapsedSeconds > 0)) {
-    return null;
-  }
-  if (!(cpuSeconds >= 0)) {
-    return null;
-  }
-  return cpuSeconds / elapsedSeconds;
-}
-
-/**
- * What one megabyte cost, once the draw that would have been spent anyway is
- * taken off.
- *
- * The draw is subtracted, so what is left is only as certain as the draw is.
- * The draw's own readings disagree with each other by a measured amount, and
- * over an interval that disagreement is worth `scatter × elapsed` seconds of
- * CPU: a reading whose remainder is smaller than that measures the wobble in
- * the subtraction rather than the torrent. This is what the removed
- * minimum-megabytes threshold was reaching for, arrived at from the readings
- * instead of from a chosen size — a small interval fails it because little was
- * moved in it, and a large one passes on the same arithmetic.
- *
- * @param {{ cpuSeconds: number, elapsedSeconds: number, megabytes: number, baseDraw: number | null, drawScatter?: number | null }} interval
- * @returns {number | null} Seconds of work per megabyte, or null when this
- *   interval cannot say — no base draw measured yet, nothing moved, or the
- *   interval spent no more than the draw and its own uncertainty account for.
- */
-export function costPerMegabyteFrom({ cpuSeconds, elapsedSeconds, megabytes, baseDraw, drawScatter = null }) {
-  if (!Number.isFinite(cpuSeconds) || !Number.isFinite(elapsedSeconds) || !(elapsedSeconds > 0)) {
-    return null;
-  }
-  if (!Number.isFinite(megabytes) || !(megabytes > 0)) {
-    return null;
-  }
-  if (!Number.isFinite(baseDraw) || !(baseDraw >= 0)) {
-    // Nothing measured to subtract. Publishing the whole spending as the
-    // torrent's is what produced the 145 ms/MB reading, so this interval says
-    // nothing instead.
-    return null;
-  }
-  const attributable = cpuSeconds - baseDraw * elapsedSeconds;
-  if (!(attributable > 0)) {
-    // The draw accounts for everything this interval spent. Not a discovery
-    // that the torrent is free — a reading with nothing left in it.
-    return null;
-  }
-  const uncertainty = Number.isFinite(drawScatter) && drawScatter > 0 ? drawScatter * elapsedSeconds : 0;
-  if (!(attributable > uncertainty)) {
-    // What is left is inside the disagreement between the draw's own readings.
-    // Dividing it by a small number of megabytes is how 145 ms/MB was reported
-    // on a host that costs 23.
-    return null;
-  }
-  return attributable / megabytes;
-}
+/**
+ * @file What the torrent itself costs this machine, per megabyte it moves.
+ *
+ * Downloading, verifying every piece and pushing segments down a data channel
+ * are work on the same box as the encoder, and they scale with what is moved.
+ * The reading is taken only while nothing is encoding, because that is the one
+ * moment the spending needs no arithmetic to attribute: what the process uses
+ * then is the torrent's.
+ *
+ * Except that it is not all the torrent's, and that is what this file exists
+ * for. Measured on the addon host 2026-08-18, one session reported **145.4 ms
+ * per megabyte over 8.7 MB** and **23.1 ms per megabyte over 54 MB** — the same
+ * host, the same minute, a sixfold disagreement that follows the size of the
+ * interval rather than anything about the torrent. 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: divided by a small number it swamps the
+ * answer. 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 measurable. An interval in which nothing encodes and the torrents
+ * move no bytes at all costs whatever this process spends anyway; subtract that
+ * from an interval which did move bytes, and what remains is the torrent's.
+ */
+
+/**
+ * The share of one core this process draws while it has nothing to do.
+ *
+ * @param {{ cpuSeconds: number, elapsedSeconds: number }} interval - CPU seconds
+ *   already divided by the number of cores, so the figure is comparable with
+ *   the wall seconds every other cost in the budget is stated in.
+ * @returns {number | null} Null when the interval cannot be divided.
+ */
+export function baseDrawFrom({ cpuSeconds, elapsedSeconds }) {
+  if (!Number.isFinite(cpuSeconds) || !Number.isFinite(elapsedSeconds) || !(elapsedSeconds > 0)) {
+    return null;
+  }
+  if (!(cpuSeconds >= 0)) {
+    return null;
+  }
+  return cpuSeconds / elapsedSeconds;
+}
+
+/**
+ * What one megabyte cost, once the draw that would have been spent anyway is
+ * taken off.
+ *
+ * The draw is subtracted, so what is left is only as certain as the draw is.
+ * The draw's own readings disagree with each other by a measured amount, and
+ * over an interval that disagreement is worth `scatter × elapsed` seconds of
+ * CPU: a reading whose remainder is smaller than that measures the wobble in
+ * the subtraction rather than the torrent. This is what the removed
+ * minimum-megabytes threshold was reaching for, arrived at from the readings
+ * instead of from a chosen size — a small interval fails it because little was
+ * moved in it, and a large one passes on the same arithmetic.
+ *
+ * @param {{ cpuSeconds: number, elapsedSeconds: number, megabytes: number, baseDraw: number | null, drawScatter?: number | null }} interval
+ * @returns {number | null} Seconds of work per megabyte, or null when this
+ *   interval cannot say — no base draw measured yet, nothing moved, or the
+ *   interval spent no more than the draw and its own uncertainty account for.
+ */
+export function costPerMegabyteFrom({ cpuSeconds, elapsedSeconds, megabytes, baseDraw, drawScatter = null }) {
+  if (!Number.isFinite(cpuSeconds) || !Number.isFinite(elapsedSeconds) || !(elapsedSeconds > 0)) {
+    return null;
+  }
+  if (!Number.isFinite(megabytes) || !(megabytes > 0)) {
+    return null;
+  }
+  if (!Number.isFinite(baseDraw) || !(baseDraw >= 0)) {
+    // Nothing measured to subtract. Publishing the whole spending as the
+    // torrent's is what produced the 145 ms/MB reading, so this interval says
+    // nothing instead.
+    return null;
+  }
+  const attributable = cpuSeconds - baseDraw * elapsedSeconds;
+  if (!(attributable > 0)) {
+    // The draw accounts for everything this interval spent. Not a discovery
+    // that the torrent is free — a reading with nothing left in it.
+    return null;
+  }
+  const uncertainty = Number.isFinite(drawScatter) && drawScatter > 0 ? drawScatter * elapsedSeconds : 0;
+  if (!(attributable > uncertainty)) {
+    // What is left is inside the disagreement between the draw's own readings.
+    // Dividing it by a small number of megabytes is how 145 ms/MB was reported
+    // on a host that costs 23.
+    return null;
+  }
+  return attributable / megabytes;
+}

package/services/identity/installation-id.js

@@ -1,38 +1,38 @@
-import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import path from "node:path";
-
-const ID_FILE = "proxy-identity.json";
-
-/**
- * Resolve this installation's registry id. Without a state directory the id
- * remains ephemeral; with one, the id survives process restarts.
- *
- * @param {{ stateDir?: string, explicitId?: string, makeId?: () => string }} options
- * @returns {string}
- */
-export function installationId({ stateDir, explicitId, makeId = randomUUID } = {}) {
-  const requestedId = typeof explicitId === "string" ? explicitId.trim() : "";
-  if (!stateDir) {
-    return requestedId || makeId();
-  }
-
-  const file = path.join(stateDir, ID_FILE);
-  let savedId = "";
-  if (existsSync(file)) {
-    const saved = JSON.parse(readFileSync(file, "utf8"));
-    savedId = typeof saved?.id === "string" ? saved.id.trim() : "";
-    if (!savedId) {
-      throw new Error(`Invalid proxy identity file: ${file}`);
-    }
-  }
-
-  const id = requestedId || savedId || makeId();
-  if (id !== savedId) {
-    mkdirSync(stateDir, { recursive: true });
-    const temporary = `${file}.${process.pid}.tmp`;
-    writeFileSync(temporary, `${JSON.stringify({ id })}\n`, { mode: 0o600 });
-    renameSync(temporary, file);
-  }
-  return id;
-}
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+const ID_FILE = "proxy-identity.json";
+
+/**
+ * Resolve this installation's registry id. Without a state directory the id
+ * remains ephemeral; with one, the id survives process restarts.
+ *
+ * @param {{ stateDir?: string, explicitId?: string, makeId?: () => string }} options
+ * @returns {string}
+ */
+export function installationId({ stateDir, explicitId, makeId = randomUUID } = {}) {
+  const requestedId = typeof explicitId === "string" ? explicitId.trim() : "";
+  if (!stateDir) {
+    return requestedId || makeId();
+  }
+
+  const file = path.join(stateDir, ID_FILE);
+  let savedId = "";
+  if (existsSync(file)) {
+    const saved = JSON.parse(readFileSync(file, "utf8"));
+    savedId = typeof saved?.id === "string" ? saved.id.trim() : "";
+    if (!savedId) {
+      throw new Error(`Invalid proxy identity file: ${file}`);
+    }
+  }
+
+  const id = requestedId || savedId || makeId();
+  if (id !== savedId) {
+    mkdirSync(stateDir, { recursive: true });
+    const temporary = `${file}.${process.pid}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify({ id })}\n`, { mode: 0o600 });
+    renameSync(temporary, file);
+  }
+  return id;
+}