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/test/epg_api_test.dart

@@ -1,5 +1,12 @@
+import 'dart:convert';
+
+import 'package:http/http.dart' as http;
+import 'package:http/testing.dart';
+import 'package:shelf/shelf.dart';
 import 'package:test/test.dart';
 import '../api/epg_api.dart';
+import '../models/playlist_config.dart';
+import '../services/xmltv_epg_service.dart';
 
 /// Extrait réel d'une réponse `get_simple_data_table` (panneau Xtream) :
 /// titres/descriptions en base64, horodatages epoch UTC doublés d'une chaîne
@@ -71,4 +78,144 @@ void main() {
       expect(result['programmes'], isEmpty);
     });
   });
+
+  group('handleGetEpg', () {
+    final playlist = PlaylistConfig(
+      id: 'p1',
+      name: 'Test',
+      dns: 'http://panel.example',
+      username: 'u',
+      password: 'p',
+      createdAt: DateTime(2026, 1, 1),
+    );
+
+    String xmltvDump(DateTime start, DateTime stop) {
+      String stamp(DateTime d) {
+        final u = d.toUtc();
+        String two(int v) => v.toString().padLeft(2, '0');
+        return '${u.year}${two(u.month)}${two(u.day)}'
+            '${two(u.hour)}${two(u.minute)}${two(u.second)} +0000';
+      }
+
+      return '''
+<?xml version="1.0" encoding="utf-8" ?>
+<tv>
+  <channel id="France2.fr"><display-name>FRANCE 2</display-name></channel>
+  <programme start="${stamp(start)}" stop="${stamp(stop)}" channel="France2.fr">
+    <title lang="fr">Journal de 20h</title>
+    <desc lang="fr">L'info du soir</desc>
+  </programme>
+</tv>
+''';
+    }
+
+    Request requestFor(String channelId) =>
+        Request('GET', Uri.parse('http://localhost/api/epg/$channelId'));
+
+    test('sert le guide depuis le dump XMLTV du panneau, sans appel par '
+        'chaîne', () async {
+      // Un appel `player_api` par chaîne coûte plusieurs secondes chez le
+      // fournisseur : le dump du panneau couvre toutes les chaînes d'un coup.
+      final now = DateTime.now().toUtc();
+      final actions = <String>[];
+
+      final client = MockClient((request) async {
+        final url = request.url;
+        if (url.path.endsWith('/xmltv.php')) {
+          return http.Response(
+            xmltvDump(now.subtract(const Duration(minutes: 5)),
+                now.add(const Duration(minutes: 25))),
+            200,
+          );
+        }
+        final action = url.queryParameters['action'] ?? '';
+        actions.add(action);
+        if (action == 'get_live_streams') {
+          return http.Response(
+            jsonEncode([
+              {
+                'stream_id': 845452,
+                'name': 'FRANCE 2',
+                'epg_channel_id': 'France2.fr',
+              },
+            ]),
+            200,
+          );
+        }
+        return http.Response('{}', 200);
+      });
+
+      final api = EpgApi(
+        (_) async => playlist,
+        httpClient: client,
+        panelXmltvBuilder: (config) => XmltvEpgService(
+          sourceUrls: ['${config.dns}/xmltv.php'],
+          client: client,
+        ),
+      );
+
+      final response = await api.handleGetEpg(requestFor('845452'), '845452');
+      final body = jsonDecode(await response.readAsString()) as Map;
+
+      expect(response.statusCode, 200);
+      expect((body['programmes'] as List).single['title'], 'Journal de 20h');
+      expect(response.headers['X-Epg-Source'], 'panel-xmltv');
+      // Seule la table des chaînes est interrogée : aucune action EPG.
+      expect(actions, ['get_live_streams']);
+    });
+
+    test('retombe sur player_api quand le dump ne couvre pas la chaîne',
+        () async {
+      final actions = <String>[];
+      // Heure locale volontairement : le panneau émet des horodatages sans
+      // fuseau, que le serveur relit comme de l'heure locale.
+      final future = DateTime.now().add(const Duration(minutes: 10));
+      String panelStamp(DateTime d) =>
+          d.toIso8601String().substring(0, 19).replaceFirst('T', ' ');
+
+      final client = MockClient((request) async {
+        final url = request.url;
+        if (url.path.endsWith('/xmltv.php')) {
+          return http.Response('<tv></tv>', 200);
+        }
+        final action = url.queryParameters['action'] ?? '';
+        actions.add(action);
+        if (action == 'get_live_streams') {
+          return http.Response(jsonEncode(const []), 200);
+        }
+        if (action == 'get_simple_data_table') {
+          return http.Response(
+            jsonEncode({
+              'epg_listings': [
+                {
+                  'title': base64Encode(utf8.encode('Match')),
+                  'description': '',
+                  'start': panelStamp(future),
+                  'end': panelStamp(future.add(const Duration(hours: 2))),
+                },
+              ],
+            }),
+            200,
+          );
+        }
+        return http.Response('{}', 200);
+      });
+
+      final api = EpgApi(
+        (_) async => playlist,
+        httpClient: client,
+        panelXmltvBuilder: (config) => XmltvEpgService(
+          sourceUrls: ['${config.dns}/xmltv.php'],
+          client: client,
+        ),
+      );
+
+      final response = await api.handleGetEpg(requestFor('999'), '999');
+      final body = jsonDecode(await response.readAsString()) as Map;
+
+      expect((body['programmes'] as List).single['title'], 'Match');
+      expect(response.headers['X-Epg-Source'], 'xtream');
+      expect(actions, contains('get_simple_data_table'));
+    });
+  });
 }