@torrent-tv/proxy 2.87.10 → 2.87.11

package/utils/parse-range.js

@@ -1,25 +1,25 @@
-/**
- * @file HTTP Range header parser.
- */
-
-/**
- * Parse an HTTP `Range` header value into a byte range clamped to the file size.
- * Only the `bytes=<start>-<end>` form is supported.
- *
- * @param {string | undefined} rangeHeader - Value of the `Range` request header.
- * @param {number} fileLength              - Total file size in bytes.
- * @returns {{ start: number, end: number } | null} Byte range, or `null` if the
- *   header is absent, malformed, or uses an unsupported unit.
- */
-export function parseRange(rangeHeader, fileLength) {
-  if (!rangeHeader || !rangeHeader.startsWith("bytes=")) {
-    return null;
-  }
-  const [startRaw, endRaw] = rangeHeader.slice("bytes=".length).split("-");
-  const start = startRaw.length > 0 ? Number(startRaw) : 0;
-  const end = endRaw && endRaw.length > 0 ? Number(endRaw) : fileLength - 1;
-  if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start) {
-    return null;
-  }
-  return { start, end: Math.min(end, fileLength - 1) };
-}
+/**
+ * @file HTTP Range header parser.
+ */
+
+/**
+ * Parse an HTTP `Range` header value into a byte range clamped to the file size.
+ * Only the `bytes=<start>-<end>` form is supported.
+ *
+ * @param {string | undefined} rangeHeader - Value of the `Range` request header.
+ * @param {number} fileLength              - Total file size in bytes.
+ * @returns {{ start: number, end: number } | null} Byte range, or `null` if the
+ *   header is absent, malformed, or uses an unsupported unit.
+ */
+export function parseRange(rangeHeader, fileLength) {
+  if (!rangeHeader || !rangeHeader.startsWith("bytes=")) {
+    return null;
+  }
+  const [startRaw, endRaw] = rangeHeader.slice("bytes=".length).split("-");
+  const start = startRaw.length > 0 ? Number(startRaw) : 0;
+  const end = endRaw && endRaw.length > 0 ? Number(endRaw) : fileLength - 1;
+  if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start) {
+    return null;
+  }
+  return { start, end: Math.min(end, fileLength - 1) };
+}

package/utils/perf.js

@@ -1,59 +1,59 @@
-/**
- * @file Runtime performance instrumentation.
- *
- * Exists because a field seek took minutes and every explanation offered for it
- * — encoder too slow, torrent too slow, channel too slow, event loop starved —
- * was a guess. The numbers that would have settled it were not being recorded.
- * This records them.
- *
- * Two things are measured:
- *
- *  - **Event loop delay** (`perf_hooks.monitorEventLoopDelay`). If synchronous
- *    work (torrent piece hashing, large buffer handling) blocks the loop, every
- *    read and every send waits behind it, and the symptom looks exactly like a
- *    slow network. The histogram distinguishes the two beyond argument.
- *  - **Named operation timings**, so a slow transfer can be attributed to the
- *    step that actually consumed the time rather than to the whole.
- *
- * Deliberately cheap: a histogram sampled every 20 ms, and plain arithmetic per
- * operation. No trace files, no profiler — `--trace-events-enabled` or
- * `--cpu-prof` remain available for a deeper look when these figures point
- * somewhere specific.
- */
-
-import { monitorEventLoopDelay } from "node:perf_hooks";
-
-const NANOSECONDS_PER_MILLISECOND = 1e6;
-// Sampling interval for the loop-delay histogram. 20 ms is fine enough to catch
-// the stalls that matter (tens of ms and up) without measurable overhead.
-const LOOP_SAMPLE_INTERVAL_MS = 20;
-
-const loopDelay = monitorEventLoopDelay({ resolution: LOOP_SAMPLE_INTERVAL_MS });
-loopDelay.enable();
-
-/**
- * Event-loop delay since the last {@link resetEventLoopDelay}, in milliseconds.
- *
- * `mean` is the everyday cost; `max` and `p99` are what a single blocking spell
- * does to whatever was waiting. A transfer that looks network-bound but shows a
- * large `max` here was not network-bound at all.
- *
- * @returns {{ meanMs: number, p99Ms: number, maxMs: number }}
- */
-export function eventLoopDelay() {
-  return {
-    meanMs: loopDelay.mean / NANOSECONDS_PER_MILLISECOND,
-    p99Ms: loopDelay.percentile(99) / NANOSECONDS_PER_MILLISECOND,
-    maxMs: loopDelay.max / NANOSECONDS_PER_MILLISECOND
-  };
-}
-
-/**
- * Start a fresh measurement window for the loop-delay histogram, so a reported
- * figure describes one operation rather than the process's whole lifetime.
- *
- * @returns {void}
- */
-export function resetEventLoopDelay() {
-  loopDelay.reset();
-}
+/**
+ * @file Runtime performance instrumentation.
+ *
+ * Exists because a field seek took minutes and every explanation offered for it
+ * — encoder too slow, torrent too slow, channel too slow, event loop starved —
+ * was a guess. The numbers that would have settled it were not being recorded.
+ * This records them.
+ *
+ * Two things are measured:
+ *
+ *  - **Event loop delay** (`perf_hooks.monitorEventLoopDelay`). If synchronous
+ *    work (torrent piece hashing, large buffer handling) blocks the loop, every
+ *    read and every send waits behind it, and the symptom looks exactly like a
+ *    slow network. The histogram distinguishes the two beyond argument.
+ *  - **Named operation timings**, so a slow transfer can be attributed to the
+ *    step that actually consumed the time rather than to the whole.
+ *
+ * Deliberately cheap: a histogram sampled every 20 ms, and plain arithmetic per
+ * operation. No trace files, no profiler — `--trace-events-enabled` or
+ * `--cpu-prof` remain available for a deeper look when these figures point
+ * somewhere specific.
+ */
+
+import { monitorEventLoopDelay } from "node:perf_hooks";
+
+const NANOSECONDS_PER_MILLISECOND = 1e6;
+// Sampling interval for the loop-delay histogram. 20 ms is fine enough to catch
+// the stalls that matter (tens of ms and up) without measurable overhead.
+const LOOP_SAMPLE_INTERVAL_MS = 20;
+
+const loopDelay = monitorEventLoopDelay({ resolution: LOOP_SAMPLE_INTERVAL_MS });
+loopDelay.enable();
+
+/**
+ * Event-loop delay since the last {@link resetEventLoopDelay}, in milliseconds.
+ *
+ * `mean` is the everyday cost; `max` and `p99` are what a single blocking spell
+ * does to whatever was waiting. A transfer that looks network-bound but shows a
+ * large `max` here was not network-bound at all.
+ *
+ * @returns {{ meanMs: number, p99Ms: number, maxMs: number }}
+ */
+export function eventLoopDelay() {
+  return {
+    meanMs: loopDelay.mean / NANOSECONDS_PER_MILLISECOND,
+    p99Ms: loopDelay.percentile(99) / NANOSECONDS_PER_MILLISECOND,
+    maxMs: loopDelay.max / NANOSECONDS_PER_MILLISECOND
+  };
+}
+
+/**
+ * Start a fresh measurement window for the loop-delay histogram, so a reported
+ * figure describes one operation rather than the process's whole lifetime.
+ *
+ * @returns {void}
+ */
+export function resetEventLoopDelay() {
+  loopDelay.reset();
+}

package/utils/torrent-source-key.js

@@ -1,38 +1,38 @@
-/**
- * @file Canonical identity for a torrent source: its own infohash.
- *
- * A magnet URI and a `.torrent` file for the same content are different
- * bytes, so naming a source by a hash of those bytes gave the same film two
- * unrelated keys — one from a magnet, another from a `.torrent` — sharing
- * neither the swarm, nor a cache, nor any work already done. Measured
- * 2026-08-19: `a518ff46…` and `7ab2fb5d…` for one infohash `11f09299…`.
- *
- * The infohash is the one thing both forms carry for the same content, and
- * both carry it synchronously — a magnet's `btih` needs no network, and a
- * `.torrent` file's SHA-1 of its own `info` dictionary needs no metadata
- * exchange either. `parse-torrent` reads either form without touching the
- * network.
- */
-
-import parseTorrent from "parse-torrent";
-
-/**
- * @param {"magnet" | "torrent"} sourceType
- * @param {string} source - Magnet URI, or base64-encoded `.torrent` bytes.
- * @returns {Promise<string>} `torrent:<infohash>` — identical for a magnet
- *   and a `.torrent` file describing the same content.
- */
-export async function deriveSourceKey(sourceType, source) {
-  const torrentId = sourceType === "torrent" ? Buffer.from(source, "base64") : source;
-  let parsed;
-  try {
-    parsed = await parseTorrent(torrentId);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Could not read an infohash from this ${sourceType}: ${message}`);
-  }
-  if (!parsed?.infoHash) {
-    throw new Error(`Could not read an infohash from this ${sourceType}.`);
-  }
-  return `torrent:${parsed.infoHash}`;
-}
+/**
+ * @file Canonical identity for a torrent source: its own infohash.
+ *
+ * A magnet URI and a `.torrent` file for the same content are different
+ * bytes, so naming a source by a hash of those bytes gave the same film two
+ * unrelated keys — one from a magnet, another from a `.torrent` — sharing
+ * neither the swarm, nor a cache, nor any work already done. Measured
+ * 2026-08-19: `a518ff46…` and `7ab2fb5d…` for one infohash `11f09299…`.
+ *
+ * The infohash is the one thing both forms carry for the same content, and
+ * both carry it synchronously — a magnet's `btih` needs no network, and a
+ * `.torrent` file's SHA-1 of its own `info` dictionary needs no metadata
+ * exchange either. `parse-torrent` reads either form without touching the
+ * network.
+ */
+
+import parseTorrent from "parse-torrent";
+
+/**
+ * @param {"magnet" | "torrent"} sourceType
+ * @param {string} source - Magnet URI, or base64-encoded `.torrent` bytes.
+ * @returns {Promise<string>} `torrent:<infohash>` — identical for a magnet
+ *   and a `.torrent` file describing the same content.
+ */
+export async function deriveSourceKey(sourceType, source) {
+  const torrentId = sourceType === "torrent" ? Buffer.from(source, "base64") : source;
+  let parsed;
+  try {
+    parsed = await parseTorrent(torrentId);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Could not read an infohash from this ${sourceType}: ${message}`);
+  }
+  if (!parsed?.infoHash) {
+    throw new Error(`Could not read an infohash from this ${sourceType}.`);
+  }
+  return `torrent:${parsed.infoHash}`;
+}