Logos, guide TV et fluidité : couper le flot de requêtes mortes

Logos absents : l'hébergeur des picons du fournisseur répond 503 sur
tout, y compris sa racine (serveur en maintenance). Le proxy relayait
ce 503 au navigateur, qui redemandait chaque logo à chaque affichage de
la grille — des centaines de requêtes sortantes mortes par seconde.
- Un statut >= 400 sur une image rend désormais un pixel transparent
  avec `Cache-Control: max-age=600`, au lieu de propager l'erreur
- Après trois échecs consécutifs, l'hôte est marqué hors service cinq
  minutes : plus aucun appel sortant, réponse servie localement
- Le corps d'erreur amont est drainé, sinon la connexion restait
  ouverte jusqu'au timeout

Guide TV très lent (4 à 8 s par chaîne dans les logs) : `player_api`
demande un appel par chaîne, et le panneau met ~4 s à répondre — une
grille de trente chaînes dépassait la minute.
- Le dump `xmltv.php` du panneau passe en premier : une requête couvre
  toutes les chaînes, réutilisée trois heures
- L'interrogation chaîne par chaîne reste le repli, puis la source
  XMLTV externe
- Une source XMLTV en échec n'est plus retéléchargée à chaque
  consultation : quinze minutes de recul
- Index borné à 48 h en avant : un dump national couvre sept jours pour
  un millier de chaînes, soit des centaines de Mo pour un guide qui
  n'affiche que le programme courant

Lecture saccadée : le relais FFmpeg -> navigateur de `/turbo.ts` ne
transmettait pas la pause du client à la source. Un lecteur plus lent
que le flux laissait FFmpeg produire à pleine vitesse et le serveur
empilait les paquets en mémoire, d'où la dérive derrière le direct. La
contre-pression est maintenant propagée (`pipeWithBackpressure`).

Le serveur tourne sur un seul isolate : le flot de requêtes mortes et
les attentes EPG de plusieurs secondes partageaient la boucle
d'événements avec les paquets vidéo.

Tests ajoutés : cache d'échecs par hôte, contre-pression du relais,
priorité des sources EPG, recul après échec XMLTV, horizon d'index.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

bin/api/proxy_handler.dart

@@ -1,12 +1,48 @@
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
+import 'dart:typed_data';
 import 'package:shelf/shelf.dart';
 import 'package:http/http.dart' as http;
 import '../database/database.dart';
 import '../middleware/auth_middleware.dart';
 import '../models/playlist_config.dart';
 import '../utils/log_redactor.dart';
+import 'asset_failure_cache.dart';
+
+/// PNG transparent 1×1, servi à la place d'un logo introuvable.
+final Uint8List _placeholderPixel = base64Decode(
+  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=',
+);
+
+/// L'URL désigne-t-elle une image ou un logo ?
+///
+/// Ces URL échappent à l'allowlist de domaine (les revendeurs hébergent leurs
+/// picons ailleurs que le panneau) et méritent un repli visuel plutôt qu'une
+/// erreur propagée au navigateur.
+bool _isStaticAssetUrl(Uri url) =>
+    url.path.endsWith('.png') ||
+    url.path.endsWith('.jpg') ||
+    url.path.endsWith('.jpeg') ||
+    url.path.endsWith('.gif') ||
+    url.path.endsWith('.webp') ||
+    url.path.endsWith('.ico') ||
+    url.path.contains('/picons/') ||
+    url.path.contains('/logos/');
+
+/// Réponse de repli pour une image indisponible.
+///
+/// Le `max-age` est essentiel : sans lui le navigateur redemande le logo à
+/// chaque affichage de la grille et le flot de requêtes mortes reprend
+/// immédiatement, coupure serveur ou pas.
+Response _placeholderImageResponse() => Response.ok(
+      _placeholderPixel,
+      headers: {
+        'content-type': 'image/png',
+        'cache-control': 'public, max-age=600',
+        'access-control-allow-origin': '*',
+      },
+    );
 
 /// Returns true when [host] must never be proxied (loopback, private LAN,
 /// link-local/cloud-metadata ranges) — SSRF protection for asset URLs that
@@ -39,6 +75,9 @@ class ProxyHandler {
   final Map<String, (PlaylistConfig, DateTime)> _playlistCache = {};
   static const _cacheDuration = Duration(minutes: 5);
 
+  /// Hôtes d'images réputés hors service (voir [AssetFailureCache]).
+  final AssetFailureCache _assetFailures = AssetFailureCache();
+
   static const _allowedHeaders = [
     'content-type',
     'content-range',
@@ -141,14 +180,14 @@ class ProxyHandler {
 
         // SSRF Protection - but allow images/static assets from any host
         // Xtream providers often use separate CDN servers for picons/images
-        final isStaticAsset = targetUrl.path.endsWith('.png') ||
-            targetUrl.path.endsWith('.jpg') ||
-            targetUrl.path.endsWith('.jpeg') ||
-            targetUrl.path.endsWith('.gif') ||
-            targetUrl.path.endsWith('.webp') ||
-            targetUrl.path.endsWith('.ico') ||
-            targetUrl.path.contains('/picons/') ||
-            targetUrl.path.contains('/logos/');
+        final isStaticAsset = _isStaticAssetUrl(targetUrl);
+
+        // Hôte d'images déjà constaté mort : on sert le pixel tout de suite.
+        // Aucun appel sortant, aucune entrée de log — c'est précisément le
+        // flot qu'on cherche à éteindre.
+        if (isStaticAsset && _assetFailures.isDown(targetUrl.host)) {
+          return _placeholderImageResponse();
+        }
 
         String? allowedHost;
         if (!isStaticAsset) {
@@ -251,6 +290,23 @@ class ProxyHandler {
             }
           }
 
+          // Une image en erreur n'a rien à transmettre au navigateur : le
+          // relais du 503 déclenchait un nouveau cycle de requêtes à chaque
+          // rendu. On sert le pixel, mis en cache, et on compte l'échec.
+          if (isStaticAsset) {
+            if (response.statusCode >= 400) {
+              // Compté sur l'hôte demandé, pas sur la cible finale d'une
+              // redirection : c'est cette clé-là que consulte le garde-fou
+              // en tête de requête.
+              _assetFailures.recordFailure(targetUrl.host);
+              // Le corps d'erreur doit être consommé, sinon la connexion
+              // reste ouverte jusqu'au timeout.
+              unawaited(response.stream.drain<void>().catchError((_) {}));
+              return _placeholderImageResponse();
+            }
+            _assetFailures.recordSuccess(targetUrl.host);
+          }
+
           // Build response headers from source response
           final responseHeaders = <String, String>{
             'access-control-allow-origin': '*',
@@ -283,14 +339,9 @@ class ProxyHandler {
         );
 
         // Return transparent 1x1 pixel image fallback for images
-        if (targetUrl?.path.endsWith('.png') == true ||
-            targetUrl?.path.endsWith('.jpg') == true) {
-          return Response.ok(
-            base64Decode(
-              'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=',
-            ),
-            headers: {'content-type': 'image/png'},
-          );
+        if (targetUrl != null && _isStaticAssetUrl(targetUrl)) {
+          _assetFailures.recordFailure(targetUrl.host);
+          return _placeholderImageResponse();
         }
 
         return Response.internalServerError(