@torrent-tv/proxy 2.87.4 → 2.87.5

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;
+}

package/services/encode/output/EncodedOutput.js

@@ -1,57 +1,57 @@
-/**
- * @file One output that exists on this proxy.
- *
- * What it holds are the facts born with the output and gone with it: its
- * identity and format (`spec`), the file it is made from, where that file is
- * cut, the container its pieces are in, the shape the encoder is given, and the
- * playlist the player is told. Two things it deliberately does NOT hold,
- * decided with the user 2026-09-16: what has been produced — the segment store
- * owns that — and which encoders are running — the encoding orchestrator owns
- * that. An output without a live record does not make its pieces invalid;
- * pieces are valid while they exist.
- *
- */
-
-export class EncodedOutput {
-  /**
-   * @param {object} params
-   * @param {string} params.id - The output's name, derived from its key.
-   * @param {import("./OutputSpec.js").OutputSpec} params.spec
-   * @param {object} params.file - The source file, one object per file.
-   * @param {object} params.keyframes - That file's keyframe table, held rather
-   *   than copied so a table read later still reaches it.
-   * @param {object} params.timeline - Where that file is cut, shared by every
-   *   output of it.
-   * @param {object} params.segmentFormat - The container the pieces are in.
-   * @param {import("./Output.js").Output} params.output - The format in the
-   *   terms the encoder is given, and how its pieces land.
-   * @param {boolean} params.useSyntheticPlaylist - The playlist is built from
-   *   the probed duration rather than written by the encoder.
-   * @param {string} params.playlistText
-   * @param {number | undefined} params.variantHeight - The height a step is
-   *   addressed by, when it is produced at exactly that size.
-   */
-  constructor({ id, spec, file, keyframes, timeline, segmentFormat, output, useSyntheticPlaylist, playlistText, variantHeight }) {
-    this.id = id;
-    this.spec = spec;
-    this.file = file;
-    this.keyframes = keyframes;
-    this.timeline = timeline;
-    this.segmentFormat = segmentFormat;
-    this.output = output;
-    this.useSyntheticPlaylist = useSyntheticPlaylist === true;
-    this.playlistText = typeof playlistText === "string" ? playlistText : "";
-    this.variantHeight = variantHeight;
-
-  }
-
-  /**
-   * The address of this output's pieces. Derived, so it cannot say anything
-   * the spec does not.
-   *
-   * @returns {string}
-   */
-  get outputKey() {
-    return this.spec.toKey();
-  }
-}
+/**
+ * @file One output that exists on this proxy.
+ *
+ * What it holds are the facts born with the output and gone with it: its
+ * identity and format (`spec`), the file it is made from, where that file is
+ * cut, the container its pieces are in, the shape the encoder is given, and the
+ * playlist the player is told. Two things it deliberately does NOT hold,
+ * decided with the user 2026-09-16: what has been produced — the segment store
+ * owns that — and which encoders are running — the encoding orchestrator owns
+ * that. An output without a live record does not make its pieces invalid;
+ * pieces are valid while they exist.
+ *
+ */
+
+export class EncodedOutput {
+  /**
+   * @param {object} params
+   * @param {string} params.id - The output's name, derived from its key.
+   * @param {import("./OutputSpec.js").OutputSpec} params.spec
+   * @param {object} params.file - The source file, one object per file.
+   * @param {object} params.keyframes - That file's keyframe table, held rather
+   *   than copied so a table read later still reaches it.
+   * @param {object} params.timeline - Where that file is cut, shared by every
+   *   output of it.
+   * @param {object} params.segmentFormat - The container the pieces are in.
+   * @param {import("./Output.js").Output} params.output - The format in the
+   *   terms the encoder is given, and how its pieces land.
+   * @param {boolean} params.useSyntheticPlaylist - The playlist is built from
+   *   the probed duration rather than written by the encoder.
+   * @param {string} params.playlistText
+   * @param {number | undefined} params.variantHeight - The height a step is
+   *   addressed by, when it is produced at exactly that size.
+   */
+  constructor({ id, spec, file, keyframes, timeline, segmentFormat, output, useSyntheticPlaylist, playlistText, variantHeight }) {
+    this.id = id;
+    this.spec = spec;
+    this.file = file;
+    this.keyframes = keyframes;
+    this.timeline = timeline;
+    this.segmentFormat = segmentFormat;
+    this.output = output;
+    this.useSyntheticPlaylist = useSyntheticPlaylist === true;
+    this.playlistText = typeof playlistText === "string" ? playlistText : "";
+    this.variantHeight = variantHeight;
+
+  }
+
+  /**
+   * The address of this output's pieces. Derived, so it cannot say anything
+   * the spec does not.
+   *
+   * @returns {string}
+   */
+  get outputKey() {
+    return this.spec.toKey();
+  }
+}

package/services/encode/output/Output.js

@@ -1,131 +1,131 @@
-/**
- * @file One output's format in the terms the encoder is given, and how its
- * pieces land.
- *
- * The format is the output's identity (`OutputSpec`) and is decided before the
- * output is named: the size, the frame rate, the speed setting, whether HDR is
- * tone mapped. This states the same values the way the command builder reads
- * them. It used to be decided once per output and cached by the output's key,
- * because the key named what was asked for while the budget chose the format
- * afterwards; the cache was dropped sooner than the pieces it described, so one
- * key could come to name two formats. The key is the format now, and there is
- * nothing left to cache.
- *
- * The bitrate limit is not here: it is part of the output's identity
- * (`OutputSpec`), so two limits are two outputs and nothing moves a limit under
- * one that exists.
- *
- * **It also holds how well its own pieces land on its own grid.** Where a piece
- * of THIS output truly began, against where its playlist says it begins, is a
- * fact of this output: a step that was told to put a keyframe at that instant
- * and did not will not splice into the stream it accompanies, and a soundtrack
- * whose grid was corrected under a run already going is that far from the
- * picture. Neither says anything about the file. Until 2026-09-15 both were
- * added to a tally held on the CUT TABLE — which is one per (file, grid), so a
- * picture and the soundtrack inside the same file shared it, the second reading
- * of one piece number was dropped as a repeat whichever output it came from,
- * and the summary could not say which of three facts it was summarising.
- */
-
-export class Output {
-  /** @type {{ checked: number, disagreed: number, maxDeviationSec: number, firstDisagreementIndex: number, deviations: number[], seen: Set<number> }} */
-  #tally;
-
-  /**
-   * @param {object} params
-   * @param {number} params.encodeWidth - 0 means the source's own width.
-   * @param {number} params.encodeHeight - 0 means the source's own height.
-   * @param {number} params.outputFps
-   * @param {string | null} params.softwarePreset - The speed setting, where the
-   *   encoder has a ladder and one was chosen from it.
-   * @param {boolean} params.applyTonemap
-   */
-  constructor({ encodeWidth, encodeHeight, outputFps, softwarePreset, applyTonemap }) {
-    this.encodeWidth = Number.isFinite(encodeWidth) ? encodeWidth : 0;
-    this.encodeHeight = Number.isFinite(encodeHeight) ? encodeHeight : 0;
-    this.outputFps = Number.isFinite(outputFps) && outputFps > 0 ? outputFps : 0;
-    this.softwarePreset = typeof softwarePreset === "string" ? softwarePreset : null;
-    this.applyTonemap = applyTonemap === true;
-    /**
-     * How far this output's produced pieces fell from its own published grid.
-     * Private, because `landing` below is the only honest way to read it: a
-     * caller holding the raw counters would have to know which of them are a
-     * summary and which are working state.
-     *
-     * @type {{ checked: number, disagreed: number, maxDeviationSec: number, firstDisagreementIndex: number, deviations: number[], seen: Set<number> }}
-     */
-    this.#tally = {
-      checked: 0,
-      disagreed: 0,
-      maxDeviationSec: 0,
-      firstDisagreementIndex: -1,
-      deviations: [],
-      // A piece can be produced and served again; a repeat is the same piece,
-      // not new evidence. Per OUTPUT, so one output's reading of piece #7 can
-      // no longer silence another output's reading of its own #7.
-      seen: new Set()
-    };
-  }
-
-  /**
-   * A produced piece of this output states where it truly began.
-   *
-   * @param {object} reading
-   * @param {number} reading.index
-   * @param {number} reading.deviationSec - From where this output's playlist
-   *   says that piece begins.
-   * @param {number} reading.toleranceSec - Above which the two are held to
-   *   disagree rather than to have rounded.
-   * @returns {void}
-   */
-  noteLanding({ index, deviationSec, toleranceSec }) {
-    if (!Number.isInteger(index) || !Number.isFinite(deviationSec) || this.#tally.seen.has(index)) {
-      return;
-    }
-    this.#tally.seen.add(index);
-    this.#tally.checked += 1;
-    this.#tally.deviations.push(deviationSec);
-    if (deviationSec > toleranceSec) {
-      this.#tally.disagreed += 1;
-      if (this.#tally.firstDisagreementIndex < 0) {
-        this.#tally.firstDisagreementIndex = index;
-      }
-    }
-    if (deviationSec > this.#tally.maxDeviationSec) {
-      this.#tally.maxDeviationSec = deviationSec;
-    }
-  }
-
-  /**
-   * How many distinct pieces of this output have stated where they began.
-   *
-   * Separate from `landing` because it is read on every produced piece, to
-   * decide whether the summary is due, while `landing` sorts what it summarises
-   * — which on a two-hour film is a sort per segment on the path that serves
-   * one. A count and a summary are two different costs.
-   *
-   * @returns {number}
-   */
-  get piecesLanded() {
-    return this.#tally.checked;
-  }
-
-  /**
-   * Where this output's pieces have been landing, or null while none has.
-   *
-   * @returns {{ checked: number, disagreed: number, maxDeviationSec: number, medianDeviationSec: number, firstDisagreementIndex: number } | null}
-   */
-  get landing() {
-    if (this.#tally.checked === 0) {
-      return null;
-    }
-    const sorted = [...this.#tally.deviations].sort((left, right) => left - right);
-    return {
-      checked: this.#tally.checked,
-      disagreed: this.#tally.disagreed,
-      maxDeviationSec: this.#tally.maxDeviationSec,
-      medianDeviationSec: sorted[Math.floor(sorted.length / 2)],
-      firstDisagreementIndex: this.#tally.firstDisagreementIndex
-    };
-  }
-}
+/**
+ * @file One output's format in the terms the encoder is given, and how its
+ * pieces land.
+ *
+ * The format is the output's identity (`OutputSpec`) and is decided before the
+ * output is named: the size, the frame rate, the speed setting, whether HDR is
+ * tone mapped. This states the same values the way the command builder reads
+ * them. It used to be decided once per output and cached by the output's key,
+ * because the key named what was asked for while the budget chose the format
+ * afterwards; the cache was dropped sooner than the pieces it described, so one
+ * key could come to name two formats. The key is the format now, and there is
+ * nothing left to cache.
+ *
+ * The bitrate limit is not here: it is part of the output's identity
+ * (`OutputSpec`), so two limits are two outputs and nothing moves a limit under
+ * one that exists.
+ *
+ * **It also holds how well its own pieces land on its own grid.** Where a piece
+ * of THIS output truly began, against where its playlist says it begins, is a
+ * fact of this output: a step that was told to put a keyframe at that instant
+ * and did not will not splice into the stream it accompanies, and a soundtrack
+ * whose grid was corrected under a run already going is that far from the
+ * picture. Neither says anything about the file. Until 2026-09-15 both were
+ * added to a tally held on the CUT TABLE — which is one per (file, grid), so a
+ * picture and the soundtrack inside the same file shared it, the second reading
+ * of one piece number was dropped as a repeat whichever output it came from,
+ * and the summary could not say which of three facts it was summarising.
+ */
+
+export class Output {
+  /** @type {{ checked: number, disagreed: number, maxDeviationSec: number, firstDisagreementIndex: number, deviations: number[], seen: Set<number> }} */
+  #tally;
+
+  /**
+   * @param {object} params
+   * @param {number} params.encodeWidth - 0 means the source's own width.
+   * @param {number} params.encodeHeight - 0 means the source's own height.
+   * @param {number} params.outputFps
+   * @param {string | null} params.softwarePreset - The speed setting, where the
+   *   encoder has a ladder and one was chosen from it.
+   * @param {boolean} params.applyTonemap
+   */
+  constructor({ encodeWidth, encodeHeight, outputFps, softwarePreset, applyTonemap }) {
+    this.encodeWidth = Number.isFinite(encodeWidth) ? encodeWidth : 0;
+    this.encodeHeight = Number.isFinite(encodeHeight) ? encodeHeight : 0;
+    this.outputFps = Number.isFinite(outputFps) && outputFps > 0 ? outputFps : 0;
+    this.softwarePreset = typeof softwarePreset === "string" ? softwarePreset : null;
+    this.applyTonemap = applyTonemap === true;
+    /**
+     * How far this output's produced pieces fell from its own published grid.
+     * Private, because `landing` below is the only honest way to read it: a
+     * caller holding the raw counters would have to know which of them are a
+     * summary and which are working state.
+     *
+     * @type {{ checked: number, disagreed: number, maxDeviationSec: number, firstDisagreementIndex: number, deviations: number[], seen: Set<number> }}
+     */
+    this.#tally = {
+      checked: 0,
+      disagreed: 0,
+      maxDeviationSec: 0,
+      firstDisagreementIndex: -1,
+      deviations: [],
+      // A piece can be produced and served again; a repeat is the same piece,
+      // not new evidence. Per OUTPUT, so one output's reading of piece #7 can
+      // no longer silence another output's reading of its own #7.
+      seen: new Set()
+    };
+  }
+
+  /**
+   * A produced piece of this output states where it truly began.
+   *
+   * @param {object} reading
+   * @param {number} reading.index
+   * @param {number} reading.deviationSec - From where this output's playlist
+   *   says that piece begins.
+   * @param {number} reading.toleranceSec - Above which the two are held to
+   *   disagree rather than to have rounded.
+   * @returns {void}
+   */
+  noteLanding({ index, deviationSec, toleranceSec }) {
+    if (!Number.isInteger(index) || !Number.isFinite(deviationSec) || this.#tally.seen.has(index)) {
+      return;
+    }
+    this.#tally.seen.add(index);
+    this.#tally.checked += 1;
+    this.#tally.deviations.push(deviationSec);
+    if (deviationSec > toleranceSec) {
+      this.#tally.disagreed += 1;
+      if (this.#tally.firstDisagreementIndex < 0) {
+        this.#tally.firstDisagreementIndex = index;
+      }
+    }
+    if (deviationSec > this.#tally.maxDeviationSec) {
+      this.#tally.maxDeviationSec = deviationSec;
+    }
+  }
+
+  /**
+   * How many distinct pieces of this output have stated where they began.
+   *
+   * Separate from `landing` because it is read on every produced piece, to
+   * decide whether the summary is due, while `landing` sorts what it summarises
+   * — which on a two-hour film is a sort per segment on the path that serves
+   * one. A count and a summary are two different costs.
+   *
+   * @returns {number}
+   */
+  get piecesLanded() {
+    return this.#tally.checked;
+  }
+
+  /**
+   * Where this output's pieces have been landing, or null while none has.
+   *
+   * @returns {{ checked: number, disagreed: number, maxDeviationSec: number, medianDeviationSec: number, firstDisagreementIndex: number } | null}
+   */
+  get landing() {
+    if (this.#tally.checked === 0) {
+      return null;
+    }
+    const sorted = [...this.#tally.deviations].sort((left, right) => left - right);
+    return {
+      checked: this.#tally.checked,
+      disagreed: this.#tally.disagreed,
+      maxDeviationSec: this.#tally.maxDeviationSec,
+      medianDeviationSec: sorted[Math.floor(sorted.length / 2)],
+      firstDisagreementIndex: this.#tally.firstDisagreementIndex
+    };
+  }
+}