@torrent-tv/proxy 2.89.7 → 2.89.8

package/services/encode/RunClock.js

@@ -1,87 +1,87 @@
-/**
- * @file Where one encoder run's time went: working, waiting for its input, or
- * stopped.
- *
- * A speed read as "film made per second of clock" measures the swarm as well
- * as the machine whenever the input runs dry: field 2026-10-01, a copy waited
- * 32.93 s and 43.91 s for two pieces and its speed read 0.21x, which the
- * forecast then carried over the whole remaining film while it charged the
- * same download separately. So the clock is split, from two facts that are
- * observed and not inferred:
- *
- * 1. the input read waited — the stream route says when it starts and stops
- *    waiting for bytes of this run's input;
- * 2. the process was stopped — the run says when it sends `SIGSTOP` and
- *    `SIGCONT`.
- *
- * Time during which either holds is idle; the rest is the run's own work. Two
- * inputs that wait at once, or a wait while the process is stopped, are idle
- * once. What is not separated is what the encoder does with bytes it already
- * holds while its read waits; that is bounded by its input buffer, which is
- * the one error this split has.
- */
-export class RunClock {
-  /** @type {() => number} */
-  #now;
-  #startedAt;
-  /** Idle causes in force now: input reads waiting, plus one while stopped. */
-  #idleCauses = 0;
-  #idleSince = 0;
-  #idleMs = 0;
-
-  /**
-   * @param {{ now?: () => number }} [options]
-   */
-  constructor({ now = Date.now } = {}) {
-    this.#now = now;
-    this.#startedAt = now();
-  }
-
-  #idleBegins() {
-    if (this.#idleCauses === 0) {
-      this.#idleSince = this.#now();
-    }
-    this.#idleCauses += 1;
-  }
-
-  #idleEnds() {
-    if (this.#idleCauses === 0) {
-      return;
-    }
-    this.#idleCauses -= 1;
-    if (this.#idleCauses === 0) {
-      this.#idleMs += this.#now() - this.#idleSince;
-    }
-  }
-
-  /** An input read of this run starts waiting for bytes. */
-  inputWaitBegins() {
-    this.#idleBegins();
-  }
-
-  /** An input read of this run has its bytes. */
-  inputWaitEnds() {
-    this.#idleEnds();
-  }
-
-  /** The process is stopped. */
-  stopped() {
-    this.#idleBegins();
-  }
-
-  /** The process runs again. */
-  continued() {
-    this.#idleEnds();
-  }
-
-  /**
-   * Milliseconds of the run's own work so far.
-   *
-   * @param {number} [at]
-   * @returns {number}
-   */
-  workingMs(at = this.#now()) {
-    const idleNow = this.#idleCauses > 0 ? at - this.#idleSince : 0;
-    return Math.max(0, at - this.#startedAt - this.#idleMs - idleNow);
-  }
-}
+/**
+ * @file Where one encoder run's time went: working, waiting for its input, or
+ * stopped.
+ *
+ * A speed read as "film made per second of clock" measures the swarm as well
+ * as the machine whenever the input runs dry: field 2026-10-01, a copy waited
+ * 32.93 s and 43.91 s for two pieces and its speed read 0.21x, which the
+ * forecast then carried over the whole remaining film while it charged the
+ * same download separately. So the clock is split, from two facts that are
+ * observed and not inferred:
+ *
+ * 1. the input read waited — the stream route says when it starts and stops
+ *    waiting for bytes of this run's input;
+ * 2. the process was stopped — the run says when it sends `SIGSTOP` and
+ *    `SIGCONT`.
+ *
+ * Time during which either holds is idle; the rest is the run's own work. Two
+ * inputs that wait at once, or a wait while the process is stopped, are idle
+ * once. What is not separated is what the encoder does with bytes it already
+ * holds while its read waits; that is bounded by its input buffer, which is
+ * the one error this split has.
+ */
+export class RunClock {
+  /** @type {() => number} */
+  #now;
+  #startedAt;
+  /** Idle causes in force now: input reads waiting, plus one while stopped. */
+  #idleCauses = 0;
+  #idleSince = 0;
+  #idleMs = 0;
+
+  /**
+   * @param {{ now?: () => number }} [options]
+   */
+  constructor({ now = Date.now } = {}) {
+    this.#now = now;
+    this.#startedAt = now();
+  }
+
+  #idleBegins() {
+    if (this.#idleCauses === 0) {
+      this.#idleSince = this.#now();
+    }
+    this.#idleCauses += 1;
+  }
+
+  #idleEnds() {
+    if (this.#idleCauses === 0) {
+      return;
+    }
+    this.#idleCauses -= 1;
+    if (this.#idleCauses === 0) {
+      this.#idleMs += this.#now() - this.#idleSince;
+    }
+  }
+
+  /** An input read of this run starts waiting for bytes. */
+  inputWaitBegins() {
+    this.#idleBegins();
+  }
+
+  /** An input read of this run has its bytes. */
+  inputWaitEnds() {
+    this.#idleEnds();
+  }
+
+  /** The process is stopped. */
+  stopped() {
+    this.#idleBegins();
+  }
+
+  /** The process runs again. */
+  continued() {
+    this.#idleEnds();
+  }
+
+  /**
+   * Milliseconds of the run's own work so far.
+   *
+   * @param {number} [at]
+   * @returns {number}
+   */
+  workingMs(at = this.#now()) {
+    const idleNow = this.#idleCauses > 0 ? at - this.#idleSince : 0;
+    return Math.max(0, at - this.#startedAt - this.#idleMs - idleNow);
+  }
+}

package/services/encode/RunProgress.js

@@ -1,79 +1,79 @@
-/**
- * @file Progress reported by one encoder run, placed on the source timeline.
- *
- * ffmpeg reports time relative to the start of each run on both the re-encode
- * and copy branches. `-output_ts_offset` and `-copyts` change muxed timestamps,
- * not the `-progress` clock. Every reading is therefore rebased by this run's
- * own start, never by an output-wide value shared with another run.
- */
-
-function parseTimestamp(value) {
-  if (typeof value !== "string" || value.length === 0) {
-    return null;
-  }
-  const parts = value.split(":");
-  if (parts.length !== 3) {
-    return null;
-  }
-  const [hours, minutes, seconds] = parts.map(Number);
-  return [hours, minutes, seconds].every(Number.isFinite)
-    ? hours * 3600 + minutes * 60 + seconds
-    : null;
-}
-
-export class RunProgress {
-  constructor({ startSeconds = 0, totalSeconds = null, now = Date.now } = {}) {
-    this.startPositionSeconds = Number.isFinite(startSeconds) ? Math.max(0, startSeconds) : 0;
-    this.processedSeconds = this.startPositionSeconds;
-    this.totalSeconds = Number.isFinite(totalSeconds) && totalSeconds > 0 ? totalSeconds : null;
-    this.percent = null;
-    this.remainingSeconds = this.totalSeconds;
-    this.updatedAt = now();
-    this.lastLoggedAt = 0;
-    this.now = now;
-    this.#derive();
-  }
-
-  note({ processedSeconds = null, outTime }) {
-    const relative = Number.isFinite(processedSeconds)
-      ? processedSeconds
-      : parseTimestamp(outTime);
-    if (relative !== null) {
-      this.processedSeconds = this.startPositionSeconds + Math.max(0, relative);
-    }
-    this.updatedAt = this.now();
-    this.#derive();
-    return this.snapshot();
-  }
-
-  shouldLog(everyMs) {
-    if (this.percent === null || this.updatedAt - this.lastLoggedAt < everyMs) {
-      return false;
-    }
-    this.lastLoggedAt = this.updatedAt;
-    return true;
-  }
-
-  snapshot() {
-    return {
-      processedSeconds: this.processedSeconds,
-      startPositionSeconds: this.startPositionSeconds,
-      totalSeconds: this.totalSeconds,
-      percent: this.percent,
-      remainingSeconds: this.remainingSeconds,
-      updatedAt: this.updatedAt
-    };
-  }
-
-  #derive() {
-    if (this.totalSeconds === null) {
-      this.percent = null;
-      this.remainingSeconds = null;
-      return;
-    }
-    const span = Math.max(1, this.totalSeconds - this.startPositionSeconds);
-    const processed = Math.max(0, this.processedSeconds - this.startPositionSeconds);
-    this.percent = Math.max(0, Math.min(100, (processed / span) * 100));
-    this.remainingSeconds = Math.max(0, this.totalSeconds - this.processedSeconds);
-  }
-}
+/**
+ * @file Progress reported by one encoder run, placed on the source timeline.
+ *
+ * ffmpeg reports time relative to the start of each run on both the re-encode
+ * and copy branches. `-output_ts_offset` and `-copyts` change muxed timestamps,
+ * not the `-progress` clock. Every reading is therefore rebased by this run's
+ * own start, never by an output-wide value shared with another run.
+ */
+
+function parseTimestamp(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+  const parts = value.split(":");
+  if (parts.length !== 3) {
+    return null;
+  }
+  const [hours, minutes, seconds] = parts.map(Number);
+  return [hours, minutes, seconds].every(Number.isFinite)
+    ? hours * 3600 + minutes * 60 + seconds
+    : null;
+}
+
+export class RunProgress {
+  constructor({ startSeconds = 0, totalSeconds = null, now = Date.now } = {}) {
+    this.startPositionSeconds = Number.isFinite(startSeconds) ? Math.max(0, startSeconds) : 0;
+    this.processedSeconds = this.startPositionSeconds;
+    this.totalSeconds = Number.isFinite(totalSeconds) && totalSeconds > 0 ? totalSeconds : null;
+    this.percent = null;
+    this.remainingSeconds = this.totalSeconds;
+    this.updatedAt = now();
+    this.lastLoggedAt = 0;
+    this.now = now;
+    this.#derive();
+  }
+
+  note({ processedSeconds = null, outTime }) {
+    const relative = Number.isFinite(processedSeconds)
+      ? processedSeconds
+      : parseTimestamp(outTime);
+    if (relative !== null) {
+      this.processedSeconds = this.startPositionSeconds + Math.max(0, relative);
+    }
+    this.updatedAt = this.now();
+    this.#derive();
+    return this.snapshot();
+  }
+
+  shouldLog(everyMs) {
+    if (this.percent === null || this.updatedAt - this.lastLoggedAt < everyMs) {
+      return false;
+    }
+    this.lastLoggedAt = this.updatedAt;
+    return true;
+  }
+
+  snapshot() {
+    return {
+      processedSeconds: this.processedSeconds,
+      startPositionSeconds: this.startPositionSeconds,
+      totalSeconds: this.totalSeconds,
+      percent: this.percent,
+      remainingSeconds: this.remainingSeconds,
+      updatedAt: this.updatedAt
+    };
+  }
+
+  #derive() {
+    if (this.totalSeconds === null) {
+      this.percent = null;
+      this.remainingSeconds = null;
+      return;
+    }
+    const span = Math.max(1, this.totalSeconds - this.startPositionSeconds);
+    const processed = Math.max(0, this.processedSeconds - this.startPositionSeconds);
+    this.percent = Math.max(0, Math.min(100, (processed / span) * 100));
+    this.remainingSeconds = Math.max(0, this.totalSeconds - this.processedSeconds);
+  }
+}

package/services/encode/SegmentDemand.js

@@ -1,95 +1,95 @@
-/**
- * @file What is wanted of one output, in ITS OWN segment numbers.
- *
- * One map per output and nothing else. The map itself is built once, per film,
- * by the layer that knows where the viewers are; this holds the copy converted
- * into an output's own numbering, because two outputs of one film are cut
- * independently — 454 pieces against 401 on the field file — so the same second
- * is a different number in each.
- *
- * **No viewer appears here.** It used to hold a window per viewer per band and
- * merge them itself, which was the priority layer's work done a second time in
- * the wrong place, and it carried the viewer's name as the key of a claim —
- * against the rule that the encoding and the viewer are not connected at all.
- * What arrives now is already merged and already anonymous.
- */
-
-export class SegmentDemand {
-  /** Output address to what is wanted of it. @type {Map<string, object[]>} */
-  #maps = new Map();
-
-  /**
-   * What is wanted of one output, replacing whatever was wanted before.
-   *
-   * An EMPTY map is a statement and is stored as one: it says nobody is coming
-   * anywhere in this output, which is what stops the encoders on it.
-   *
-   * @param {string} address
-   * @param {{ from: number, to: number, priority: number, withinSeconds: number }[]} zones
-   */
-  state(address, zones) {
-    this.#maps.set(address, Array.isArray(zones) ? zones : []);
-  }
-
-  /**
-   * An output nobody has anything to say about any more.
-   *
-   * @param {string} address
-   */
-  forget(address) {
-    this.#maps.delete(address);
-  }
-
-  /**
-   * Every output anything is wanted of.
-   *
-   * @returns {string[]}
-   */
-  addresses() {
-    return [...this.#maps.keys()];
-  }
-
-  /**
-   * What is wanted of one output.
-   *
-   * @param {string} address
-   * @returns {{ from: number, to: number, priority: number, withinSeconds: number }[]}
-   */
-  mapOn(address) {
-    return this.#maps.get(address) ?? [];
-  }
-
-  /**
-   * What the map says about one segment, and about the map it sits in.
-   *
-   * Asked by whoever MEASURES how well the map is being served: a wait means
-   * one thing at the top rank and another at the bottom, and telling them apart
-   * needs both the segment's own rank and the highest rank stated — a rank is a
-   * position in this map, not an absolute number.
-   *
-   * AND AN EMPTY MAP IS NOT AN ANSWER, which is why the top rank comes back even
-   * when the segment's own is zero. A top rank of zero says the map has not been
-   * built yet — a session created a moment ago, before the first pass — and that
-   * is a different thing from "nobody is coming". Conflated, every request
-   * behind the run reads as absent for as long as a fresh session has no map.
-   *
-   * @param {string} address
-   * @param {number} index
-   * @returns {{ rank: number, topRank: number }} Rank zero for a number in
-   *   nobody's zone, which is a statement: nothing is coming for it.
-   */
-  rankOf(address, index) {
-    const zones = this.mapOn(address);
-    let rank = 0;
-    let topRank = 0;
-    for (const zone of zones) {
-      if (zone.priority > topRank) {
-        topRank = zone.priority;
-      }
-      if (index >= zone.from && index <= zone.to && zone.priority > rank) {
-        rank = zone.priority;
-      }
-    }
-    return { rank, topRank };
-  }
-}
+/**
+ * @file What is wanted of one output, in ITS OWN segment numbers.
+ *
+ * One map per output and nothing else. The map itself is built once, per film,
+ * by the layer that knows where the viewers are; this holds the copy converted
+ * into an output's own numbering, because two outputs of one film are cut
+ * independently — 454 pieces against 401 on the field file — so the same second
+ * is a different number in each.
+ *
+ * **No viewer appears here.** It used to hold a window per viewer per band and
+ * merge them itself, which was the priority layer's work done a second time in
+ * the wrong place, and it carried the viewer's name as the key of a claim —
+ * against the rule that the encoding and the viewer are not connected at all.
+ * What arrives now is already merged and already anonymous.
+ */
+
+export class SegmentDemand {
+  /** Output address to what is wanted of it. @type {Map<string, object[]>} */
+  #maps = new Map();
+
+  /**
+   * What is wanted of one output, replacing whatever was wanted before.
+   *
+   * An EMPTY map is a statement and is stored as one: it says nobody is coming
+   * anywhere in this output, which is what stops the encoders on it.
+   *
+   * @param {string} address
+   * @param {{ from: number, to: number, priority: number, withinSeconds: number }[]} zones
+   */
+  state(address, zones) {
+    this.#maps.set(address, Array.isArray(zones) ? zones : []);
+  }
+
+  /**
+   * An output nobody has anything to say about any more.
+   *
+   * @param {string} address
+   */
+  forget(address) {
+    this.#maps.delete(address);
+  }
+
+  /**
+   * Every output anything is wanted of.
+   *
+   * @returns {string[]}
+   */
+  addresses() {
+    return [...this.#maps.keys()];
+  }
+
+  /**
+   * What is wanted of one output.
+   *
+   * @param {string} address
+   * @returns {{ from: number, to: number, priority: number, withinSeconds: number }[]}
+   */
+  mapOn(address) {
+    return this.#maps.get(address) ?? [];
+  }
+
+  /**
+   * What the map says about one segment, and about the map it sits in.
+   *
+   * Asked by whoever MEASURES how well the map is being served: a wait means
+   * one thing at the top rank and another at the bottom, and telling them apart
+   * needs both the segment's own rank and the highest rank stated — a rank is a
+   * position in this map, not an absolute number.
+   *
+   * AND AN EMPTY MAP IS NOT AN ANSWER, which is why the top rank comes back even
+   * when the segment's own is zero. A top rank of zero says the map has not been
+   * built yet — a session created a moment ago, before the first pass — and that
+   * is a different thing from "nobody is coming". Conflated, every request
+   * behind the run reads as absent for as long as a fresh session has no map.
+   *
+   * @param {string} address
+   * @param {number} index
+   * @returns {{ rank: number, topRank: number }} Rank zero for a number in
+   *   nobody's zone, which is a statement: nothing is coming for it.
+   */
+  rankOf(address, index) {
+    const zones = this.mapOn(address);
+    let rank = 0;
+    let topRank = 0;
+    for (const zone of zones) {
+      if (zone.priority > topRank) {
+        topRank = zone.priority;
+      }
+      if (index >= zone.from && index <= zone.to && zone.priority > rank) {
+        rank = zone.priority;
+      }
+    }
+    return { rank, topRank };
+  }
+}