Lecture TV : plus de saut de 20 s après un silence du panneau

Télémétrie (session de 25 min avec la réserve de 25 s) : un silence du
panneau a été absorbé sans coupure (avance 27 → 14,7 s), mais à la
reprise le panneau renvoie d'un coup tout le retard. L'avance dépassait
alors le seuil de rattrapage (45 s) et le lecteur sautait 20 s de
programme — deux fois en une minute.

Saut seulement au-delà de 90 s de retard ; liveSync (x1,1 au-delà de
35 s) résorbe l'excédent en douceur. Vidéo déjà vue purgée plus tôt
(30 s) pour rester sous le quota du SourceBuffer.

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

README.md

@@ -37,7 +37,7 @@ Au premier démarrage, un compte `admin` est créé avec un **mot de passe aléa
 | `RECORDINGS_PATH` | `./data/recordings` | Dossier hôte des enregistrements |
 | `TZ` | `Europe/Paris` | Fuseau du conteneur (les enregistrements sont stockés en UTC) |
 | `MAX_CONCURRENT_RECORDINGS` | `2` | Enregistrements simultanés |
-| `EPG_XMLTV_URLS` | dump FR | Sources XMLTV de repli (vide = aucun appel sortant) |
+| `EPG_XMLTV_URLS` | dumps FR, CH, BE | Sources XMLTV de repli (vide = aucun appel sortant) |
 | `NVIDIA_GPU` | `false` | Transcodage NVENC |
 | `ADMIN_INITIAL_PASSWORD` | *(généré)* | Mot de passe initial du compte admin |
 | `MIN_FREE_DISK_MB` | `500` | Espace libre minimal pour démarrer une capture |

bin/api/epg_api.dart

@@ -1,4 +1,5 @@
 import 'dart:convert';
+import 'dart:isolate';
 import 'package:shelf/shelf.dart';
 import 'package:http/http.dart' as http;
 import '../models/playlist_config.dart';
@@ -97,10 +98,15 @@ class EpgApi {
       // Le dump du panneau passe devant : une requête couvre toutes les
       // chaînes, là où `player_api` en demande une par chaîne, à plusieurs
       // secondes pièce.
+      //
+      // Le dump externe passe ensuite AVANT l'interrogation chaîne par
+      // chaîne : il est déjà indexé en mémoire (réponse instantanée), alors
+      // que `player_api` coûte plusieurs secondes par chaîne et échouait en
+      // prod — ce qui laissait toute la grille sans guide.
       final sources = <(String, Future<List<Map<String, dynamic>>> Function())>[
         ('panel-xmltv', () => _panelProgrammes(playlist, channelId)),
-        ('xtream', () => _xtreamProgrammes(playlist, channelId)),
         ('xmltv', () => _xmltvProgrammes(playlist, channelId)),
+        ('xtream', () => _xtreamProgrammes(playlist, channelId)),
       ];
 
       var epgData = <String, dynamic>{
@@ -133,10 +139,13 @@ class EpgApi {
 
       final jsonStr = json.encode(epgData);
 
-      // Mettre en cache 30 minutes
+      // 30 min pour un guide trouvé ; 5 min seulement pour un guide vide,
+      // qui vient souvent d'une source momentanément indisponible et ne
+      // doit pas priver la chaîne de guide pendant une demi-heure.
       _cache[cacheKey] = _CacheEntry(
         data: jsonStr,
-        expiresAt: DateTime.now().add(const Duration(minutes: 30)),
+        expiresAt: DateTime.now()
+            .add(Duration(minutes: found ? 30 : 5)),
       );
 
       return Response.ok(
@@ -191,8 +200,19 @@ class EpgApi {
           '&password=${playlist.password}'
           '&action=$action&stream_id=$channelId';
 
-      final response =
-          await _http.get(Uri.parse(url)).timeout(const Duration(seconds: 60));
+      final http.Response response;
+      try {
+        response = await _http
+            .get(Uri.parse(url))
+            .timeout(const Duration(seconds: 20));
+      } catch (e) {
+        // Délai dépassé, connexion coupée… : une source parmi d'autres, pas
+        // une raison de répondre 500 (ce qui privait la chaîne des sources
+        // suivantes). L'exception recopie l'URL, identifiants compris.
+        print('[EpgApi] player_api $action indisponible pour $channelId : '
+            '${LogRedactor.redactUrl('$e')}');
+        continue;
+      }
       if (response.statusCode != 200) continue;
 
       Map<String, dynamic> parsed;
@@ -267,41 +287,88 @@ class EpgApi {
     }
   }
 
+  /// `stream_id` → (`epg_channel_id`, nom) depuis la réponse
+  /// `get_live_streams`.
+  static (Map<String, String>, Map<String, String>) _parseChannelTable(
+    String body,
+  ) {
+    final epgIds = <String, String>{};
+    final names = <String, String>{};
+    final decoded = json.decode(body);
+    if (decoded is List) {
+      for (final item in decoded) {
+        if (item is! Map) continue;
+        final streamId = item['stream_id']?.toString();
+        if (streamId == null || streamId.isEmpty) continue;
+        final epgId = item['epg_channel_id']?.toString();
+        if (epgId != null && epgId.isNotEmpty) epgIds[streamId] = epgId;
+        final name = item['name']?.toString();
+        if (name != null && name.isNotEmpty) names[streamId] = name;
+      }
+    }
+    return (epgIds, names);
+  }
+
+  /// Téléchargements de la table des chaînes en cours, par compte.
+  final Map<String, Future<_ChannelMap>> _channelMapsInFlight = {};
+
   /// Table des chaînes du compte, rafraîchie toutes les 6 heures.
-  Future<_ChannelMap> _channelMapFor(PlaylistConfig playlist) async {
+  ///
+  /// Les requêtes simultanées partagent un seul téléchargement : la grille
+  /// demande le guide de 30 chaînes d'un coup, et chacune déclenchait sinon
+  /// son propre `get_live_streams` (7 Mo en prod).
+  Future<_ChannelMap> _channelMapFor(PlaylistConfig playlist) {
     final key = '${playlist.dns}|${playlist.username}';
     final cached = _channelMaps[key];
     if (cached != null && DateTime.now().isBefore(cached.expiresAt)) {
-      return cached;
+      return Future.value(cached);
     }
+    return _channelMapsInFlight[key] ??=
+        _loadChannelMap(playlist, key).whenComplete(() {
+      _channelMapsInFlight.remove(key);
+    });
+  }
 
+  Future<_ChannelMap> _loadChannelMap(
+    PlaylistConfig playlist,
+    String key,
+  ) async {
     final url = '${playlist.dns}/player_api.php'
         '?username=${playlist.username}&password=${playlist.password}'
         '&action=get_live_streams';
-    final response =
-        await _http.get(Uri.parse(url)).timeout(const Duration(seconds: 90));
+    http.Response? response;
+    try {
+      response =
+          await _http.get(Uri.parse(url)).timeout(const Duration(seconds: 90));
+    } catch (e) {
+      print('[EpgApi] table des chaînes indisponible : '
+          '${LogRedactor.redactUrl('$e')}');
+    }
 
-    final epgIds = <String, String>{};
-    final names = <String, String>{};
-    if (response.statusCode == 200) {
-      final decoded = json.decode(response.body);
-      if (decoded is List) {
-        for (final item in decoded) {
-          if (item is! Map) continue;
-          final streamId = item['stream_id']?.toString();
-          if (streamId == null || streamId.isEmpty) continue;
-          final epgId = item['epg_channel_id']?.toString();
-          if (epgId != null && epgId.isNotEmpty) epgIds[streamId] = epgId;
-          final name = item['name']?.toString();
-          if (name != null && name.isNotEmpty) names[streamId] = name;
-        }
+    var epgIds = <String, String>{};
+    var names = <String, String>{};
+    if (response != null && response.statusCode == 200) {
+      // Décodage dans un isolate : 7 Mo de JSON sur la boucle principale la
+      // gelaient, et le relais turbo.ts cessait d'émettre pendant ce temps.
+      // UTF-8 explicite : sans charset annoncé, `response.body` peut décoder
+      // en latin-1 et abîmer les noms (« Chérie », « ◉ »), donc leur
+      // correspondance avec le guide.
+      final body = utf8.decode(response.bodyBytes, allowMalformed: true);
+      try {
+        (epgIds, names) = await Isolate.run(() => _parseChannelTable(body));
+      } catch (e) {
+        print('[EpgApi] table des chaînes illisible : ${e.runtimeType}');
       }
     }
 
+    // Une table vide (panneau en échec) n'est gardée que 2 minutes : la
+    // garder 6 h privait TOUTES les chaînes du repli XMLTV pendant 6 h.
     final map = _ChannelMap(
       epgIds: epgIds,
       names: names,
-      expiresAt: DateTime.now().add(const Duration(hours: 6)),
+      expiresAt: DateTime.now().add(
+        names.isEmpty ? const Duration(minutes: 2) : const Duration(hours: 6),
+      ),
     );
     _channelMaps[key] = map;
     return map;

bin/api/player_log.dart

@@ -0,0 +1,70 @@
+import 'dart:convert';
+
+import 'package:shelf/shelf.dart';
+
+/// Journal des incidents de lecture remontés par le lecteur web.
+///
+/// POURQUOI : les freezes (image et son figés puis reprise) se produisent
+/// chez l'utilisateur, dans son navigateur ; le serveur n'en voit rien. Le
+/// lecteur envoie ici chaque coupure, erreur, recréation et saut, et le
+/// serveur les écrit dans `docker logs` (`[Player] …`) : on sait alors si un
+/// freeze vient d'un buffer à sec, d'une erreur du démuxeur ou d'une
+/// relance du flux.
+///
+/// Entrée non fiable : seuls des champs connus, courts et typés passent.
+
+const _events = {
+  'start', 'first_frame', 'stall', 'seek', 'mpegts_error', 'recreate',
+  'fallback_hls', 'hls_error', 'profile', 'error_shown', 'heartbeat',
+};
+
+const _numericFields = {
+  't', 'ms', 'buffer', 'pos', 'from', 'to', 'stalls', 'stallMs', 'seeks',
+  'errors', 'rate',
+};
+
+const _textFields = {'session', 'ch', 'mode', 'profile', 'detail'};
+
+/// Ligne de journal pour l'événement [raw], ou null s'il est invalide.
+String? formatPlayerEvent(Object? raw) {
+  if (raw is! Map) return null;
+  final event = raw['event'];
+  if (event is! String || !_events.contains(event)) return null;
+
+  final parts = <String>[event];
+  for (final key in _textFields) {
+    final value = raw[key];
+    if (value is String && value.isNotEmpty) {
+      // Ni espace, ni retour ligne, ni URL : jamais d'injection de faux
+      // journaux, jamais d'identifiants recopiés depuis une URL d'erreur.
+      final safe = value
+          .replaceAll(RegExp(r'https?://\S+'), '<url>')
+          .replaceAll(RegExp(r'[^\w.\-:/<>]'), '_');
+      parts.add('$key=${safe.length > 60 ? safe.substring(0, 60) : safe}');
+    }
+  }
+  for (final key in _numericFields) {
+    final value = raw[key];
+    if (value is num && value.isFinite) {
+      parts.add('$key=${value is int ? value : value.toStringAsFixed(1)}');
+    }
+  }
+  return '[Player] ${parts.join(' ')}';
+}
+
+Future<Response> handlePlayerLog(Request request) async {
+  final body = await request.readAsString();
+  if (body.length > 4096) return Response(413);
+  Object? decoded;
+  try {
+    decoded = jsonDecode(body);
+  } catch (_) {
+    return Response.badRequest();
+  }
+  final events = decoded is List ? decoded.take(20) : [decoded];
+  for (final event in events) {
+    final line = formatPlayerEvent(event);
+    if (line != null) print(line);
+  }
+  return Response(204);
+}

bin/api/streaming_handler.dart

@@ -48,17 +48,31 @@ Future<void> _claimUpstream(PlaylistConfig playlist, String id) async {
   await Future<void>.delayed(const Duration(seconds: 1));
 }
 
+/// Délai sans consommation au-delà duquel un flux est tenu pour orphelin.
+///
+/// Un lecteur HLS redemande sa playlist toutes les 2 à 4 s ; un flux
+/// `turbo.ts` reçoit au moins une rafale toutes les ~7 s même sur un panneau
+/// qui livre par à-coups. 15 s laissent une marge à ces deux rythmes.
+const _viewerGrace = Duration(seconds: 15);
+
 /// Inscrit [process] comme connexion amont de [playlist] tant qu'il vit.
+///
+/// [lastActivity] : dernier signe de vie du spectateur ; la connexion n'est
+/// coupée pour en ouvrir une autre que s'il remonte à plus de
+/// [_viewerGrace].
 void _registerUpstream(
   PlaylistConfig playlist,
   String id,
   Process process, {
   required void Function() release,
+  required DateTime Function() lastActivity,
 }) {
   final token = _upstreamSlots.register(
     id: id,
     account: accountKeyOf(playlist),
     release: release,
+    isActive: () =>
+        DateTime.now().difference(lastActivity()) < _viewerGrace,
   );
   process.exitCode.then((_) => _upstreamSlots.unregister(id, token: token));
 }
@@ -274,6 +288,8 @@ Future<_SessionAttempt> _runSession({
       id,
       session.process,
       release: () => sessionManager.killSession(id),
+      // Touchée à chaque requête de playlist ou de segment.
+      lastActivity: () => session.lastAccess,
     );
   }
   final outcome =
@@ -580,11 +596,16 @@ Handler createLiveStreamHandler(
       return Response(503, body: 'FFmpeg start failed');
     }
 
+    // Dernier octet remis au client : un lecteur en vie en reçoit à chaque
+    // rafale ; un client parti (zap mal détecté derrière le proxy) n'en
+    // reçoit plus, la contre-pression bloquant FFmpeg.
+    var lastDelivered = DateTime.now();
     _registerUpstream(
       playlist,
       upstreamId,
       process,
       release: () => process.kill(ProcessSignal.sigterm),
+      lastActivity: () => lastDelivered,
     );
 
     // Journaliser les erreurs FFmpeg (redactées) sans bloquer le flux.
@@ -602,7 +623,10 @@ Handler createLiveStreamHandler(
     final body = pipeWithBackpressure(
       process.stdout,
       onStop: () => process.kill(ProcessSignal.sigterm),
-    );
+    ).map((chunk) {
+      lastDelivered = DateTime.now();
+      return chunk;
+    });
 
     return Response(
       200,

bin/api/upstream_probe.dart

@@ -0,0 +1,133 @@
+import 'dart:async';
+import 'dart:convert';
+
+import 'package:http/http.dart' as http;
+
+import '../models/playlist_config.dart';
+
+/// Diagnostic admin : chronomètre l'ouverture d'une chaîne chez le
+/// fournisseur, en `.ts` et en `.m3u8`.
+///
+/// POURQUOI : ~4,3 s des ~4,6 s d'un zap se passent avant le premier octet
+/// du panneau (mesuré en prod). Le panneau autorise aussi le HLS ; reste à
+/// savoir lequel des deux formats démarre le plus vite, et où part le temps
+/// (redirection, en-têtes, premier octet). Les identifiants n'apparaissent
+/// jamais dans la réponse : seuls l'hôte et les durées sont rendus.
+Future<Map<String, Object?>> probeUpstream(
+  PlaylistConfig playlist,
+  String streamId, {
+  http.Client? client,
+}) async {
+  final c = client ?? http.Client();
+  try {
+    final base = '${playlist.dns}/live/${playlist.username}/'
+        '${playlist.password}/$streamId';
+    final ts = await _probeStream(c, Uri.parse('$base.ts'));
+    // Laisser le panneau libérer la connexion (comptes à une connexion).
+    await Future<void>.delayed(const Duration(seconds: 2));
+    final hls = await _probeHls(c, Uri.parse('$base.m3u8'));
+    return {'stream': streamId, 'ts': ts, 'm3u8': hls};
+  } finally {
+    if (client == null) c.close();
+  }
+}
+
+/// Suit les redirections à la main pour chronométrer chaque saut.
+Future<({http.StreamedResponse? response, List<Map<String, Object?>> hops, Uri url})>
+    _open(http.Client c, Uri url, Stopwatch sw) async {
+  final hops = <Map<String, Object?>>[];
+  var current = url;
+  for (var i = 0; i < 5; i++) {
+    final request = http.Request('GET', current)
+      ..followRedirects = false
+      ..headers['User-Agent'] = 'VLC/3.0.18 LibVLC/3.0.18';
+    final response =
+        await c.send(request).timeout(const Duration(seconds: 20));
+    hops.add({
+      'host': current.host,
+      'status': response.statusCode,
+      'headersMs': sw.elapsedMilliseconds,
+    });
+    final location = response.headers['location'];
+    if (const {301, 302, 303, 307, 308}.contains(response.statusCode) &&
+        location != null) {
+      await response.stream.drain<void>().catchError((_) {});
+      current = current.resolve(location);
+      continue;
+    }
+    return (response: response, hops: hops, url: current);
+  }
+  return (response: null, hops: hops, url: current);
+}
+
+Future<Map<String, Object?>> _probeStream(http.Client c, Uri url) async {
+  final sw = Stopwatch()..start();
+  try {
+    final opened = await _open(c, url, sw);
+    final response = opened.response;
+    if (response == null || response.statusCode != 200) {
+      return {'hops': opened.hops, 'error': 'status ${response?.statusCode}'};
+    }
+    var bytes = 0;
+    int? firstByteMs;
+    final sub = response.stream.listen(null);
+    final done = Completer<void>();
+    sub.onData((chunk) {
+      firstByteMs ??= sw.elapsedMilliseconds;
+      bytes += chunk.length;
+      // 1 Mo suffit à voir le premier envoi (préchargement du panneau).
+      if (bytes > 1000000 && !done.isCompleted) done.complete();
+    });
+    sub.onDone(() {
+      if (!done.isCompleted) done.complete();
+    });
+    await done.future.timeout(const Duration(seconds: 15), onTimeout: () {});
+    await sub.cancel();
+    return {
+      'hops': opened.hops,
+      'firstByteMs': firstByteMs,
+      'firstMegabyteMs': bytes > 1000000 ? sw.elapsedMilliseconds : null,
+    };
+  } catch (e) {
+    return {'error': e.runtimeType.toString(), 'afterMs': sw.elapsedMilliseconds};
+  }
+}
+
+Future<Map<String, Object?>> _probeHls(http.Client c, Uri url) async {
+  final sw = Stopwatch()..start();
+  try {
+    final opened = await _open(c, url, sw);
+    final response = opened.response;
+    if (response == null || response.statusCode != 200) {
+      return {'hops': opened.hops, 'error': 'status ${response?.statusCode}'};
+    }
+    final body = await response.stream.bytesToString();
+    final playlistMs = sw.elapsedMilliseconds;
+    final lines = const LineSplitter().convert(body);
+    final segments =
+        lines.where((l) => l.isNotEmpty && !l.startsWith('#')).toList();
+    final target = lines
+        .firstWhere((l) => l.startsWith('#EXT-X-TARGETDURATION'),
+            orElse: () => '')
+        .split(':')
+        .last;
+    if (segments.isEmpty) {
+      return {'hops': opened.hops, 'playlistMs': playlistMs, 'segments': 0};
+    }
+    // Un lecteur démarre près du direct : chronométrer l'avant-dernier.
+    final pick = segments.length >= 2
+        ? segments[segments.length - 2]
+        : segments.last;
+    final segment = await _probeStream(c, opened.url.resolve(pick));
+    return {
+      'hops': opened.hops,
+      'playlistMs': playlistMs,
+      'segments': segments.length,
+      'targetDuration': target,
+      'segment': segment,
+      'segmentStartedAtMs': playlistMs,
+    };
+  } catch (e) {
+    return {'error': e.runtimeType.toString(), 'afterMs': sw.elapsedMilliseconds};
+  }
+}

bin/server.dart

@@ -28,6 +28,8 @@ import 'middleware/security_middleware.dart';
 import 'services/cleanup_service.dart';
 import 'services/recording_scheduler.dart';
 import 'utils/asset_versioning.dart';
+import 'api/upstream_probe.dart';
+import 'api/player_log.dart';
 
 void main(List<String> args) async {
   // Parse command line arguments
@@ -131,7 +133,9 @@ void main(List<String> args) async {
   // Source XMLTV de repli. Vider EPG_XMLTV_URLS désactive tout appel sortant :
   // l'EPG se limite alors au panneau de l'abonné.
   final xmltvUrls = (Platform.environment['EPG_XMLTV_URLS'] ??
-          'https://epgshare01.online/epgshare01/epg_ripper_FR1.xml.gz')
+          'https://epgshare01.online/epgshare01/epg_ripper_FR1.xml.gz,'
+          'https://epgshare01.online/epgshare01/epg_ripper_CH1.xml.gz,'
+          'https://epgshare01.online/epgshare01/epg_ripper_BE2.xml.gz')
       .split(',')
       .map((u) => u.trim())
       .where((u) => u.isNotEmpty)
@@ -218,6 +222,14 @@ void main(List<String> args) async {
           .addMiddleware(authMiddleware(db))
           .addHandler(logoApi.handle),
     )
+    // Incidents de lecture remontés par le lecteur web (freezes, erreurs),
+    // écrits dans les logs pour le diagnostic.
+    ..post(
+      '/api/player-log',
+      const Pipeline()
+          .addMiddleware(authMiddleware(db))
+          .addHandler(handlePlayerLog),
+    )
     // EPG - guide TV (auth required)
     ..mount(
       '/api/epg',
@@ -269,6 +281,29 @@ void main(List<String> args) async {
         );
       });
 
+      // GET /api/admin/upstream-probe?stream=<id> : chronomètre l'ouverture
+      // d'une chaîne chez le fournisseur en .ts et en .m3u8 (diagnostic du
+      // délai de zap ; aucun identifiant dans la réponse).
+      router.get('/upstream-probe', (Request req) async {
+        final user = req.context['user'] as User?;
+        if (user == null || !user.isAdmin) {
+          return Response.forbidden(
+            jsonEncode({'error': 'Admin access required'}),
+          );
+        }
+        final streamId = req.url.queryParameters['stream'] ?? '';
+        if (!RegExp(r'^[0-9]+$').hasMatch(streamId)) {
+          return Response.badRequest(body: 'stream=<id numérique> requis');
+        }
+        final playlist = await getPlaylist(req);
+        if (playlist == null) return Response.forbidden('No playlist');
+        final result = await probeUpstream(playlist, streamId);
+        return Response.ok(
+          jsonEncode(result),
+          headers: {'content-type': 'application/json'},
+        );
+      });
+
       return router(request);
     }),
   );

bin/services/upstream_slots.dart

@@ -15,10 +15,18 @@ import '../models/playlist_config.dart';
 /// le panneau répondait `HTTP 551` ou ne répondait pas (timeout), d'où les
 /// films « indisponibles » et les zaps qui échouent.
 ///
-/// Règle : le dernier flux demandé gagne. Avant d'ouvrir une nouvelle
-/// connexion amont, on coupe les plus anciennes du même compte jusqu'à lui
-/// faire de la place. Les enregistrements n'y sont pas inscrits : ils ne
-/// sont jamais coupés.
+/// Règle : avant d'ouvrir une nouvelle connexion amont, on coupe les
+/// connexions ORPHELINES du même compte (plus personne ne les consomme),
+/// les plus anciennes d'abord, jusqu'à lui faire de la place.
+///
+/// Un flux encore regardé n'est jamais coupé. Une première version coupait
+/// sans distinction (« le dernier gagne ») : deux lecteurs ouverts sur un
+/// compte à une connexion se coupaient alors en boucle, chacun relançant
+/// aussitôt — plus aucune image nulle part (constaté en prod). Le second
+/// lecteur est désormais refusé par le panneau, comme avant, et le premier
+/// continue.
+///
+/// Les enregistrements n'y sont pas inscrits : ils ne sont jamais coupés.
 class UpstreamSlots {
   final DateTime Function() _now;
   final Map<String, _Slot> _slots = {};
@@ -31,13 +39,17 @@ class UpstreamSlots {
   /// Renvoie un jeton à repasser à [unregister] : une session relancée sous
   /// le même identifiant ne doit pas être désinscrite par la fin de
   /// l'ancien processus.
+  ///
+  /// [isActive] : vrai tant qu'un spectateur consomme le flux. Une
+  /// connexion active n'est jamais coupée par [makeRoom].
   int register({
     required String id,
     required String account,
     required void Function() release,
+    bool Function()? isActive,
   }) {
     final token = ++_nextToken;
-    _slots[id] = _Slot(token, account, _now(), release);
+    _slots[id] = _Slot(token, account, _now(), release, isActive);
     return token;
   }
 
@@ -60,14 +72,16 @@ class UpstreamSlots {
     if (max <= 0) return const [];
     final others = _slots.entries
         .where((e) => e.value.account == account && e.key != keep)
-        .toList()
-      ..sort((a, b) => a.value.since.compareTo(b.value.since));
+        .toList();
 
     final excess = others.length - (max - 1);
     if (excess <= 0) return const [];
 
+    final orphans = others.where((e) => !e.value.active).toList()
+      ..sort((a, b) => a.value.since.compareTo(b.value.since));
+
     final freed = <String>[];
-    for (final entry in others.take(excess)) {
+    for (final entry in orphans.take(excess)) {
       _slots.remove(entry.key);
       try {
         entry.value.release();
@@ -83,7 +97,16 @@ class _Slot {
   final String account;
   final DateTime since;
   final void Function() release;
-  _Slot(this.token, this.account, this.since, this.release);
+  final bool Function()? isActive;
+  _Slot(this.token, this.account, this.since, this.release, this.isActive);
+
+  bool get active {
+    try {
+      return isActive?.call() ?? false;
+    } catch (_) {
+      return false;
+    }
+  }
 }
 
 /// Clé de compte : deux playlists sur les mêmes identifiants partagent le
@@ -101,13 +124,21 @@ int? parseMaxConnections(Object? json) {
 }
 
 /// Quota de connexions par compte, lu chez le fournisseur et mis en cache.
+///
+/// Ne fait JAMAIS attendre un flux : `player_api.php` met jusqu'à 4 s à
+/// répondre (mesuré en prod), délai qui s'ajoutait au démarrage du premier
+/// flux puis de chaque flux suivant l'expiration du cache. La valeur connue
+/// (même périmée), sinon [fallback], est rendue immédiatement ; la lecture
+/// chez le panneau se fait en arrière-plan. Sans risque : le quota ne sert
+/// qu'à décider quels flux ORPHELINS couper.
 class AccountLimits {
   final Duration ttl;
   final Future<int?> Function(PlaylistConfig) _fetch;
   final Map<String, ({int max, DateTime at})> _cache = {};
+  final Set<String> _refreshing = {};
 
-  /// Valeur retenue quand le panneau ne répond pas : un seul flux, le cas
-  /// de loin le plus courant chez les fournisseurs Xtream.
+  /// Valeur retenue tant que le panneau n'a pas répondu : un seul flux, le
+  /// cas de loin le plus courant chez les fournisseurs Xtream.
   static const fallback = 1;
 
   AccountLimits({
@@ -118,19 +149,20 @@ class AccountLimits {
   Future<int> maxFor(PlaylistConfig p) async {
     final key = accountKeyOf(p);
     final cached = _cache[key];
-    if (cached != null && DateTime.now().difference(cached.at) < ttl) {
-      return cached.max;
+    if (cached == null || DateTime.now().difference(cached.at) >= ttl) {
+      _refresh(key, p);
     }
-    int? value;
-    try {
-      value = await _fetch(p);
-    } catch (_) {
-      value = null;
-    }
-    // Un échec n'est pas mis en cache longtemps : on réessaiera au prochain
-    // flux plutôt que de rester 10 min sur une valeur devinée.
-    if (value != null) _cache[key] = (max: value, at: DateTime.now());
-    return value ?? fallback;
+    return cached?.max ?? fallback;
+  }
+
+  void _refresh(String key, PlaylistConfig p) {
+    if (!_refreshing.add(key)) return; // une seule lecture à la fois
+    Future<int?>.sync(() => _fetch(p))
+        .then<int?>((v) => v, onError: (Object _) => null)
+        .then((value) {
+      // Un échec n'est pas mis en cache : on réessaiera au prochain flux.
+      if (value != null) _cache[key] = (max: value, at: DateTime.now());
+    }).whenComplete(() => _refreshing.remove(key));
   }
 
   static Future<int?> _fetchFromPanel(PlaylistConfig p) async {

bin/services/xmltv_epg_service.dart

@@ -82,8 +82,39 @@ class XmltvEpgService {
     String? displayName,
   }) async {
     await ensureFresh();
-    for (final candidate in [channelId, displayName]) {
-      final key = normalizeKey(candidate);
+    final direct = _lookup(channelId, displayName);
+    if (direct.isNotEmpty) return direct;
+
+    // Chaîne décalée sans guide propre (« TF1 +1 » absent des dumps) : le
+    // guide de la chaîne principale, une heure plus tard, est exact.
+    if (displayName != null && _plusOne.hasMatch(displayName)) {
+      final base = displayName.replaceAll(_plusOne, ' ');
+      final hits = _lookup(null, base);
+      return [
+        for (final p in hits)
+          XmltvProgramme(
+            title: p.title,
+            description: p.description,
+            start: p.start.add(const Duration(hours: 1)),
+            stop: p.stop.add(const Duration(hours: 1)),
+          ),
+      ];
+    }
+    return const [];
+  }
+
+  static final _plusOne = RegExp(r'\+\s*1(?![0-9])');
+
+  List<XmltvProgramme> _lookup(String? channelId, String? displayName) {
+    final keys = [
+      normalizeKey(channelId),
+      if (displayName != null) ...nameKeys(displayName),
+      // Clés souples en dernier recours, dans leur propre espace de noms.
+      _looseIndexKey(looseKey(channelId)),
+      if (displayName != null)
+        _looseIndexKey(looseKey(cleanChannelName(displayName).name)),
+    ];
+    for (final key in keys) {
       if (key.isEmpty) continue;
       final hit = _index[key];
       if (hit != null && hit.isNotEmpty) return hit;
@@ -91,6 +122,110 @@ class XmltvEpgService {
     return const [];
   }
 
+  static String _looseIndexKey(String loose) => loose.isEmpty ? '' : '~$loose';
+
+  /// Jetons sans valeur distinctive pour reconnaître une chaîne.
+  static const _looseNoise = {
+    'channel', 'tv', 'hd', 'fhd', 'uhd', 'sd', '4k', 'hevc',
+  };
+
+  /// Codes pays en fin d'identifiant XMLTV (`TF1.fr`, `RTS1.ch`).
+  static const _countryCodes = {
+    'fr', 'be', 'ch', 'lu', 'mc', 'ca', 'uk', 'us', 'es', 'it', 'de', 'pt',
+    'nl',
+  };
+
+  /// Clé « souple » : sans code pays final ni mots génériques
+  /// (« AB3.Channel.fr » et « AB3 » → `ab3`).
+  ///
+  /// Servie dans un espace de noms à part, consultée en tout dernier : elle
+  /// rattrape les variantes d'écriture sans fausser les correspondances
+  /// exactes.
+  static String looseKey(String? raw) {
+    if (raw == null) return '';
+    final folded = StringBuffer();
+    for (final rune in raw.toLowerCase().runes) {
+      final char = String.fromCharCode(rune);
+      folded.write(_accents[char] ?? char);
+    }
+    final tokens = folded
+        .toString()
+        .split(RegExp(r'[^a-z0-9]+'))
+        .where((t) => t.isNotEmpty)
+        .toList();
+    if (tokens.length > 1 && _countryCodes.contains(tokens.last)) {
+      tokens.removeLast();
+    }
+    tokens.removeWhere(_looseNoise.contains);
+    return tokens.join();
+  }
+
+  /// Préfixe pays des noms de panneau : `FR - `, `FR: `, `|FR| `, `[FR] `…
+  static final _countryPrefix = RegExp(
+    r'^\s*[\|\[\(]?\s*([A-Za-z]{2,3})\s*[\|\]\)]?\s*[-:|]\s*|^\s*[\|\[\(]\s*([A-Za-z]{2,3})\s*[\|\]\)]\s*',
+  );
+
+  /// Marqueurs de qualité ou de source en fin de nom, sans rapport avec la
+  /// chaîne elle-même.
+  static final _qualitySuffix = RegExp(
+    r'(\s+|^)(fhd|uhd|hd|sd|hq|lq|4k|8k|hevc|h\.?265|h\.?264|1080p?|720p?|'
+    r'50fps|60fps|backup|raw|vip|multi|\(backup\)|\(multi\))\s*$',
+    caseSensitive: false,
+  );
+
+  /// Clés candidates pour retrouver une chaîne du panneau par son nom.
+  ///
+  /// POURQUOI : en prod, 59 % des chaînes françaises n'ont pas
+  /// d'`epg_channel_id`. Leur nom brut (« FR - TF1 FHD ◉ » → `frtf1fhd`) ne
+  /// correspond à aucune entrée XMLTV (`TF1.fr`, « TF1 »). On retire le
+  /// préfixe pays, les marqueurs de qualité et les symboles, puis on tente
+  /// aussi la forme `nom.pays` qu'utilisent les dumps publics.
+  ///
+  /// Le décalage horaire (« +1 ») est conservé : TF1 +1 n'a pas le guide
+  /// de TF1.
+  static List<String> nameKeys(String name) {
+    final keys = <String>[normalizeKey(name)];
+    final cleaned = cleanChannelName(name);
+    final country = cleaned.country;
+    final base = normalizeKey(cleaned.name);
+    if (base.isNotEmpty) {
+      keys.add(base);
+      keys.add('$base${country ?? 'fr'}');
+    }
+    return keys.where((k) => k.isNotEmpty).toSet().toList();
+  }
+
+  /// Abréviations du panneau pour les chaînes publiques (« F3 ALPES »), là
+  /// où les dumps écrivent `France.3.-.Alpes.fr`.
+  static final _franceAbbrev = RegExp(r'^F\s?([2-5])\b', caseSensitive: false);
+
+  /// Nom de chaîne débarrassé du préfixe pays, des symboles et des
+  /// marqueurs de qualité ; [country] = code pays du préfixe, s'il y en a.
+  static ({String name, String? country}) cleanChannelName(String raw) {
+    var cleaned = raw;
+    String? country;
+    final prefix = _countryPrefix.firstMatch(cleaned);
+    if (prefix != null) {
+      country = (prefix.group(1) ?? prefix.group(2))?.toLowerCase();
+      cleaned = cleaned.substring(prefix.end);
+    }
+    // Symboles décoratifs (◉, ᴴᴰ, ★…) : tout ce qui n'est ni lettre, ni
+    // chiffre, ni ponctuation utile.
+    cleaned = cleaned
+        .replaceAll(RegExp(r'[^\p{L}\p{N}\s+.&\-()]', unicode: true), ' ')
+        .trim();
+    String previous;
+    do {
+      previous = cleaned;
+      cleaned = cleaned.replaceFirst(_qualitySuffix, '').trim();
+    } while (cleaned != previous && cleaned.isNotEmpty);
+    cleaned = cleaned.replaceFirstMapped(
+      _franceAbbrev,
+      (m) => 'France ${m[1]}',
+    );
+    return (name: cleaned, country: country);
+  }
+
   /// Recharge l'index s'il est absent ou périmé. Les appels concurrents
   /// partagent le même téléchargement.
   Future<void> ensureFresh() {
@@ -212,10 +347,12 @@ class XmltvEpgService {
     final limit = DateTime.now().toUtc().add(horizon);
     final byChannel = <String, List<XmltvProgramme>>{};
 
-    // Alias : plusieurs dumps déclarent <channel id="X"> avec un
-    // <display-name> différent de l'identifiant. On indexe les deux pour
-    // maximiser les correspondances.
+    // Alias : plusieurs dumps déclarent <channel id="X"> avec un ou plusieurs
+    // <display-name> différents de l'identifiant (« TF1 HD », « TF1 »). On
+    // les indexe TOUS : seul le premier l'était, et c'était souvent la
+    // variante la moins proche du nom annoncé par le panneau.
     final aliases = <String, String>{};
+    final displayNames = <String>[];
 
     String? channelId;
     String? programmeChannel;
@@ -232,6 +369,7 @@ class XmltvEpgService {
           case 'channel':
             channelId = _attr(event, 'id');
             displayName.clear();
+            displayNames.clear();
           case 'programme':
             programmeChannel = _attr(event, 'channel');
             start = parseXmltvDate(_attr(event, 'start'));
@@ -254,15 +392,27 @@ class XmltvEpgService {
           case 'desc':
             desc.write(text);
           case 'display-name':
-            if (displayName.isEmpty) displayName.write(text);
+            displayName.write(text);
         }
       } else if (event is XmlEndElementEvent) {
         switch (event.name) {
+          case 'display-name':
+            displayNames.add(displayName.toString());
+            displayName.clear();
           case 'channel':
             final id = normalizeKey(channelId);
-            final name = normalizeKey(displayName.toString());
-            if (id.isNotEmpty && name.isNotEmpty && id != name) {
-              aliases[name] = id;
+            for (final raw in displayNames) {
+              final name = normalizeKey(raw);
+              if (id.isNotEmpty && name.isNotEmpty && id != name) {
+                aliases.putIfAbsent(name, () => id);
+              }
+            }
+            // Clés souples (espace de noms « ~ ») : premier arrivé gagne.
+            if (id.isNotEmpty) {
+              for (final raw in [channelId, ...displayNames]) {
+                final loose = _looseIndexKey(looseKey(raw));
+                if (loose.isNotEmpty) aliases.putIfAbsent(loose, () => id);
+              }
             }
             channelId = null;
           case 'programme':

bin/test/epg_api_test.dart

@@ -217,5 +217,113 @@ void main() {
       expect(response.headers['X-Epg-Source'], 'xtream');
       expect(actions, contains('get_simple_data_table'));
     });
+
+    // Dump externe couvrant TF1, et panneau dont le xmltv.php est vide.
+    String externalDump() {
+      final now = DateTime.now().toUtc();
+      return xmltvDump(now, now.add(const Duration(hours: 1)))
+          .replaceAll('France2.fr', 'TF1.fr')
+          .replaceAll('FRANCE 2', 'TF1');
+    }
+
+    EpgApi apiWith(http.Client client) => EpgApi(
+          (_) async => playlist,
+          httpClient: client,
+          xmltv: XmltvEpgService(
+            sourceUrls: const ['http://ext.example/epg.xml'],
+            client: client,
+          ),
+          panelXmltvBuilder: (config) => XmltvEpgService(
+            sourceUrls: ['${config.dns}/xmltv.php'],
+            client: client,
+          ),
+        );
+
+    test('un panneau qui plante ne prive plus la chaîne du dump externe',
+        () async {
+      // Constaté en prod : chaque /api/epg répondait 500 en 4 s, le guide
+      // externe (qui couvrait pourtant la chaîne) n'étant jamais consulté.
+      final client = MockClient((request) async {
+        final url = request.url;
+        if (url.host == 'ext.example') return http.Response(externalDump(), 200);
+        if (url.path.endsWith('/xmltv.php')) return http.Response('<tv></tv>', 200);
+        final action = url.queryParameters['action'] ?? '';
+        if (action == 'get_live_streams') {
+          // Octets UTF-8 et JSON sans charset annoncé, comme le panneau réel.
+          return http.Response.bytes(
+            utf8.encode(jsonEncode([
+              {'stream_id': 1, 'name': 'FR - TF1 FHD ◉', 'epg_channel_id': ''},
+            ])),
+            200,
+            headers: {'content-type': 'application/json'},
+          );
+        }
+        throw http.ClientException('Connection closed', url);
+      });
+
+      final response = await apiWith(client).handleGetEpg(requestFor('1'), '1');
+      final body = jsonDecode(await response.readAsString()) as Map;
+
+      expect(response.statusCode, 200);
+      expect(response.headers['X-Epg-Source'], 'xmltv');
+      expect((body['programmes'] as List).single['title'], 'Journal de 20h');
+    });
+
+    test('le dump externe passe avant l\'appel lent chaîne par chaîne',
+        () async {
+      final actions = <String>[];
+      final client = MockClient((request) async {
+        final url = request.url;
+        if (url.host == 'ext.example') return http.Response(externalDump(), 200);
+        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([
+              {'stream_id': 1, 'name': 'TF1', 'epg_channel_id': 'TF1.fr'},
+            ]),
+            200,
+          );
+        }
+        return http.Response('{}', 200);
+      });
+
+      final response = await apiWith(client).handleGetEpg(requestFor('1'), '1');
+      expect(response.headers['X-Epg-Source'], 'xmltv');
+      expect(actions, isNot(contains('get_simple_data_table')));
+    });
+
+    test('la grille entière partage un seul téléchargement de la table',
+        () async {
+      // 30 tuiles demandent leur guide d'un coup : sans mutualisation, autant
+      // de `get_live_streams` (7 Mo en prod) partaient en parallèle.
+      var liveStreamsCalls = 0;
+      final client = MockClient((request) async {
+        final url = request.url;
+        if (url.host == 'ext.example') return http.Response(externalDump(), 200);
+        if (url.path.endsWith('/xmltv.php')) return http.Response('<tv></tv>', 200);
+        final action = url.queryParameters['action'] ?? '';
+        if (action == 'get_live_streams') {
+          liveStreamsCalls++;
+          await Future<void>.delayed(const Duration(milliseconds: 50));
+          return http.Response(
+            jsonEncode([
+              for (var i = 1; i <= 5; i++)
+                {'stream_id': i, 'name': 'TF1', 'epg_channel_id': 'TF1.fr'},
+            ]),
+            200,
+          );
+        }
+        return http.Response('{}', 200);
+      });
+
+      final api = apiWith(client);
+      final responses = await Future.wait([
+        for (var i = 1; i <= 5; i++) api.handleGetEpg(requestFor('$i'), '$i'),
+      ]);
+      expect(responses.every((r) => r.statusCode == 200), isTrue);
+      expect(liveStreamsCalls, 1);
+    });
   });
 }

bin/test/player_log_test.dart

@@ -0,0 +1,47 @@
+import 'package:test/test.dart';
+import '../api/player_log.dart';
+
+void main() {
+  group('formatPlayerEvent', () {
+    test('écrit une coupure avec sa durée et le buffer', () {
+      expect(
+        formatPlayerEvent({
+          'event': 'stall',
+          'session': 'ab12',
+          'ch': '554034',
+          'ms': 5230,
+          'buffer': 0.04,
+        }),
+        '[Player] stall session=ab12 ch=554034 ms=5230 buffer=0.0',
+      );
+    });
+
+    test('refuse un événement inconnu ou un payload invalide', () {
+      expect(formatPlayerEvent({'event': 'rm -rf'}), isNull);
+      expect(formatPlayerEvent('stall'), isNull);
+      expect(formatPlayerEvent(null), isNull);
+    });
+
+    test('pas d\'injection de lignes ni d\'URL (identifiants Xtream)', () {
+      final line = formatPlayerEvent({
+        'event': 'mpegts_error',
+        'detail': 'NetworkError http://panel/live/user/pass/1.ts\n[Player] faux',
+      })!;
+      expect(line, isNot(contains('\n')));
+      expect(line, isNot(contains('user/pass')));
+      expect(line, contains('<url>'));
+    });
+
+    test('ignore les champs inattendus et les nombres non finis', () {
+      final line = formatPlayerEvent({
+        'event': 'seek',
+        'from': 10,
+        'to': double.infinity,
+        'cookie': 'secret',
+      })!;
+      expect(line, contains('from=10'));
+      expect(line, isNot(contains('to=')));
+      expect(line, isNot(contains('secret')));
+    });
+  });
+}

bin/test/upstream_probe_test.dart

@@ -0,0 +1,62 @@
+import 'dart:convert';
+
+import 'package:http/http.dart' as http;
+import 'package:http/testing.dart';
+import 'package:test/test.dart';
+
+import '../api/upstream_probe.dart';
+import '../models/playlist_config.dart';
+
+void main() {
+  final playlist = PlaylistConfig(
+    id: 'p',
+    name: 'n',
+    dns: 'http://panel.test',
+    username: 'secretuser',
+    password: 'secretpass',
+    createdAt: DateTime(2026),
+  );
+
+  // Panneau simulé : redirige vers un serveur de diffusion avec jeton.
+  final client = MockClient.streaming((request, _) async {
+    final path = request.url.path;
+    if (request.url.host == 'panel.test') {
+      return http.StreamedResponse(
+        const Stream.empty(),
+        302,
+        headers: {
+          'location': 'http://lb.test$path?token=secrettoken',
+        },
+      );
+    }
+    if (path.endsWith('.m3u8')) {
+      return http.StreamedResponse(
+        Stream.value(utf8.encode(
+          '#EXTM3U\n#EXT-X-TARGETDURATION:6\n#EXTINF:6,\nseg1.ts\n'
+          '#EXTINF:6,\nseg2.ts\n',
+        )),
+        200,
+      );
+    }
+    return http.StreamedResponse(Stream.value(List.filled(2000, 0x47)), 200);
+  });
+
+  test('chronomètre .ts et .m3u8 en suivant les redirections', () async {
+    final result = await probeUpstream(playlist, '123', client: client);
+    final ts = result['ts'] as Map;
+    expect((ts['hops'] as List).map((h) => (h as Map)['status']), [302, 200]);
+    expect(ts['firstByteMs'], isNotNull);
+
+    final hls = result['m3u8'] as Map;
+    expect(hls['segments'], 2);
+    expect(hls['targetDuration'], '6');
+    expect((hls['segment'] as Map)['firstByteMs'], isNotNull);
+  });
+
+  test('aucun identifiant ni jeton dans la réponse', () async {
+    final json = jsonEncode(await probeUpstream(playlist, '123', client: client));
+    expect(json, isNot(contains('secretuser')));
+    expect(json, isNot(contains('secretpass')));
+    expect(json, isNot(contains('secrettoken')));
+  });
+}

bin/test/upstream_slots_test.dart

@@ -1,4 +1,7 @@
+import 'dart:async';
+
 import 'package:test/test.dart';
+import '../models/playlist_config.dart';
 import '../services/upstream_slots.dart';
 
 void main() {
@@ -53,12 +56,81 @@ void main() {
       expect(slots.countFor('acc'), 1);
     });
 
+    test('un flux encore regardé n\'est jamais coupé (pas de ping-pong entre deux lecteurs)', () {
+      slots.register(
+        id: 'watched',
+        account: 'acc',
+        release: () => released.add('watched'),
+        isActive: () => true,
+      );
+      expect(slots.makeRoom('acc', max: 1, keep: 'new'), isEmpty);
+      expect(released, isEmpty);
+      expect(slots.countFor('acc'), 1);
+    });
+
+    test('seuls les orphelins partent, même plus récents qu\'un flux regardé', () {
+      slots.register(
+        id: 'watched',
+        account: 'acc',
+        release: () => released.add('watched'),
+        isActive: () => true,
+      );
+      add('orphan', 'acc');
+      expect(slots.makeRoom('acc', max: 1, keep: 'new'), ['orphan']);
+      expect(released, ['orphan']);
+    });
+
     test('quota inconnu ou nul : rien n\'est coupé', () {
       add('a', 'acc');
       expect(slots.makeRoom('acc', max: 0, keep: 'new'), isEmpty);
     });
   });
 
+  group('AccountLimits', () {
+    PlaylistConfig playlist() => PlaylistConfig(
+          id: 'p',
+          name: 'n',
+          dns: 'http://panel.test',
+          username: 'u',
+          password: 'x',
+          createdAt: DateTime(2026),
+        );
+
+    test('ne fait jamais attendre un flux : repli immédiat, valeur réelle ensuite', () async {
+      final pending = Completer<int?>();
+      final limits = AccountLimits(fetch: (_) => pending.future);
+
+      // Le panneau répond lentement (4 s mesurées en prod) : le premier flux
+      // part tout de suite sur la valeur de repli.
+      expect(await limits.maxFor(playlist()), AccountLimits.fallback);
+
+      pending.complete(3);
+      await Future<void>.delayed(Duration.zero);
+      expect(await limits.maxFor(playlist()), 3);
+    });
+
+    test('valeur périmée servie pendant le rafraîchissement', () async {
+      var calls = 0;
+      final limits = AccountLimits(
+        ttl: Duration.zero,
+        fetch: (_) async => ++calls == 1 ? 2 : 5,
+      );
+      await limits.maxFor(playlist());
+      await Future<void>.delayed(Duration.zero);
+      // Périmée (ttl nul) : la valeur connue sort sans attendre la nouvelle.
+      expect(await limits.maxFor(playlist()), 2);
+      await Future<void>.delayed(Duration.zero);
+      expect(await limits.maxFor(playlist()), 5);
+    });
+
+    test('panneau en échec : repli, sans exception', () async {
+      final limits = AccountLimits(fetch: (_) async => throw Exception('down'));
+      expect(await limits.maxFor(playlist()), AccountLimits.fallback);
+      await Future<void>.delayed(Duration.zero);
+      expect(await limits.maxFor(playlist()), AccountLimits.fallback);
+    });
+  });
+
   group('parseMaxConnections', () {
     test('lit la valeur texte renvoyée par player_api', () {
       expect(

bin/test/xmltv_epg_test.dart

@@ -1,4 +1,5 @@
 import 'dart:async';
+import 'dart:convert';
 
 import 'package:http/http.dart' as http;
 import 'package:http/testing.dart';
@@ -28,6 +29,13 @@ String _fixture(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';
+}
+
 void main() {
   final service = XmltvEpgService(sourceUrls: const []);
 
@@ -51,6 +59,117 @@ void main() {
     });
   });
 
+  group('nameKeys', () {
+    // Noms réels du panneau (prod) : 59 % des chaînes françaises n'ont pas
+    // d'epg_channel_id, seul leur nom permet de retrouver le guide.
+    test('retire le préfixe pays et les marqueurs de qualité', () {
+      expect(XmltvEpgService.nameKeys('FR - TF1 FHD ◉'), contains('tf1'));
+      expect(XmltvEpgService.nameKeys('FR - FRANCE 4 FHD'), contains('france4'));
+      expect(XmltvEpgService.nameKeys('|FR| M6 HD'), contains('m6'));
+      expect(XmltvEpgService.nameKeys('[FR] Arte UHD 4K'), contains('arte'));
+      expect(XmltvEpgService.nameKeys('FR: RMC Story HEVC'), contains('rmcstory'));
+    });
+
+    test('propose aussi la forme identifiant « nom.pays »', () {
+      // Les dumps publics identifient souvent la chaîne par `TF1.fr`.
+      expect(XmltvEpgService.nameKeys('FR - TF1 FHD'), contains('tf1fr'));
+    });
+
+    test('garde la variante décalée distincte de la chaîne principale', () {
+      expect(XmltvEpgService.nameKeys('FR - TF1 +1 FHD'), isNot(contains('tf1')));
+    });
+
+    test('ne réduit pas un nom court à rien', () {
+      expect(XmltvEpgService.nameKeys('M6'), contains('m6'));
+      expect(XmltvEpgService.nameKeys('HD'), isNot(contains('')));
+    });
+  });
+
+  group('correspondances élargies (chaînes vides mesurées en prod)', () {
+    XmltvEpgService serviceWith(String dump) => XmltvEpgService(
+          sourceUrls: const ['http://ext/epg.xml'],
+          client: MockClient((_) async => http.Response.bytes(
+                // Octets UTF-8 : les ids réels portent des accents.
+                const Utf8Encoder().convert(dump),
+                200,
+              )),
+        );
+
+    String channel(String id, String name, String title, DateTime start) => '''
+  <channel id="$id"><display-name>$name</display-name></channel>
+  <programme start="${_stamp(start)}" stop="${_stamp(start.add(const Duration(hours: 1)))}" channel="$id"><title>$title</title></programme>''';
+
+    test('« F3 ALPES » du panneau trouve France.3.-.Alpes.fr', () async {
+      final now = DateTime.now().toUtc();
+      final svc = serviceWith('<tv>${channel('France.3.-.Alpes.fr', 'France 3 Alpes', 'JT Alpes', now)}</tv>');
+      final hits = await svc.programmesFor(null, displayName: 'FR - F3 ALPES HD');
+      expect(hits.single.title, 'JT Alpes');
+    });
+
+    test('« AB3 » trouve AB3.Channel.fr (clé souple)', () async {
+      final now = DateTime.now().toUtc();
+      final svc = serviceWith('<tv>${channel('AB3.Channel.fr', 'AB3 Channel', 'Série', now)}</tv>');
+      final hits = await svc.programmesFor('AB3.fr', displayName: 'FR - AB3 FHD');
+      expect(hits.single.title, 'Série');
+    });
+
+    test('« TF1 +1 » reprend le guide de TF1 décalé d\'une heure', () async {
+      final now = DateTime.now().toUtc();
+      final svc = serviceWith('<tv>${channel('TF1.fr', 'TF1', 'Le 13h', now)}</tv>');
+      final hits = await svc.programmesFor(null, displayName: 'FR - TF1 +1 FHD');
+      expect(hits.single.title, 'Le 13h');
+      expect(hits.single.start, now.add(const Duration(hours: 1)).copyWith(microsecond: 0, millisecond: 0));
+    });
+
+    test('une chaîne +1 qui a son propre guide le garde', () async {
+      final now = DateTime.now().toUtc();
+      final svc = serviceWith('<tv>'
+          '${channel('Boomerang.fr', 'Boomerang', 'Normal', now)}'
+          '${channel('Boomerang.+1.fr', 'Boomerang +1', 'Décalé', now)}</tv>');
+      final hits = await svc.programmesFor(null, displayName: 'FR - BOOMERANG +1');
+      expect(hits.single.title, 'Décalé');
+    });
+  });
+
+  group('programmesFor par nom', () {
+    test('trouve le guide d\'une chaîne sans epg_channel_id par son nom nettoyé',
+        () async {
+      final now = DateTime.now().toUtc();
+      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';
+      }
+
+      final dump = '''
+<tv>
+  <channel id="TF1.fr"><display-name>TF1 HD</display-name><display-name>TF1</display-name></channel>
+  <programme start="${stamp(now)}" stop="${stamp(now.add(const Duration(hours: 1)))}" channel="TF1.fr">
+    <title>Le 13h</title>
+  </programme>
+</tv>
+''';
+      final svc = XmltvEpgService(
+        sourceUrls: const ['http://ext/epg.xml'],
+        client: MockClient((_) async => http.Response(dump, 200)),
+      );
+      final hits = await svc.programmesFor(null, displayName: 'FR - TF1 FHD ◉');
+      expect(hits.single.title, 'Le 13h');
+    });
+
+    test('indexe chaque display-name, pas seulement le premier', () {
+      final now = DateTime.now().toUtc();
+      final index = service.parseForTest('''
+<tv>
+  <channel id="x.fr"><display-name>Premier Nom</display-name><display-name>Second Nom</display-name></channel>
+  <programme start="${_stamp(now)}" stop="${_stamp(now.add(const Duration(hours: 1)))}" channel="x.fr"><title>T</title></programme>
+</tv>
+''');
+      expect(index[XmltvEpgService.normalizeKey('Second Nom')], isNotNull);
+    });
+  });
+
   group('parseXmltvDate', () {
     test('applique le décalage horaire annoncé', () {
       expect(

docker-compose.prod.yml

@@ -9,7 +9,7 @@ services:
       - MAX_CONCURRENT_RECORDINGS=2
       # Source XMLTV de repli, utilisée seulement quand le panneau ne rend
       # aucun programme actuel. Vider la variable coupe tout appel sortant.
-      - EPG_XMLTV_URLS=https://epgshare01.online/epgshare01/epg_ripper_FR1.xml.gz
+      - EPG_XMLTV_URLS=https://epgshare01.online/epgshare01/epg_ripper_FR1.xml.gz,https://epgshare01.online/epgshare01/epg_ripper_CH1.xml.gz,https://epgshare01.online/epgshare01/epg_ripper_BE2.xml.gz
       - NVIDIA_GPU=true
     volumes:
       - xtremflow-data:/app/data

docker-compose.yml

@@ -27,7 +27,7 @@ services:
       # aucun programme couvrant l'instant présent. Vider la variable coupe
       # tout appel sortant : l'EPG se limite alors au panneau de l'abonné.
       # Plusieurs dumps se séparent par des virgules.
-      - EPG_XMLTV_URLS=${EPG_XMLTV_URLS-https://epgshare01.online/epgshare01/epg_ripper_FR1.xml.gz}
+      - EPG_XMLTV_URLS=${EPG_XMLTV_URLS-https://epgshare01.online/epgshare01/epg_ripper_FR1.xml.gz,https://epgshare01.online/epgshare01/epg_ripper_CH1.xml.gz,https://epgshare01.online/epgshare01/epg_ripper_BE2.xml.gz}
       # Accélération GPU NVIDIA pour le transcodage (NVENC) : true/false
       - NVIDIA_GPU=${NVIDIA_GPU:-false}
     restart: unless-stopped

test/web/xf_player_core_test.mjs

@@ -101,6 +101,130 @@ test('live : le retard est résorbé en douceur (liveSync) plutôt que par sauts
   assert.ok(c.liveSyncMaxLatency <= c.liveBufferLatencyMaxLatency);
 });
 
+test('télémétrie : une coupure (waiting → playing) est remontée avec sa durée', async () => {
+  const sent = [];
+  const listeners = {};
+  const video = {
+    addEventListener(type, fn) { (listeners[type] ||= []).push(fn); },
+    removeEventListener() {},
+    canPlayType: () => '',
+    play: () => Promise.resolve(),
+    buffered: { length: 0 },
+    seekable: { length: 0 },
+    currentTime: 12,
+    playbackRate: 1,
+  };
+  const fire = (type) => (listeners[type] || []).forEach((fn) => fn());
+  const window = {
+    addEventListener() {}, removeEventListener() {},
+    console: { log() {} },
+    location: { origin: 'https://xf.test', href: 'https://xf.test/', search: '' },
+    parent: { postMessage() {} },
+    localStorage: { getItem: () => 'tok' },
+  };
+  let now = 1000;
+  const context = vm.createContext({
+    window,
+    location: window.location,
+    document: { addEventListener() {}, removeEventListener() {} },
+    URLSearchParams,
+    setInterval: () => 0,
+    clearInterval() {},
+    setTimeout,
+    Date: { now: () => now },
+    fetch: (url, opts) => { sent.push({ url, body: JSON.parse(opts.body) }); return Promise.resolve(); },
+  });
+  vm.runInContext(source, context);
+  const player = new window.XFPlayer({ video, url: '/api/live/554034/turbo.ts', type: 'live' });
+  player._wireVideoEvents();
+
+  fire('playing');            // premier affichage
+  now += 1000; fire('waiting');
+  now += 4200; fire('playing'); // reprise 4,2 s plus tard
+
+  const stall = sent.map((s) => s.body).find((b) => b.event === 'stall');
+  assert.ok(stall, 'aucun événement stall envoyé');
+  assert.equal(stall.ms, 4200);
+  assert.equal(stall.ch, '554034');
+  assert.equal(sent[0].url, '/api/player-log');
+});
+
+// Freeze mesuré en prod (télémétrie) : le panneau s'est tu ~15-20 s sur une
+// connexion restée ouverte, alors que le lecteur n'avait gardé que 11-16 s.
+const PROVIDER_OUTAGE_S = 18;
+
+test('live : la réserve visée couvre un silence du panneau de ~18 s', () => {
+  const c = liveMpegtsConfig();
+  // liveSync ramène le retard vers la cible : c'est la réserve en régime
+  // établi. Elle doit dépasser le silence mesuré.
+  assert.ok(c.liveSyncTargetLatency > PROVIDER_OUTAGE_S,
+    `cible ${c.liveSyncTargetLatency}s < silence mesuré ${PROVIDER_OUTAGE_S}s`);
+  assert.ok(c.liveBufferLatencyMinRemain > PROVIDER_OUTAGE_S);
+});
+
+test('live : la rafale de rattrapage après un silence ne fait pas sauter le programme', () => {
+  // Mesuré en prod : après un silence, le panneau renvoie d'un coup tout le
+  // retard ; l'avance a dépassé 45 s et le lecteur a sauté 2 fois de 20 s
+  // (programme perdu). Le retard doit se résorber en douceur (liveSync).
+  const observedPeakAhead = 45;
+  const c = liveMpegtsConfig();
+  assert.ok(c.liveBufferLatencyMaxLatency >= 2 * observedPeakAhead - 10,
+    `saut dès ${c.liveBufferLatencyMaxLatency}s d'avance : la rafale de rattrapage le déclenche`);
+  assert.ok(c.liveSyncMaxLatency < observedPeakAhead,
+    'liveSync doit déjà accélérer avant ce niveau');
+});
+
+test('live : la vidéo déjà vue est purgée plus tôt, l\'avance étant plus grande', () => {
+  const c = liveMpegtsConfig();
+  assert.ok(c.autoCleanupMaxBackwardDuration <= 30);
+});
+
+test('reprise après coupure : attendre une vraie réserve avant de relire', () => {
+  const calls = [];
+  const listeners = {};
+  let ahead = 0;
+  const video = {
+    addEventListener(type, fn) { (listeners[type] ||= []).push(fn); },
+    removeEventListener() {},
+    canPlayType: () => '',
+    play: () => { calls.push('play'); return Promise.resolve(); },
+    pause: () => { calls.push('pause'); },
+    get buffered() { return { length: 1, start: () => 0, end: () => 100 + ahead }; },
+    seekable: { length: 0 },
+    currentTime: 100,
+    playbackRate: 1,
+    seeking: false,
+  };
+  const fire = (type) => (listeners[type] || []).forEach((fn) => fn());
+  const window = {
+    addEventListener() {}, removeEventListener() {},
+    console: { log() {} },
+    location: { origin: 'https://xf.test', href: 'https://xf.test/', search: '' },
+    parent: { postMessage() {} },
+  };
+  const context = vm.createContext({
+    window, location: window.location,
+    document: { addEventListener() {}, removeEventListener() {} },
+    URLSearchParams, setInterval: () => 0, clearInterval() {}, setTimeout, Date,
+  });
+  vm.runInContext(source, context);
+  const player = new window.XFPlayer({ video, url: '/api/live/1/turbo.ts', type: 'live' });
+  player.mpegts = {}; // flux MPEG-TS en cours
+  player._wireVideoEvents();
+
+  fire('playing');
+  fire('waiting');            // le panneau se tait
+  assert.deepEqual(calls.slice(-1), ['pause'], 'le lecteur doit se mettre en attente');
+
+  ahead = 1;                  // 1 s arrive : trop peu, ne pas repartir
+  player._checkHold();
+  assert.ok(!calls.slice(1).includes('play'), 'reparti avec 1 s : recoupera aussitôt');
+
+  ahead = 5;                  // vraie réserve reconstituée
+  player._checkHold();
+  assert.equal(calls.at(-1), 'play');
+});
+
 test('live : le buffer déjà lu est purgé (sinon QuotaExceeded en séance longue)', () => {
   const c = liveMpegtsConfig();
   assert.equal(c.autoCleanupSourceBuffer, true);

web/player_lite.html

@@ -141,6 +141,12 @@
 
             // Contrat historique du lite : mise en pause manuelle → overlay lecture.
             video.addEventListener('pause', function () {
+                // Pause technique : le lecteur attend que la réserve se
+                // reconstitue après une coupure, il repartira seul.
+                if (player && player._holding) {
+                    showLoading('Reconstitution de la réserve');
+                    return;
+                }
                 if (video.currentTime === 0 || video.paused) {
                     loading.style.display = 'none';
                     playOverlay.style.display = 'flex';

web/xf-player-core.js

@@ -58,6 +58,14 @@
   // Erreurs MPEG-TS tolérées sur 60 s avant de basculer sur HLS.
   var MPEGTS_MAX_ERRORS = 3;
 
+  // Après une coupure en direct, réserve à reconstituer avant de relire.
+  // Repartir dès la première seconde reçue transformait un silence du
+  // panneau en cascade de micro-coupures (6,3 s puis 1,7 s puis 2,0 s,
+  // mesuré) ; comme mpv (cache-pause), on attend une vraie réserve.
+  var REBUFFER_SECONDS = 4;
+  // Au-delà, on relance quand même avec ce qu'on a.
+  var REBUFFER_MAX_WAIT_MS = 15000;
+
   // ------------------------------------------------------------------
   // Chargement paresseux des libs (aucune requête inutile)
   // ------------------------------------------------------------------
@@ -190,8 +198,75 @@
     // ça, une relance après échec laisserait l'ancienne instance réagir aux
     // commandes du parent et republier des positions périmées.
     this._listeners = [];
+
+    // Télémétrie des incidents (voir _report) : chaque freeze vécu par
+    // l'utilisateur finit dans les logs du serveur, avec sa cause.
+    this._t0 = Date.now();
+    this._session = Math.random().toString(36).slice(2, 8);
+    var idMatch = /\/api\/(?:live|vod|recordings\/stream)\/([^/?#.]+)/.exec(this.url || '');
+    this._channel = idMatch ? idMatch[1] : '';
+    this._stallSince = null;
+    this._stats = { stalls: 0, stallMs: 0, seeks: 0, errors: 0 };
+    this._lastPos = 0;
+    var self = this;
+    var userOnError = this.onError;
+    this.onError = function (msg) {
+      self._report('error_shown', { detail: String(msg) });
+      userOnError(msg);
+    };
   }
 
+  // ---------------- Télémétrie ----------------
+
+  /** Secondes d'avance dans le buffer à la position courante. */
+  XFPlayer.prototype._bufferAhead = function () {
+    var v = this.video;
+    try {
+      for (var i = 0; i < v.buffered.length; i++) {
+        if (v.buffered.start(i) <= v.currentTime + 0.5 &&
+            v.buffered.end(i) >= v.currentTime) {
+          return v.buffered.end(i) - v.currentTime;
+        }
+      }
+    } catch (e) {}
+    return 0;
+  };
+
+  /**
+   * Remonte un incident au serveur (`POST /api/player-log`, écrit dans les
+   * logs `[Player] …`). Jamais bloquant : erreurs ignorées, aucun envoi
+   * sans session.
+   */
+  XFPlayer.prototype._report = function (event, data) {
+    try {
+      var token = null;
+      try { token = global.localStorage.getItem('auth_token'); } catch (e) {}
+      if (!token || typeof fetch !== 'function') return;
+      var payload = {
+        event: event,
+        session: this._session,
+        ch: this._channel,
+        t: (Date.now() - this._t0) / 1000,
+        mode: this.hls ? 'hls' : (this.mpegts ? 'ts' : 'direct'),
+        profile: this.profile.name,
+        buffer: this._bufferAhead(),
+        pos: this.video.currentTime || 0
+      };
+      for (var k in data) {
+        if (Object.prototype.hasOwnProperty.call(data, k)) payload[k] = data[k];
+      }
+      fetch('/api/player-log', {
+        method: 'POST',
+        keepalive: true,
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': 'Bearer ' + token
+        },
+        body: JSON.stringify(payload)
+      }).catch(function () {});
+    } catch (e) {}
+  };
+
   /** addEventListener + mémorisation pour un retrait propre. */
   XFPlayer.prototype._on = function (target, type, handler, options) {
     target.addEventListener(type, handler, options);
@@ -224,6 +299,7 @@
     var isLive = this.type === 'live';
 
     this.onLoading('Ouverture du flux');
+    this._report('start', {});
 
     // Safari / iOS : HLS natif = le chemin le plus rapide, aucune lib à charger.
     if (isHls && this._canPlayNativeHls()) {
@@ -345,6 +421,8 @@
       hls.on(Hls.Events.ERROR, function (e, d) {
         if (!d.fatal) return;
         self.log('Erreur HLS fatale : ' + d.details);
+        self._stats.errors++;
+        self._report('hls_error', { detail: d.type + '/' + d.details });
         if (d.type === Hls.ErrorTypes.NETWORK_ERROR) {
           // Playlist jamais obtenue (transcodeur en échec → 502, serveur trop
           // chargé → délai dépassé), après les relances internes de hls.js.
@@ -427,20 +505,34 @@
         // coupure toutes les 3-4 s et contenu sauté (12 sauts et 14 coupures
         // en 30 s sur une chaîne FHD). La marge de 12 s couvre deux silences ;
         // le saut ne sert plus qu'à borner un retard réellement accumulé.
+        //
+        // 25 s et non plus 12 : la télémétrie a mesuré un silence du panneau
+        // de ~15-20 s sur une connexion restée ouverte, alors que le lecteur
+        // n'avait gardé que 11-16 s — il venait de « consommer » à x1,1
+        // l'avance que le panneau envoie au démarrage. On la garde : ~25 s
+        // de retard sur le direct, en échange d'une lecture qui traverse ces
+        // silences sans figer.
+        //
+        // Saut seulement au-delà de 90 s : après un silence, le panneau
+        // renvoie d'un coup tout le retard. Avec un seuil à 45 s, l'avance
+        // le dépassait et le lecteur sautait 20 s de programme (2 fois en
+        // 1 min, mesuré). liveSync résorbe désormais cet excédent en douceur.
         liveBufferLatencyChasing: isLive,
-        liveBufferLatencyMaxLatency: 30,
-        liveBufferLatencyMinRemain: 12,
-        // Au-delà de 20 s de retard, accélérer légèrement (x1,1) jusqu'à
-        // revenir à 12 s : rattrapage invisible, sans saut ni coupure.
+        liveBufferLatencyMaxLatency: 90,
+        liveBufferLatencyMinRemain: 25,
+        // Au-delà de 35 s de retard, accélérer légèrement (x1,1) jusqu'à
+        // revenir à 25 s : rattrapage invisible, sans saut ni coupure.
         liveSync: isLive,
-        liveSyncMaxLatency: 20,
-        liveSyncTargetLatency: 12,
+        liveSyncMaxLatency: 35,
+        liveSyncTargetLatency: 25,
         liveSyncPlaybackRate: 1.1,
         // Purge du buffer déjà lu : sans elle, une longue séance finit par
         // saturer le SourceBuffer (QuotaExceededError → erreur MPEG-TS).
+        // Avance jusqu'à 90 s : la vidéo déjà vue est purgée plus tôt pour
+        // rester sous le quota du SourceBuffer (~150 Mo en vidéo sur Chrome).
         autoCleanupSourceBuffer: true,
-        autoCleanupMaxBackwardDuration: 60,
-        autoCleanupMinBackwardDuration: 30,
+        autoCleanupMaxBackwardDuration: 30,
+        autoCleanupMinBackwardDuration: 15,
         lazyLoad: false
       }
     );
@@ -462,6 +554,7 @@
 
       self._audioFallbackDone = true;
       self.log('Aucune piste audio démuxée (codec non supporté) — bascule HLS');
+      self._report('fallback_hls', { detail: 'no_audio' });
       self.onLoading('Piste audio incompatible — réencodage');
 
       try {
@@ -479,6 +572,8 @@
     player.on(mpegts.Events.ERROR, function (type, detail) {
       self.log('Erreur MPEG-TS : ' + type + ' / ' + detail);
       if (self._destroyed) return;
+      self._stats.errors++;
+      self._report('mpegts_error', { detail: type + '/' + detail });
 
       // Chaque recréation relance un FFmpeg côté serveur : sur un serveur
       // déjà saturé, recréer sans fin toutes les 1,2 s ne faisait
@@ -503,6 +598,7 @@
           return;
         }
         self.log('Erreurs MPEG-TS répétées — bascule HLS');
+        self._report('fallback_hls', { detail: 'repeated_mpegts_errors' });
         self.onLoading('Ouverture du flux');
         self.url = hlsUrl;
         if (self._canPlayNativeHls()) self._playDirect(hlsUrl);
@@ -519,6 +615,7 @@
           player.detachMediaElement();
           player.destroy();
         } catch (e) {}
+        self._report('recreate', {});
         self._createMpegts(self._mpegtsIsLive);
       }, 1200);
     });
@@ -585,6 +682,7 @@
     var next = PROFILES[ORDER[idx + 1]];
     this.profile = next;
     this.log('Escalade buffer → ' + next.name + ' (' + reason + ')');
+    this._report('profile', { detail: reason });
     this.onProfileChange(next.name, reason);
 
     // HLS : les fenêtres de buffer sont modifiables à chaud, pas besoin de
@@ -602,6 +700,32 @@
     // recréation du lecteur (déclenchée par le handler d'erreur).
   };
 
+  /**
+   * Direct MPEG-TS à sec : se mettre en pause jusqu'à [REBUFFER_SECONDS] de
+   * réserve (voir la constante). HLS gère déjà sa propre reprise.
+   */
+  XFPlayer.prototype._holdUntilBuffered = function () {
+    if (this._holding || !this.mpegts || this.type !== 'live') return;
+    var self = this;
+    this._holding = true;
+    this._holdSince = Date.now();
+    try { this.video.pause(); } catch (e) {}
+    this._holdTimer = setInterval(function () { self._checkHold(); }, 250);
+  };
+
+  /** Relance la lecture dès que la réserve est reconstituée. */
+  XFPlayer.prototype._checkHold = function () {
+    if (!this._holding) return;
+    if (this._destroyed) { clearInterval(this._holdTimer); return; }
+    var waited = Date.now() - this._holdSince;
+    if (this._bufferAhead() < REBUFFER_SECONDS && waited < REBUFFER_MAX_WAIT_MS) {
+      return;
+    }
+    clearInterval(this._holdTimer);
+    this._holding = false;
+    this._attemptPlay();
+  };
+
   XFPlayer.prototype._noteStall = function () {
     if (!this._started) return; // les attentes d'amorçage ne comptent pas
     var now = Date.now();
@@ -628,18 +752,62 @@
     });
 
     this._on(v, 'playing', function () {
+      if (!self._started) {
+        self._report('first_frame', { ms: Date.now() - self._t0 });
+      }
+      if (self._stallSince !== null) {
+        var stallMs = Date.now() - self._stallSince;
+        self._stallSince = null;
+        // < 250 ms : imperceptible, ne pas noyer les logs.
+        if (stallMs >= 250) {
+          self._stats.stalls++;
+          self._stats.stallMs += stallMs;
+          self._report('stall', { ms: stallMs });
+        }
+      }
       self._started = true;
       self.onReady();
       self.send({ type: 'playback_status', status: 'playing' });
     });
 
     this._on(v, 'pause', function () {
+      // Pause posée par l'attente de réserve : pas une pause utilisateur,
+      // l'interface ne doit pas basculer sur « lecture ».
+      if (self._holding) return;
       self.send({ type: 'playback_status', status: 'paused' });
     });
 
-    this._on(v, 'waiting', function () { self._noteStall(); });
+    this._on(v, 'waiting', function () {
+      if (self._started && self._stallSince === null) {
+        self._stallSince = Date.now();
+      }
+      self._noteStall();
+      if (self._started) self._holdUntilBuffered();
+    });
     this._on(v, 'stalled', function () { self._noteStall(); });
 
+    // Sauts (rattrapage du direct, recherche) : d'où, vers où.
+    this._on(v, 'timeupdate', function () {
+      if (!v.seeking) self._lastPos = v.currentTime;
+    });
+    this._on(v, 'seeking', function () {
+      if (!self._started) return;
+      self._stats.seeks++;
+      self._report('seek', { from: self._lastPos, to: v.currentTime });
+    });
+
+    // Bilan toutes les 60 s : nombre et durée cumulée des coupures.
+    this._beatTimer = setInterval(function () {
+      if (!self._started) return;
+      self._report('heartbeat', {
+        stalls: self._stats.stalls,
+        stallMs: self._stats.stallMs,
+        seeks: self._stats.seeks,
+        errors: self._stats.errors,
+        rate: v.playbackRate
+      });
+    }, 60000);
+
     this._on(v, 'ended', function () {
       self.send({
         type: 'playback_ended',
@@ -781,6 +949,12 @@
           self._attemptPlay();
           break;
         case 'pause':
+          // Pause voulue par l'utilisateur : l'attente de réserve ne doit
+          // pas relancer la lecture derrière son dos.
+          if (self._holding) {
+            clearInterval(self._holdTimer);
+            self._holding = false;
+          }
           v.pause();
           break;
         case 'seek':
@@ -806,6 +980,8 @@
   XFPlayer.prototype.destroy = function () {
     this._destroyed = true;
     clearInterval(this._posTimer);
+    clearInterval(this._beatTimer);
+    clearInterval(this._holdTimer);
     this._listeners.forEach(function (l) {
       try { l.target.removeEventListener(l.type, l.handler); } catch (e) {}
     });